Classes and Objects in Python

Python is an object-oriented language and almost every entity in Python is an object, which means that programmers extensively use classes and objects while coding in Python. Objects in Python are basically an encapsulation of Python variables and functions that they get from classes.

Watch this video on ‘Python Classes and Objects’:

Python Classes and Objects

In this module, we will learn each aspect of classes and objects in Python in the following order:

So, without further delay, let’s get started.

Go for the most professional Python Course Online in Toronto for a stellar career now!

What Are Classes and Objects in Python?

A class is simply a logical entity that behaves as a prototype or a template to create objects, while an object is just a collection of variables and Python functions. Variables and functions are defined inside the class and are accessed using objects. These variables and functions are collectively known as attributes.
Let’s take an example to understand the concept of Python classes and objects. We can think of an object as a regular day-to-day object, say, a car. Now as discussed above, we know that a class has the data and functions defined inside of it, and all this data and functions can be considered as features and actions of the object, respectively. That is, the features (data) of the car (object) are color, price, number of doors, etc. The actions (functions) of the car (object) are speed, application of brakes, etc. Multiple objects with different data and functions associated with them can be created using a class as depicted by the following diagram.

Advantages of Using Classes in Python

  • Classes provide an easy way of keeping the data members and methods together in one place which helps in keeping the program more organized.
  • Using classes also provides another functionality of this object-oriented programming paradigm, that is, inheritance.
  • Classes also help in overriding any standard operator.
  • Using classes provides the ability to reuse the code which makes the program more efficient.
  • Grouping related functions and keeping them in one place (inside a class) provides a clean structure to the code which increases the readability of the program.

Become a professional Python Programmer with this complete Python Training in Singapore!

Get 50% Hike!

Master Most in Demand Skills Now !

Defining a Class in Python

Just as a function in Python is defined using the def keyword, a class in Python is also defined using the class keyword, followed by the class name.
Much similar to functions, we use docstrings in classes as well. Although the use of docstrings is not mandatory, it is still recommended as it is considered to be a good practice to include a brief description about the class to increase the readability and understandability of the code.
The following example illustrates how to define a class in python:

class IntellipaatClass:
“Class statements and methods here'”

The create class statement will create a local namespace for all the attributes including the special attributes that start with double underscores (__), for example, __init__() and __doc__(). As soon as the class is created, a class object is also created which is used to access the attributes in the class, let us understand this with the help of a Python class example.

class IntellipaatClass:
a = 5
def function1(self):
print(‘Welcome to Intellipaat’)
#accessing attributes using the class object of same name
IntellipaatClass.function(1)
print(IntellipaatClass.a)
Output:
Welcome to Intellipaat
5

Creating an Object in Python

We saw in the previous topic that the class object of the same name as the class is used to access attributes. That is not all the class object is used for; it can also be used to create new objects, and then those objects can be used to access the attributes as shown in the following example:

class IntellipaatClass:
a = 5
def function1(self):
print(‘Welcome to Intellipaat’)#creating a new object named object1 using class object
object1 = IntellipaatClass()
Output:
Welcome to Intellipaat

We must notice that we are using a parameter named self while defining the function in the class, but we’re not really passing any value while calling the function. That is because, when a function is called using an object, the object itself is passed automatically to the function as an argument, so object1.function1() is equivalent to object1.function1(object1). That’s why the very first argument in the function must be the object itself, which is conventionally called ‘self’. It can be named something else too, but naming it ‘self’ is a convention and it is considered as a good practice to follow this convention.

Modifying and Deleting an Object

You can modify an object like this:

Person.age=20

You can delete an object by using del keyword

For example,

del objectName

Go for this in-depth job-oriented Python Training in Hyderabad now!

Career Transition

The_init_() Function in Python

In python classes, “__init__” method is reserved. It is automatically called when you create an object using a class and is used to initialize the variables of the class. It is equivalent to a constructor.

  • Like any other method, init method starts with the keyword “def”
  • “self” is the first parameter in this method just like any other method although in case of init, “self” refers to a newly created object unlike other methods where it refers to the current object or instance associated with that particular method.
  • Additional parameters can be added

Following example illustrates how to use the __init__() function:

class IntellipaatClass:
    def __init__(self, course):
        self.course = course
    def display(self):
        print(self.course)
object1 = IntellipaatClass("Python")
object1.display()
Output:
Python

In the above example, the init function behaves as a constructor and is called automatically as soon as the ‘object1 = IntellipaatClass(“Python”)’ statement is executed. Since it is a function inside a class, the first argument passed in it is the object itself which is caught in the ‘self’ parameter. The second parameter, i.e., course, is used to catch the second argument passed through the object, that is ‘Python’. And then, we have initialized the variable course inside the init function. Further, we have defined another function named ‘display’ to print the value of the variable. This function is called using object1.

Note: Don’t forget to give proper indentation in the above code.

Python Inheritance and Its Types

As a result of being an object-oriented programming language, Python also utilizes inheritance. The ability of a class to inherit the properties of another class is known as inheritance. The class that inherits the properties is usually called a subclass or a derived class. And, the class that is being inherited is known as a superclass or a base class.
Inheritance provides code reusability as we can use an existing class and its properties rather than creating a class from scratch with the same properties.

class derived_Class_Name (base class):
<class-suite>

The derived class can inherit multiple classes at a time by mentioning all base classes inside parentheses

