Python OOPs: Class, Object, Inheritance and Constructor
Basic Object-Oriented Programming (OOP) Concepts in Python
Python is similar to most general-purpose programming languages with an Object-Oriented environment system since its existence. Being an Object-Oriented Programming language, Python provides ease to the users for developing applications with an Object-Oriented approach. Python also provides an easy way to create and make use of classes and objects.
An Object-oriented paradigm deals in designing the programs with classes and objects. Keeping the classes aside for a while, let us discuss the objects in brief.
Python helps in supporting various programming approaches. And one of them includes the approach for solving a programming problem by creating objects. This approach is well-known as Object-Oriented Programming (OOP).
The Object can be anything such as an employee while creating an office's record registry, a notebook in an item management program of a stationary, or any product in a product manufacturing industry's database program.
An Object can be identified with the following significant characteristics:
- Identity: Some information that can help identify the class's object can be termed as Identity. For example, an employee's Identity is his /her name, the company Id and many more.
- Properties: Properties are said to the attributes of that object. For example, these attributes can be the gender, age, Date of Birth for an employee, or the type of processor, size of RAM and ROM for a smartphone and many more.
- Behavior: The functions that an object can perform are said to its behavior. Object-Oriented Programming makes the assignment of the functions to class objects possible. For example, the smartphone can provide high performance and better picture quality and many more.
The OOPs concept in Python mainly focuses on reusable code development. This concept is also called DRY (abbreviated for Don't Repeat Yourself).
Some of the basic principles of Object-Oriented Programming in Python are as follows:
- Class
- Object
- Method
- Inheritance
- Encapsulation
- Polymorphism
- Data Abstraction
Let’s discuss these principles in the following sections.
Class
A Collection of objects can be known as the Class. A Class is a logical entity that comprises of some particular properties and methods. Thus, we can also say that it is a blueprint for the object.
The Syntax for a Class is shown below:
class ClassName: <statement_1> <statement_2> . . . <statement_N>
In the above syntax, we have used the keyword class to define a class ClassName. Using class, we can construct instances. A particular object that is constructed from a specific class is known as an instance.
For example - If we have a cellphone class, it should comprise properties and methods such as Model Name, Platform OS, Chipset, GPU, CPU, Memory, Camera, Price, and many more. Based on these descriptions and specifications, we can study the cellphone. Here, a cellphone is an object.
The Syntax for Cellphone Class can be:
class Cellphone: pass
In the above syntax, we have defined an empty class Cellphone.
Object
An instantiation of a class is known as an Object or Instance of that class. The class contains the description of the object. Thus, no storage or memory allocation takes place.
The example for the object of Cellphone class can be:
obj = Cellphone()
Here, obj is an object of the class Cellphone.
Suppose we have information about cellphones. Now, we are building the class and objects of Cellphone.
Example 1: Defining Class and Object in Python
class Cellphone:
# class attribute
cellphone_type = "Smartphone"
# instance attribute
def __init__(self, model_name, price):
self.model_name = model_name
self.price = price
# instantiating the Cellphone class
phone_1 = Cellphone("Apple iPhone 12", 78999)
phone_2 = Cellphone("OnePlus 8T", 42999)
# accessing the class attributes
print("Apple iPhone 12 is a {}".format(phone_1.__class__.cellphone_type))
print("OnePlus 8T is also a {}".format(phone_2.__class__.cellphone_type))
# accessing the instance attributes
print("The Price of {} is INR {}.".format( phone_1.model_name, phone_1.price))
print("The Price of {} is INR {}.".format( phone_2.model_name, phone_2.price))
Output:
Apple iPhone 12 is a Smartphone OnePlus 8T is also a Smartphone The Price of Apple iPhone 12 is INR 78999. The Price of OnePlus 8T is INR 42999.
Explanation:
In the above program, we have defined a class with the name Cellphone. Then, we defined the attributes. These attributes are the characteristics of the object.
We have defined these attributes inside the __init__ method of the class. It acts as an initializer for executing the code as soon as the object is defined.
Then, we have created instances of the Cellphone class. Here, phone_1 and phone_2 are values (or references) to our new objects.
The class attribute can be accessed using __class__.species. The Class attributes act similarly for every instance of a class. The instance attributes can be accessed in the same way, using phone_1.model_name and phone_1.price. However, they are different for every class’s instance.
We will learn a lot more about Classes and Objects in the upcoming tutorial.
Methods
The function defined inside the class body and associated with an object is known as a Method. They are not unique to class instances and are used for defining the object behaviors.
Example 2: Methods creation in Python
class Cellphone:
# instance attributes
def __init__(self, model_name, price):
self.model_name = model_name
self.price = price
# instance method
def performance(self, perf):
return "{} provides {} performance".format(self.model_name, perf)
def refreshrate(self, rr):
return "{} has {} refresh rate".format(self.model_name, rr)
# instantiating the object
phone_1 = Cellphone("Apple iPhone 12", 78999)
# calling the instance methods
print(phone_1.performance("'Excellent'"))
print(phone_1.refreshrate("'120Hz'"))
Output:
Apple iPhone 12 provides 'Excellent' performance Apple iPhone 12 has '120Hz' refresh rate
Explanation -
In the above program, we have defined two methods, i.e., performance() and refreshrate(). These are known as instance methods as they are called on an instance object, i.e., phone_1.
Inheritance
Inheritance refers to creating a new class for utilizing the information of an already existing class without making any changes to it. The newly designed class acts like a child class or derived class. And similarly, the already existing class acts as a parent class or base class.
Example 3: Using Inheritance in Python
# parent class
class Cellphone:
def __init__(self):
print("This is a Cellphone")
def who(self):
print("Cellphone")
def performance(self):
print("High performance")
# child class
class iPhone(Cellphone):
def __init__(self):
# calling super() function
super().__init__()
print("iPhone is also a Cellphone")
def who(self):
print("Apple iPhone 12 Pro")
def refreshrate(self):
print("120Hz Refresh Rate")
phone = iPhone()
phone.who()
phone.performance()
phone.refreshrate()
Output:
This is a Cellphone iPhone is also a Cellphone Apple iPhone 12 Pro High performance 120Hz Refresh Rate
In the above program, we have defined two classes, i.e., Cellphone (parent class) and iPhone (child class). The functions of the parent class are inherited from the child class. It can be seen from the performance() method.
Moreover, the behavior of the parent class is modified by the child class. This can be seen from the who() method. In addition to this, the parent class functions are extending using a new run() method.
Moreover, we have used the super() function inside the __init__() method. This function helps the users execute the parent class __init__() method inside the child class.
Encapsulation
Object-Oriented Programming has an essential aspect known as Encapsulation, which allows users to restrict access to variables and methods. This helps in preventing the data from any direct modification. These private attributes are denoted with underscores as the prefix, single _ or double ___, in Python.
Example 4: Data Encapsulation in Python
class Cellphone:
def __init__(self):
self.__maxmemory = 128
def variant(self):
print("The Internal Memory is {} GB.".format(self.__maxmemory))
def setMaxMemory(self, memory):
self.__maxmemory = memory
cell = Cellphone()
cell.variant()
# changing the memory
cell.__maxmemory = 256
cell.variant()
# using the setter function
cell.setMaxMemory(256)
cell.variant()
Output:
The Internal Memory is 128 GB. The Internal Memory is 128 GB. The Internal Memory is 256 GB.
Explanation –
In the above program, we have defined a Cellphone class. Then we used the __init__() method for storing the maximum internal memory of Cellphone. Then, we tried to change the memory size. But it can’t be modified as Python is treating the __maxmemory as a private attribute.
As we can see, we have used a setter function, i.e., setMaxMemory(), to change the value.
Polymorphism
Polymorphism comprises of two words – “poly” and “morphs”. Poly implies many or multiple, whereas morph implies shape or form. Thus, we can conclude that Polymorphism is an ability that performs one task in several ways.
Let’s take an example where we have to color a shape. There are several shapes available such as circle, triangle and square. However, we can use the same method to color any of them. This concept is known as Polymorphism.
Example 5: Utilizing Polymorphism in Python
class iPhone_12:
def processor(self):
print("Apple iPhone 12 mini is built on A14 Bionic Chipset")
def OS(self):
print("Apple iPhone 12 mini has IOS 14 as Operation System")
class OnePlus_8t:
def processor(self):
print("OnePlus 8T is built on Snapdragon 865 Chipset")
def OS(self):
print("OnePlus 8T has Android 11 as Operating System")
# common interface
def processor_test(Cellphone):
Cellphone.processor()
#instantiating objects
apple = iPhone_12()
oneplus = OnePlus_8t()
# passing the object
processor_test(apple)
processor_test(oneplus)
Output:
Apple iPhone 12 mini is built on A14 Bionic Chipset
OnePlus 8T is built on Snapdragon 865 Chipset
Explanation –
In the above program, we have defined two separate classes, i.e., iPhone_12 and OnePlus_8t. Both of them have a common processor() method but vary in their functioning.
We have then created a common interface, i.e., processor_test() function, to use the polymorphism. Thus, it works effectively when we passed the apple and oneplus objects in the processor_test() function.
Data Abstraction
Data Abstraction is often misunderstood with encapsulation as both of them are synonyms, and we can achieve data abstraction through encapsulation.
Abstraction helps the users to hide internal information and display only functionalities. Data Abstracting refers to providing the identity to the data to capture the core concept of the function or program.
Conclusion
Object-Oriented Programming helps in making a program understandable and well-efficient. We can reuse the code as the class is sharable. Data abstraction helps in securing the data. And Polymorphism allows the users to use the common interface for distinct objects; thus, it helps the programmer write the code efficiently.