Khumbo Klein Chilamwa

Posted on Jul 11, 2023

The Ultimate Guide to Object-Oriented Programming in Python

#oop #python #programming #advance

Object-Oriented Programming, also known as OOP, is one of those important topics that any programmer needs to have full knowledge of. Before diving any deeper into this topic, let us define what OOP is in general and why it is a must-have skill for any programmer. OOP in Python is a method of structuring a program by bundling related properties and behaviors into individual objects.

Why OOP?

Object Oriented Programming comes with so many benefits for the programmer, some of these benefits are listed below:

Makes your code reusable
Makes your code clean and gives it a clear structure
Makes your code easy to maintain

The structure of OOP

Classes -These are user-defined data types that act as a blueprint for objects, methods, and attributes or they are containers of objects, methods, and attributes
Objects -These are instances of a class created with specifically defined data
Methods -These are functions defined inside a class describing the behavior of objects
Attributes -These represent the state of objects in a class

Creating our first class

We can create a class using the class keyword followed by the class name and a colon at the end.
Syntax:

class ClassName:
    statement1
        .
        .
    statementN

Example1: Creating a Car class

class Car:
    pass

If you do print(type(Car)) you will get the below output:

Class objects

An object is an instance of a class and it must be known that we can have as many objects as possible from a class. The process of creating a class object is also called object instantiating, you can only create an object for a class that exists.
Syntax:

object_name = ClassName()

Example2: Creating a class object

audi = Car()

audi is an object for the class Car

Creating a class and its objects

# creating a class Car
class Car:
    pass
# instantiating the Car class
car1 = Car()
car2 = Car()
# creating attributes for instances car1 and car2
car1.name = "Audi A7"
car2.name = "Nissan Demio"
car1.year_made = "2000"
car2.year_made = "1994"
# printing the output
print(car1.name, "was built in", car1.year_made)
print(car2.name, "was built in", car2.year_made)

Output:

Methods

These are functions defined inside a class describing the behavior of objects tied to that class. Methods inside a class will always take self as the first parameter.
Example3: Creating methods inside a class

# creating a class Car
class Car:
    # initializing method(one of the special methods)
    # called everytime an instance is created
    # takes self always
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made
    # normal method to return the car info   
    def carInformation(self):
        return self.name + " was built in " + self.year_made

#instantiating class objects 
car1 = Car("Audi A7", "2000")
car2 = Car("Nissan Demio", "1994")
# calling the carInformation() method
print(car1.carInformation())
print(car2.carInformation())

Output:

Note:
Any object has access to everything contained in the class, for example, object car1 has access to method carInformation().

Let us now talk about the __init__ or dunder init method also known as the constructor, this method is used to initialize an instance, and the name is fixed (cannot be renamed to anything). It is inside the __init__ method that we define or instantiate the class attributes, apart from attributes self is another parameter that __init__ method takes.

def __init__(self, name, year_made):
    self.name = name
    self.year_made = year_made

Other special methods used in classes

●__str__ is used for displaying data in a beautiful way
Example:

# creating a class Car
class Car:
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made
    #the __str__ function for display pretty output 
    def __str__(self):
        return self.name
# instantiating an object
car1 = Car("Range Rover", "2019")
# calling the whole object
print(car1)

Output:

●__repr__ is used for logging and debugging
Example:

# creating a class Car
class Car:
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made
    #the __repr__ function for display pretty output 
    def __repr__(self):
        return self.name
# instantiating an object
car1 = Car("Range Rover", "2019")
# calling the whole object
print(car1)

Output:

Note:
The __str__ and __repr__ do not differ much in nature

Class and instance variables

As you are creating your classes you might want to work with class variables or instance variables or work with both, so how do these two differ then? The below table explains everything:

Example4: Class variables

# creating a class Car
class Car:
    # creating the class variable after class definition
    maximum_speed = "210 km/hr"
    # initializing method(one of the special methods)
    # called everytime an instance is created
    # takes self always
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made
    # normal method to return the car info   
    def carInformation(self):
        return self.name + " was built in " + self.year_made

#instantiating class objects 
car1 = Car("Audi A7", "2000")
# calling the carInformation() method
print(car1.carInformation())
# accessing class and instance variable using the object
print(car1.name, "has maximum speed of", car1.maximum_speed)

Output:

Example5: Instance variables

# creating the class
class Car:
    # initializing method
    def __init__(self, name, year_made):
        # 2 instance variables name and year_made
        self.name = name
        self.year_made = year_made
