Object Oriented Programming in Python

By Object Oriented Programming in Python

In the this article, we learnt OOP concepts in Java. In this article we are going to see what Object Oriented Programming in another programming language, Python. Object-Oriented Programming is a programming paradigm that organizes data around the idea of objects. We can define an object as a real-world entity that has attributes and behaviors. In Object-Oriented Programming, there are terms that we need to get familiar with so as to understand the whole idea behind OOP. These terms are "class", "object", "attributes” and “methods”. Code with OOP design is flexible, modular, and abstract. This makes it particularly useful when you create larger programs.

A class is a blueprint that defines how an object should be implemented whereas an object is an instance of a class. We can define many objects from a single class as long as they are related.

Attributes are the information that is stored in a class. When a class object is instantiated, individual objects contain information that is stored in attributes. Methods define behaviors that objects should have. These objects might return some information or update an object's data.

Benefits of Object-Oriented Programming

i) Re-usability - OOP objects are reusable across the whole program.

ii) Code maintenance - It is always easy and time-saving to maintain and modify the existing codes by incorporating new changes into them.

iii) Security - With the use abstraction mechanism, we are exposing only the data that we need the user to see which means we are maintaining security.

iv) OOP benefits the programmer by providing a better design structure. By this, the programmer is saved from making mistakes and writing bad code.

v) Easier troubleshooting – When something goes wrong, you know exactly where to look at it. For instance, when a car object breaks, you know that there is a problem with the car class.

Principles of Object-Oriented Programming

In this post, we are going to look at the principles of OOP one by one using Python programming. Many programming languages also support this paradigm including Java, PHP, JavaScript, C++, and many more.

Inheritance

It is the ability of a class to derive properties and characteristics from another class. Note: The class that inherits properties from another class is called subclass/derived class whereas the class whose properties are inherited is called class/base class.

As we saw before, the primary benefit of inheritance is code re-usability, therefore saving time on programming. Python supports four different types of inheritance. Types of Inheritance depend upon the number of child and parent classes involved.

Single Inheritance

Single inheritance enables a derived class to inherit properties from a single parent class. This following is an example of a Python program to demonstrate single inheritance.

# Parent class

class Dog:
def function1(self):
print("I'm a function from parent class!")

# Child class

class Bulldog(Dog):
def function2(self):
print("I'm a function from child class!")

# Driver code

object1 = Bulldog()
object1.function1()
object1.function2()

The following is the output of our program:

I'm a function from parent class!

        I'm a function from child class!

Multiple Inheritance

This is where a subclass can inherit from more than one superclass.  This following is an example of a Python program to demonstrate multiple inheritances.

# Parent class1

class Donkey:
donkey_name = ""
def father(self):
print(self.donkey_name)

# Parent class2

class Horse:
horse_name = ""
def mother(self):
print(self.horse_name)

# Child class

class Child(Donkey, Horse):
def parents(self):
print("Father : ", self.donkey_name)
print("Mother : ", self.horse_name)

# Driver code

c1 = Child()
c1.donkey_name= "Jack"
c1.horse_name = "Mare"
c1.parents()

The following is the output of our program:

Father:  Jack

Mother:  Mare

Multilevel Inheritance

Here, one class can inherit from another class which also inherits from another class. Let’s look at this example to demonstrate multilevel inheritance.

# Base class

class Grandfather:
def __init__(self, grandfathername):
self.grandfathername = grandfathername

# Intermediate class

class Father(Grandfather):
def __init__(self, fathername, grandfathername):
self.fathername = fathername

# invoking constructor of Grandfather class

Grandfather.__init__(self, grandfathername)

# Derived class

class Son(Father):
def __init__(self,sonname, fathername, grandfathername):
self.sonname = sonname

# invoking constructor of Father class

Father.__init__(self, fathername, grandfathername)
def print_name(self):
print('Grandfather name :', self.grandfathername)
print("Father name :", self.fathername)
print("Son name :", self.sonname)

# Driver code

s1 = Son('Prince', 'Rampal', 'Lal mani')
print(s1.grandfathername)
s1.print_name()

The following is the output of our program:

Lal mani

Grandfather name : Lal mani

Father name : Rampal

Son name : Prince

Hierarchical Inheritance

This is where more than one sub-class can be derived from the same superclass. Example of a Python program to demonstrate Hierarchical inheritance.

# Base class

class Parent:
def function1(self):
print("This is function 1")

# Child class1

class Child1(Parent):
def function2(self):
print("This is function 2")

# Child class2

class Child2(Parent):
def function3(self):
print("This is function 3")

# Driver code

ob = Child1()
ob1 = Child2()
ob.function1()
ob.function2()

Output:

This is function 1

This is function 2

Abstraction

Abstraction is a another feature of Object Oriented Programming that displays only essential details to the user while hiding the implementation details. The concept of abstraction makes the application to be presented to the user in the simplest way possible.

In Python, abstraction can be achieved by using abstract classes and methods in our programs. Example of a Python program to demonstrate abstraction.

From abc import ABC

#abstract class

class Shape(ABC):
def calculate_area(self):  #abstract method
pass
class Rectangle(Shape):
  length = 5
  breadth = 3
def calculate_area(self):
return self.length * self.breadth
class Circle(Shape):
  radius = 4
def calculate_area(self):
return 3.14 * self.radius * self.radius
rec = Rectangle() #object created for the class 'Rectangle'
cir = Circle() #object created for the class 'Circle'

#call to 'calculate_area' method defined inside the class 'Rectangle'

print("Area of a rectangle:", rec.calculate_area())

#call to 'calculate_area' method defined inside the class 'Circle'.

print("Area of a circle:", cir.calculate_area())

The following is the output:

Area of a rectangle: 15

Area of a circle: 50.24

Encapsulation

It is defined as wrapping up of data and information under a single unit. In other words, it is defined as binding together the data and the functions that manipulate them. Example of a Python program to demonstrate protected members

# Creating a base class

class Base:
def __init__(self):

# Protected member
self._a = 2

# Creating a derived class

class Derived(Base):
def __init__(self):

# Calling constructor of
# Base class
Base.__init__(self)
print("Calling protected member of base class: ")
print(self._a)

# Driver code

obj1 = Derived()
obj2 = Base()

# Calling protected member

# Outside class will result in

# AttributeError

print(obj2.a)

The following is the output:

AttributeError: 'Base' object has no attribute 'a'

Polymorphism

It is an Object Oriented Programming concept that refers to the ability of variables, functions or objects to take or occur in many forms. Example of a Python program to demonstrate polymorphism.

class Kenya():
def capital(self):
print("Nairobi")
def language(self):
print("Kiswahili and English")


class Britain():
def capital(self):
print("London")
def language(self):
print("English")


obj_kenya = Kenya()
obj_britain = Britain()


for country in (obj_kenya, obj_britain):
country.capital()
country.language()


Output:

Nairobi

Kiswahili and English

London

English

In this example, the function "capital" and "language" are used in the two classes "Kenya" and "Britain" but they are returning different results. This is an of polymorphism in class functions.

Conclusion

We have looked at Object-Oriented Programming, its benefits, and some various examples in Python language. I hope this post has given you a foundation in OOP and Python language. Feel free to look at some examples and practice on your own to sharpen your skills.

Did you like my article? Please share it using these buttons. Thanks!

Was this article helpful?

Bessy
Eric Murithi Muchenah

Life is beautiful, time is precious. Make the most out of it.