Object-oriented programming (OOP) is the most widely used programming paradigm. It enables you to organize and manage code in a structured way. Like other general-purpose programming languages such as Java, C++, and C#, Python also supports OOP concepts, making it an OOP language. To learn more about Python OOPs and how to apply them effectively in your projects, you have come to the right place.
Let’s get started!
What Is OOPs in Python?
Python supports OOPs, which allows you to write reusable and maintainable Python programs using objects and classes. An object is a specific instance of a class that represents a real-world entity, such as a person, vehicle, or animal. Each object is bundled with attributes (characteristics) and methods (functions) to describe what it is and what it can do. A class is like a blueprint or template that defines the attributes and functions every object should have.
An OOP Example
Let’s understand this clearly by considering a scenario where you are designing a system to manage vehicles. Here, a class can be a template for different types of vehicles. Each class will describe common vehicle characteristics like color, brand, and model, along with functions such as starting or stopping.
For instance, you might have a class called “Car,” which has these attributes and behaviors. Then, an object would be a specific car, such as a red Mercedes Benz. This object has all the features defined in the class but with particular details: “red” for color, “Mercedes Benz” for brand, and “Cabriolet” for the model. Another object could be a yellow Lamborghini, which has “yellow” for color, “Lamborghini” for the brand, and “Coupe” for the model.
In this way, the class is a blueprint, while the object is a unique instance of that blueprint with real-world information.
How Do You Implement Classes and Objects in Python?
To create a class in Python, you must use a keyword class as follows:
class classname:
<statements> For example,
class demo:
name = "XYZ"Once you define a class, you can use it to create objects using the following syntax:
object_name = classname()
print(object_name.field_name)For instance,
Object1 = demo()
print(Object1.name)This will produce XYZ as output.
Instance Attributes and Methods
Each object (instance) of a class can have its own attributes. In the above example, Car is a class with attributes like color, model, and brand. Using an __init__ method, you can initialize these attributes whenever a new object is created. You can pass any number of attributes as parameters to the __init__method, but the first one must always be named self. When you create a new instance of a class, Python automatically forwards that instance to the self parameter. This allows you to ensure that attributes like color, brand, and model are specific to an object rather than being shared among all instances.
Objects can also have methods, which are functions that belong to a class and work with specific instances of that class. They use an object’s attributes to perform an action. The first parameter of an instance method is always self, which refers to the object on which the method is being called. Using self parameter, the object methods can access and modify the attributes in the current instance. Inside an instance method, you can use a self to call other methods of the same class for the specific instance.
To get more idea on this, let’s create a simple implementation for the Car class using classes and objects:
# Define the Car class
class Car:
def __init__(self, color, brand, model):
self.color = color # Attribute for color
self.brand = brand # Attribute for brand
self.model = model # Attribute for model
# Start Method for Car
def start(self):
print(f"The {self.color} {self.brand} {self.model} is starting.")
# Stop Method for Car
def stop(self):
self.start() # Calling another method
print(f"The {self.color} {self.brand} {self.model} is stopping.")
# Creating two objects of the Car class
car1 = Car("red", "Mercedes Benz", "Cabriolet")
car2 = Car("yellow", "Lamborghini", "Coupe")
# Calling the methods of the Car class to execute Car1 object
car1.start()
car1.stop()
# Calling the methods of the Car class to execute Car2 object
car2.start()
car2.stop() Click here to try the given program and customize it according to your needs.
Here is a sample output:
The above program demonstrates how OOP helps in modeling real-world entities and how they interact with each other.
Key Principles of OOP
Apart from classes and objects, there are four more principles that make Python an object-oriented programming language. Let’s take a look at each of them:
Inheritance
Inheritance is a key concept in OOPs that provides the ability for one class to inherit the attributes and methods of another class. A class that derives these characteristics is referred to as the child class or derived class. On the other hand, the class from which data and functions are inherited is known as the parent class or base class.
By implementing inheritance in Python programs, you can efficiently reuse the existing code in multiple classes without rewriting it. This is done by creating a base class with common properties and behaviors. Then, you can derive child classes that inherit the parent class functionality. In the derived classes, you have the flexibility to add new features or override existing methods by preserving the base class code.
Types of Python Inheritance
Single Inheritance
In single inheritance, a child class helps you inherit from one base class. Let’s extend the above Car class to model a vehicle management system through single inheritance:
# Define the Vehicle class (Parent class)
class Vehicle:
def __init__(self, color, brand, model):
self.color = color
self.brand = brand
self.model = model
# Start Method for Vehicle
def start(self):
print(f"The {self.color} {self.brand} {self.model} is starting.")
# Stop Method for Vehicle
def stop(self):
print(f"The {self.color} {self.brand} {self.model} is stopping.")
class Car(Vehicle): # Car is a child class that inherits from the Vehicle class
# Defining function for Car
def carfunction(self):
print("Car is functioning")
# Creating an object of the Car class
car1 = Car("red", "Mercedes Benz", "Cabriolet")
# Calling the methods
car1.start()
car1.carfunction()
car1.stop() Sample Output:
Hierarchical Inheritance
In hierarchical inheritance, multiple derived classes inherit from a single base class, which helps different child classes to share functionalities. Here is the modified vehicle management program to illustrate hierarchical inheritance:
class Bike(Vehicle): # Bike inherits from Vehicle
def kick_start(self):
print("Bike is kick-started.")
class Jeep(Vehicle): # SportsBike inherits from Bike
def off_road(self):
print("Jeep is in off-road mode!")
# Creating an object of Bike and Jeep child class
bike1 = Bike("yellow", "Kawasaki", "Ninja")
jeep1 = Jeep("Black", "Mahindra", "Thar")
bike1.kick_start()
bike1.start()
bike1.stop()
jeep1.off_road()
jeep1.start()
jeep1.stop()Sample Output:
Multilevel Inheritance
Multilevel inheritance is referred to as a chain of inheritance, which enables a child class to inherit from another child class. Here is the code fragment demonstrating multilevel inheritance that you can add to the above vehicle management program:
class SportsBike(Bike): # SportsBike inherits from Bike
def drift(self):
print(f"The {self.color} {self.brand} {self.model} is drifting!")
# Creating an object of SportsBike
sports_bike = SportsBike("yellow", "Kawasaki", "Ninja")
sports_bike.start()
sports_bike.kick_start()
sports_bike.drift()
sports_bike.stop()Sample Output:
Multiple Inheritance
In multiple inheritance, a derived class can inherit from more than one base class. This helps the child class to combine functions of multiple parent classes. Let’s include one more parent class in the vehicle management program to understand the multiple inheritance concept:
# Define the Vehicle class
class Vehicle:
def __init__(self, color, model):
self.color = color # Attribute for color
self.model = model # Attribute for model
def start(self):
print(f"The {self.color} {self.model} is starting.")
def stop(self):
print(f"The {self.color} {self.model} is stopping.")
# Define the Manufacturer class
class Manufacturer:
def __init__(self, brand):
self.brand = brand # Attribute for brand
def get_brand(self):
print(f"This vehicle is manufactured by {self.brand}.")
# Define the Car class that inherits from both the Vehicle and the Manufacturer
class Car(Vehicle, Manufacturer):
def __init__(self, color, model, brand):
Vehicle.__init__(self, color, model)
Manufacturer.__init__(self, brand)
def show_details(self):
self.get_brand()
print(f"The car is a {self.color} {self.brand} {self.model}.")
# Creating an object of Car
car = Car("red", "Cabriolet", "Mercedes Benz")
car.start()
car.show_details()
car.stop()Sample Output:
Polymorphism
Polymorphism refers to the capability of different objects to respond in multiple ways using the same method or function call. Here are the four ways to achieve polymorphism in Python:
Duck Typing
In duck typing, Python allows you to use an object based on its attributes and method instead of its type. This indicates that it only considers if the object has a required method and provides support for dynamic typing in Python.
For example, if an object looks like a list, Python will consider it a list type. With duck typing, you can focus on what an object can do instead of worrying about its specific type.
Let’s look at an example of how duck typing is implemented in Python:
# Define a class Dog with a method speak
class Dog:
def speak(self):
return "Yes, it barks bow bow"
# Define a class Cat with a method speak
class Cat:
def speak(self):
return "Yes, it cries meow meow"
# Function that takes any animal object and calls its speak method
def animal_sound(animal):
return animal.speak() # Calls the speak method of the passed object
# Create instances of Dog and Cat
dog = Dog()
cat = Cat()
# Call animal_sound function with the dog and cat objects, printing their sounds
print(animal_sound(dog))
print(animal_sound(cat))Sample Output:
In the above code, the animal_sound() function works with any object passed to it as long as that object has a speak() method. The animal_sound() function does not check if the object is an instance of Dog, Cat, or another class; it just calls speak() on the object, assuming it will behave as expected. This flexibility through the duck typing concept enables the Python compiler to focus on what an object can do rather than its actual type or class.
Method Overriding
Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its parent class.
Here is an example:
# Base class Vehicle with a start method
class Vehicle:
def start(self):
return "Vehicle is starting."
# Subclass Car that inherits from Vehicle and overrides the start method
class Car(Vehicle):
def start(self):
return "Car is starting."
# Creating instances of Vehicle and Car
vehicle = Vehicle()
car = Car()
print(vehicle.start())
print(car.start())Sample Output:
Method Overloading
Python does not support traditional method overloading as Java does. However, you can implement it using default arguments or handling different input types. Let’s see an example:
class Calculator:
def add(self, a, b=None):
if b is not None:
return a + b
return a
# Create an instance of the Calculator class
calc = Calculator()
# Calling the add method with two arguments
print(calc.add(5, 10))
# Calling the add method with one argument
print(calc.add(5)) Sample Output:
Operator Overloading
Operator overloading allows you to define custom methods for standard operators like + or -.
Here is an example:
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)
def __repr__(self):
return f"Point({self.x}, {self.y})"
p1 = Point(2, 3)
p2 = Point(4, 1)
p3 = p1 + p2
print(p3) Sample Output:
Encapsulation
Encapsulation is the practice of restricting direct access to certain attributes and methods of an object to protect data integrity. In Python, you can achieve data encapsulation by prefixing an attribute with a single underscore (_) or a double underscore (__).
Attributes marked with a single underscore are considered protected. These attributes can be accessed from within the classes and their derived classes but not from outside the class. If the attributes prefixed with a double underscore are private, they are intended to be inaccessible from within or outside the class. This mechanism ensures better data security and helps you maintain the internal state of an object.
Let’s see an example to achieve encapsulation in Python:
class Person:
def __init__(self, name, age, phone_number):
self.name = name # Public attribute
self.age = age # Public attribute
self._email = None # Protected attribute
self.__phone_number = phone_number # Private attribute
def get_phone_number(self):
return self.__phone_number # Public method to access the private attribute
def set_phone_number(self, phone_number):
self.__phone_number = phone_number # Public method to modify the private attribute
def set_email(self, email):
self._email = email # Public method to modify the protected attribute
def get_email(self):
return self._email # Public method to access the protected attribute
# Creating an instance of the Person class
person = Person("Xyz", 20, "9863748743")
# Accessing public attributes
print(person.name)
print(person.age)
# Accessing protected attribute
person.set_email("xyz@sample.com")
print(person.get_email())
# Accessing a private attribute using public methods
print(person.get_phone_number())
# Modifying the private attribute using a public method
person.set_phone_number("123456789")
print(person.get_phone_number())Sample Output:
Data Abstraction
Abstraction helps you hide complex implementation details and only show an object’s essential features. The Abstract Base Classes (ABC) module allows you to implement data abstraction in your Python program through abstract classes and methods.
Here is an example of implementing abstraction:
# Importing ABC module to define abstract classes
from abc import ABC, abstractmethod
# Defining an abstract class Animal that inherits from ABC
class Animal(ABC):
# Declaring an abstract method move that must be implemented by subclasses
@abstractmethod
def move(self):
pass # No implementation here; subclasses will provide it
# Defining a class Bird that inherits from the abstract class Animal
class Bird(Animal):
# Implementing the abstract method move for the Bird class
def move(self):
print("Flies")
# Creating an instance of the Bird class
bird = Bird()
bird.move()Sample Output:
Use Cases of Python OOPs
- Game Development: Python OOPs help you create maintainable code by defining classes for game entities such as characters, enemies, and items.
- Web Development: OOP concepts enable you to develop web applications by organizing the code into classes and objects.
- GUI Applications: In GUI development, utilizing OOP concepts allows you to reuse the code of the components like buttons and windows. This will enhance the organization and scalability of your application.
- Data Analysis: In Python, you can structure data analysis workflows using classes, encapsulating required data processing methods and attributes.
10 Best Practices for OOP in Python
- You must use a descriptive naming convention, follow the CapWords for classes, and lowercase with an underscore for attributes and methods.
- Ensure each class has only one responsibility to reduce the complexity of modifying it according to the requirements.
- Reuse code through functions and inheritance to avoid redundancy.
- You must add comments next to your Python classes and methods with docstrings (“””) to understand the code in flow.
- Optimize your memory usage using the __slots__ method in your classes.
- Keep inheritance hierarchies simple to maintain readability and manageability in your code.
- Minimize the number of arguments in your methods to improve the code clarity and fix the errors quickly.
- Utilize duck typing or other polymorphism techniques to write a flexible program that adapts to varying data types.
- Write unit tests for your classes to ensure that modifications do not break existing functionality.
- Leverage lazy loader packages to initialize the objects on demand, which can improve performance and resource management in your application.
Conclusion
You have explored Python OOPs with examples in this article. By understanding key OOP concepts like classes, objects, inheritance, polymorphism, encapsulation, and abstraction, you are well-equipped to build scalable Python applications. The various use cases highlighted show the versatility of OOP in applications ranging from game development to data analysis. In addition, following the recommended best practices ensures that your OOP implementations remain clean, efficient, and reliable.
FAQs
How do you modify properties on objects?
You can modify the properties of an object by directly accessing them and assigning new values.
For example:
class Car:
def __init__(self, color):
self.color = color
my_car = Car("red")
print(my_car.color)
# Modifying the car color from red to yellow
my_car.color = "yellow"
print(my_car.color)Can you delete properties on objects?
Yes, you can delete the object attributes using the del keyword.
How do static methods and class methods differ from instance methods in Python?
Instance methods operate on an object and can access its properties using self parameter. In contrast, class methods work on the class itself and are defined with the @classmethod decorator. They accept cls as the first parameter. Compared to these methods, static methods do not accept any parameters. It is defined with a @staticmethod decorator and cannot access or modify class or object data.