Example:

class Intellipaat:
    def course(self):
        print("Python tutorial")
class hello(Intellipaat):
    def func(self):
        print("Welcome to intellipaat")
ob1 = hello()
ob1.func()
ob1.course()

Output:
Welcome to Intellipaat
Python tutorial

There are different forms of inheritance depending on the structure of inheritance taking place between a derived class and a base class in Python. Let’s discuss each one of them individually:

  1. Single inheritance: The type of inheritance when a class inherits only one base class is known as single inheritance, as we saw in the above example.
  2. Multiple inheritance:When a class inherits multiple base classes, it’s known as multiple inheritance. Unlike languages like Java, Python fully supports multiple inheritance. All the base classes are mentioned inside brackets as a comma-separated list.

Example:

class BaseClass1():
    def __init__(self):
        print("Base class 1")
class BaseClass2():
    def __init__(self):
        print("Base class 2")
class derivedClass (BaseClass1, BaseClass2):
    def __init__(self):
        BaseClass1.__init__(self)
        BaseClass2.__init__(self)
        print("derived class")
    def display_all(Self):
        print(self.ob1, self.ob2)
ob = derivedClass()
Output:
Base class 1
Base Class 2
derived class
  1. Multilevel inheritance: When a class inherits a base class and then another class inherits this previously derived class, forming a ‘parent, child, and grandchild’ class structure, then it’s known as multilevel inheritance.
class BaseClass():
    def __init__(self):
        print("Base class")
class childClass(BaseClass):
    def __init__(self):
        print("Child class")
class grandchildClass(childClass):
    def __init__(self):
        BaseClass.__init__(self)
        childClass.__init__(self)
        print("Grand child class")
ob1 = grandchildClass()
Output:
Base class
Child class
Grand child class
  1. Hierarchical inheritance: When there is only one base class inherited by multiple derived classes, it is known as hierarchical inheritance.
  2. Hybrid inheritance: Hybrid inheritance is when there is a combination of the above-mentioned inheritance types, that is, a blend of more than one type of inheritance.

We have the perfect professional Python Course in Bangalore for you!

Private Attributes of a Class in Python

While implementing inheritance, there are certain cases where we don’t want all the attributes of a class to be inherited by the derived class. In those cases, we can make those attributes private members of the base class. We can simply do this by adding two underscores (__) before the variable name.

Example:

class Base1:
    def __init__(self):
        self.x = 10


# creating a private variable named y
    def __init__(self):
        self.__y = 5
class Derived1(Base1):
    def __init__(self):
        self.z = 20
        Base1.__init__(self)
ob1 = Derived1()
print(ob1.y)

When the above code block is executed, it will give the following error:


Output:
Traceback (most recent call last):
File “”, line 1, in
AttributeError: ‘Derived1’ object has no attribute ‘y’

Since y is a private variable in the base class, the derived class is not able to access it.

 

Python Polymorphism

Polymorphism means having many forms. Polymorphism enables using a single interface with different data types, different classes, or even a different number of inputs.

Polymorphism is of two types:

  • Run time Polymorphism
  • Compile time Polymorphism

Certification in Full Stack Web Development

Run time Polymorphism:

Run time polymorphism is a process in which the call to an overridden method is resolved at runtime. In python, we implement the run time polymorphism through method overriding.

Method overriding allows us to change the implementation of a method in the child class that is defined in the parent class.

To override a method the following conditions must be met:

  • There should be inheritance. Child class should be derived from a parent class.
  • The method that we are redefining must have the same number of parameters as the method in the parent class.

Example:

class Animal:
def sound(self):
print("Animal sound")
class Cat(Animal):
def sound(self):
print("Cat says meow")

animal=Animal()
cat=Cat()
animal.sound()
cat.sound()

Output:

Animal sound
Cat says meow

Compile time Polymorphism:

Compile time Polymorphism is a process in which the call to the method is resolved at the time of the compilation. We implement compile time polymorphism through method overloading.
By using method overloading you can implement the same functionality of the class with different parameters. Python does not support the Compile time Polymorphism but there is a workaround like the example below.

Example:

class Example:
def multiply(self,a,b,c=1):
print(a*b*c)
example=Example()
example.multiply(5,10)
example.multiply(2,5,6)

Output:

50
60
 

Mutable and Immutable Objects in Python

A mutable object is a changeable object that can be modified after it is created. Lists, dict, set and byte array are all mutable objects.

An immutable object is an object whose state can never be modified after it is created.  Int, float, complex, string, tuple, frozen set and bytes are immutable.

Python handles mutable and immutable objects in different ways. Mutable objects are of great use in scenarios where there is a need to change the object size. Immutable objects are used when you want an object you created to always stay the same as it was when created.

With this, we come to an end of this module in Python Tutorial. Now, if you want to know how python is used for data science, you can go through this blog on Python for Data Science
Further, check out our offers for Python Certification Course and also refer to the trending Python interview questions prepared by the industry experts.

Course Schedule

Name Date
Python Course 2021-09-18 2021-09-19
(Sat-Sun) Weekend batch
View Details
Python Course 2021-09-25 2021-09-26
(Sat-Sun) Weekend batch
View Details
Python Course 2021-10-02 2021-10-03
(Sat-Sun) Weekend batch
View Details

Leave a Reply

Your email address will not be published. Required fields are marked *