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 an 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:
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:
Let’s discuss these principles in the following sections.
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:
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:
In the above syntax, we have defined an empty class Cellphone.
An instantiation of a class is known as an Object or Instance of that class. The class contains a description of the object. Thus, no storage or memory allocation takes place.
The example for the object of Cellphone class can be:
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
Output:
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.
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
Output:
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 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
Output:
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.
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
Output:
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 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
Output:
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 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.
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.