#instantiating the class object   
car1 = Car("Audi A7", "2000")
# car1.name and car1.year_made accesses instance variables
print("Car name:", car1.name)
print("Year made:", car1.year_made)

Output:

Inheritance

Inheritance in Object Oriented Programming is a concept where a new class is created using an already existing class. As you are inheriting from a class, it means you are getting the methods, and attributes of that class, in short, you are getting everything contained in that class.

Why inheritance?

Inheritance allows the reusability of code, this means that we do not have to write the same code over and over again, and we can easily reuse a method with the same or modified data.

Types of inheritance

Single inheritance - a child class inherits from only one parent class Syntax:

class ParentClass:
    statement(s)

class ChildClass(ParentClass):
    statement(s)

Multiple inheritance - a child class inherits from multiple parent classes Syntax:

class ParentClass:
    statement(s)

class AnotherParentClass:
    statement(s)

class ChildClass(ParentClass, AnotherParentClass):
    statement(s)

Example1: Using inheritance

class Car:
    # creating class variables
    maximum_speed = "210 km/hr"
    number_of_tyres = 4
    # the dunder init method/initializer
    def __init__(self, name, year_made):
        self.name = name
        self.year_made = year_made

# class Minibus inheriting from class Car
class Minibus(Car):
    # __init__ method of class Minibus
    def __init__(self, name, year_made, price):
        self.name = name
        self.year_made = year_made
        self.price = price
    # method to return price
    def carPrice(self):
        return self.price
# instantiating the object for class Minibus
minbus1 = Minibus("Vanetti", "2013", "MWK4500000")
# printing data
print("Name:", minbus1.name)#name for Minibus class
print("Year made:", minbus1.year_made)#year for Minibus class
print("Maximum speeed:", minbus1.maximum_speed)#max_speed inherited from Car
print("Number of tyres:", minbus1.number_of_tyres)#number_of_tyres inherited from Car
print("Price:", minbus1.carPrice())#calling the carPrice() method in Minibus

Output:

Encapsulation

As you are writing your programs in an Object Oriented Programming way, situations arise where you want your class data not to be modified in any way, to solve this encapsulation comes into play. Encapsulation is defined as a way of restricting access to methods and variables available in a class. Using encapsulation, you can make your class attributes private or protected.

Private - These attributes are invisible and inaccessible from outside the class itself

Syntax:

def __init__(self, name, year_made):
    self.__year_made = year_made#this attribute is private

We use double underscores __ to denote a private attribute

Example2: Creating a private attribute

# creating our class Car
class Car:
    # initializing attribute name via __init__
    def __init__(self, name):
        self.__name = name#this is a private attribute

#instantiating an object   
car1 = Car("BMW")
# printing the private attribute
print(car1.name)

Output:

We are getting an error because the private attribute is invisible and inaccessible outside the class

Protected - This attribute can only be accessed via a subclass but it’s possible to access them outside the class

Syntax:

def __init__(self, name, year_made):
    self._name = name#this attribute is protected

We use a single underscore _ to denote a protected attribute
Example3: creating a protected attribute

# creating our class Car
class Car:
    # initializing attribute name via __init__
    def __init__(self, name):
        self._name = name#this is a protected attribute

#instantiating an object   
car1 = Car("BMW")
# printing the protected attribute
print(car1._name)

Output:

To access the protected attribute outside the class, we use a single underscore before the attribute name e.g. car1._name

Note:
Attributes without any underscores are said to be public, this means they are visible and accessible even from outside the class itself using an object.

Polymorphism

Poly means many and morphism means forms, so polymorphism means having many forms. In Python, polymorphism means the same function name is used in different ways.
Example4: Using polymorphism

# creating class Square
class Square:
    # initializer
    def __init__(self, side):
        self.side = side 
    # common method
    def calculate_area(self):
        return self.side * self.side
# creating class Triangle
class Triangle:
    # initializer
    def __init__(self, base, height):
        self.base = base
        self.height = height
    # common method
    def calculate_area(self):
        return 0.5 * self.base * self.height
# instantiating class objects
sq = Square(6)
tri = Triangle(2, 7)
# printing results
print("Area of square: ", sq.calculate_area())
print("Area of triangle: ", tri.calculate_area())

Output:

In our two classes, we have created a common method calculate_area() that is being used in different ways, that is calculating the area of a square and a triangle.

Conclusion

In summary, mastering object-oriented concepts is a must-have skill for any developer. Following an object-oriented paradigm when writing your code makes it cleaner, maintainable, and reusable.