Python Classes And Objects – Object Oriented Programming

After Stack Overflow predicted that by 2019, Python will outstrip other languages in terms of active developers, the demand for Certified Python Developers is only growing. Python follows object-oriented programming paradigm. It deals with declaring python classes, creating objects from them and interacting with the users. In an object-oriented language, the program is split into self-contained objects or you can say into several mini-programs. Each object is representing a different part of the application which can communicate among themselves.
In this python class blog, you will understand each aspect of classes and objects in the following sequence:

• What is a Python Class?
• Methods and Attributes in a class
• What are Objects?
• OOPs Concepts:
  • Inheritance
  • Polymorphism
  • Abstraction

Let’s get started.:-)

To master your skills and kick-start your learning enroll to Edureka’s python certification program and become a python developer in no time.

What is a Python Class?

A class in python is the blueprint from which specific objects are created. It lets you structure your software in a particular way. Here comes a question how? Classes allow us to logically group our data and function in a way that it is easy to reuse and a way to build upon if need to be. Consider the below image.

In the first image (A), it represents a blueprint of a house that can be considered as Class. With the same blueprint, we can create several houses and these can be considered as Objects. Using a class, you can add consistency to your programs so that they can be used in cleaner and efficient ways. The attributes are data members (class variables and instance variables) and methods which are accessed via dot notation.

• Class variable is a variable that is shared by all the different objects/instances of a class.
• Instance variables are variables which are unique to each instance. It is defined inside a method and belongs only to the current instance of a class.
• Methods are also called as functions which are defined in a class and describes the behaviour of an object.

Now, let us move ahead and see how it works in PyCharm. To get started, first have a look at the syntax of a python class.

Syntax:

class Class_name:
statement-1
.
.
statement-N

Here, the “class” statement creates a new class definition. The name of the class immediately follows the keyword “class” in python which is followed by a colon. To create a class in python, consider the below example:

class employee:
 pass
 #no attributes and methods
 emp_1=employee()
 emp_2=employee()
 #instance variable can be created manually
 emp_1.first='aayushi'
 emp_1.last='Johari'
 emp_1.email='aayushi@edureka.co'
 emp_1.pay=10000

emp_2.first='test'
 emp_2.last='abc'
 emp_2.email='test@company.com'
 emp_2.pay=10000
 print(emp_1.email)
 print(emp_2.email)

Output –

aayushi@edureka.co
test@company.com

Now, what if we don’t want to manually set these variables. You will see a lot of code and also it is prone to error. So to make it automatic, we can use “init” method. For that, let’s understand what exactly are methods and attributes in a python class.

Methods and Attributes in a Python Class

Now creating a class is incomplete without some functionality. So functionalities can be defined by setting various attributes which acts as a container for data and functions related to those attributes. Functions in python are also called as Methods. Talking about the init method, it is a special function which gets called whenever a new object of that class is instantiated. You can think of it as initialize method or you can consider this as constructors if you’re coming from any another object-oriented programming background such as C++, Java etc. Now when we set a method inside a class, they receive instance automatically. Let’s go ahead with python class and accept the first name, last name and salary using this method.

class employee:
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'

emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)
print(emp_1.email)
print(emp_2.email)

Now within our “init” method, we have set these instance variables (self, first, last, sal). Self is the instance which means whenever we write self.fname=first, it is same as emp_1.first=’aayushi’. Then we have created instances of employee class where we can pass the values specified in the init method. This method takes the instances as arguments. Instead of doing it manually, it will be done automatically now.

Next, we want the ability to perform some kind of action. For that, we will add a method to this class. Suppose I want the functionality to display the full name of the employee. So let’s  us implement this practically.

class employee:
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'

    def fullname(self):
            return '{}{}'.format(self.fname,self.lname)

emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)
print(emp_1.email)
print(emp_2.email)
print(emp_1.fullname())
print(emp_2.fullname())

Output –

 aayushi.johari@company.com
 test.test@company.com
 aayushijohari
 testtest

As you can see above, I have created a method called “full name” within a class. So each method inside a python class automatically takes the instance as the first argument. Now within this method, I have written the logic to print full name and return this instead of emp_1 first name and last name. Next, I have used “self” so that it will work with all the instances. Therefore to print this every time, we use a method.

Moving ahead with Python classes, there are variables which are shared among all the instances of a class. These are called as class variables. Instance variables can be unique for each instance like names, email, sal etc. Complicated? Let’s understand this with an example. Refer the code below to find out the annual rise in the salary. 

class employee:
    perc_raise =1.05
    def __init__(self, first, last, sal):
        self.fname=first
        self.lname=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'

    def fullname(self):
            return '{}{}'.format(self.fname,self.lname)
    def apply_raise(self):
        self.sal=int(self.sal*1.05)

emp_1=employee('aayushi','johari',350000)
emp_2=employee('test','test',100000)

print(emp_1.sal)
emp_1.apply_raise()
print(emp_1.sal)

Output –

 350000
 367500

As you can see above, I have printed the salary first and then applied the 1.5% increase. In order to access these class variables, we either need to access them through the class or an instance of the class. Now, let’s understand the various attributes in a python class.

Attributes in a Python Class

Attributes in Python defines a property of an object, element or a file. There are two types of attributes:

• Built-in Class Attributes: There are various built-in attributes present inside Python classes. For example _dict_, _doc_, _name _, etc. Let me take the same example where I want to view all the key-value pairs of employee1. For that, you can simply write the below statement which contains the class namespace:
  

print(emp_1.__dict__)

After executing it, you will get output such as: {‘fname’: ‘aayushi’, ‘lname’: ‘johari’, ‘sal’: 350000, ’email’: ‘aayushi.johari@company.com’}

• Attributes defined by Users: Attributes are created inside the class definition. We can dynamically create new attributes for existing instances of a class. Attributes can be bound to class names as well.

Next, we have public, protected and private attributes. Let’s understand them in detail:

Next, let’s understand the most important component in a python class i.e Objects.

What are objects in a Python Class?

As we have discussed above, an object can be used to access different attributes. It is used to create an instance of the class. An instance is an object of a class created at run-time.

To give you a quick overview, an object basically is everything you see around. For eg: A dog is an object of the animal class, I am an object of the human class. Similarly, there can be different objects to the same phone class. This is quite similar to a function call which we have already discussed. Let’s understand this with an example:

class MyClass:

   def func(self):
      print('Hello')

# create a new MyClass
ob = MyClass()
ob.func()

Moving ahead with python class, let’s understand the various OOPs concepts.

OOPs Concepts

OOPs refers to the Object-Oriented Programming in Python. Well, Python is not completely object-oriented as it contains some procedural functions. Now, you must be wondering what is the difference between a procedural and object-oriented programming. To clear your doubt, in a procedural programming, the entire code is written into one long procedure even though it might contain functions and subroutines. It is not manageable as both data and logic get mixed together. But when we talk about object-oriented programming, the program is split into self-contained objects or several mini-programs. Each object is representing a different part of the application which has its own data and logic to communicate among themselves. For example, a website has different objects such as images, videos etc. 
Object-Oriented programming includes the concept of Python class, object, Inheritance, Polymorphism, Abstraction etc. Let’s understand these topics in detail.

Python Class: Inheritance

Inheritance allows us to inherit attributes and methods from the base/parent class. This is useful as we can create sub-classes and get all of the functionality from our parent class. Then we can overwrite and add new functionalities without affecting the parent class. Let’s understand the concept of parent class and child class with an example.

As we can see in the image, a child inherits the properties from the father. Similarly, in python, there are two classes:

1. Parent class ( Super or Base class)

2. Child class (Subclass or Derived class )

A class which inherits the properties is known as Child Class whereas a class whose properties are inherited is known as Parent class.

Inheritance refers to the ability to create Sub-classes that contain specializations of their parents. It is further divided into four types namely single, multilevel, hierarchical and multiple inheritances. Refer the below image to get a better understanding.

Let’s go ahead with python class and understand how inheritance is useful.

Say, I want to create classes for the types of employees. I’ll create ‘developers’ and ‘managers’ as sub-classes since both developers and managers will have a name, email and salary and all these functionalities will be there in the employee class. So, instead of copying the code for the subclasses, we can simply reuse the code by inheriting from the employee. 

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal * raise_amount)
class developer(employee):
    pass

emp_1=developer('aayushi', 'johari', 1000000)
print(emp_1.email)

Output - aayushi.johari@company.com

As you can see in the above output, all the details of the employee class are available in the developer class. Now what if I want to change the raise_amount for a developer to 10%? let’s see how it can be done practically.

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal* raise_amount)

class developer(employee):
    raise_amount = 1.10

emp_1=developer('aayushi', 'johari', 1000000)
print(emp_1.raise_amount)

Output - 1.1

As you can see that it has updated the percentage rise in salary from 4% to 10%. Now if I want to add one more attribute, say a programming language in our init method, but it doesn’t exist in our parent class. Is there any solution for that? Yes! we can copy the entire employee logic and do that but it will again increase the code size. So to avoid that, let’s consider the below code:

class employee:
    num_employee=0
    raise_amount=1.04
    def __init__(self, first, last, sal):
        self.first=first
        self.last=last
        self.sal=sal
        self.email=first + '.' + last + '@company.com'
        employee.num_employee+=1
    def fullname (self):
        return '{} {}'.format(self.first, self.last)
    def apply_raise (self):
        self.sal=int(self.sal* raise_amount)
class developer(employee):
    raise_amount = 1.10
    def __init__(self, first, last, sal, prog_lang):
        super().__init__(first, last, sal)
        self.prog_lang=prog_lang

emp_1=developer('aayushi', 'johari', 1000000, 'python')
print(emp_1.prog_lang)

Therefore, with just a little bit of code, I have made changes. I have used super.__init__(first, last, pay) which inherits the properties from the base class. To conclude, inheritance is used to reuse the code and reduce the complexity of a program.

Python Class: Polymorphism

Polymorphism in Computer Science is the ability to present the same interface for differing underlying forms. In practical terms, polymorphism means that if class B inherits from class A, it doesn’t have to inherit everything about class A, it can do some of the things that class A does differently. It is most commonly used while dealing with inheritance. Python is implicitly polymorphic, it has the ability to overload standard operators so that they have appropriate behaviour based on their context.

Let us understand with an example:

class Animal:
    def __init__(self,name):
        self.name=name
        def talk(self):
            pass
class Dog(Animal):
            def talk(self):
                print('Woof')
class Cat(Animal):
    def talk(self):
        print('MEOW!')
c= Cat('kitty')
c.talk()
d=Dog(Animal)
d.talk()

Output –

Meow!
Woof

Next, let us move to another object-oriented programming concept i.e Abstraction.

Python Class: Abstraction

Abstraction is used to simplify complex reality by modelling classes appropriate to the problem. Here, we have an abstract class which cannot be instantiated. This means you cannot create objects or instances for these classes. It can only be used for inheriting certain functionalities which you call as a base class. So you can inherit functionalities but at the same time, you cannot create an instance of this particular class. Let’s understand the concept of abstract class with an example below:

from abc import ABC, abstractmethod     

class Employee(ABC):
    @abstractmethod

    def calculate_salary(self,sal):
        pass

class Developer(Employee):

    def calculate_salary(self,sal):
        finalsalary= sal*1.10
        return  finalsalary

emp_1 = Developer()
print(emp_1.calculate_salary(10000))

Output –

11000.0

As you can see in the above output, we have increased the base salary to 10%  i.e. the salary is now 11000. Now, if you actually go on and make an object of class “Employee”, it throws you an error as python doesn’t allow you to create an object of abstract class. But using inheritance, you can actually inherit the properties and perform the respective tasks.

So guys, this was all about python classes and objects in a nutshell. We have covered all the basics of Python class, objects and various object-oriented concepts in python, so you can start practicing now. I hope you guys enjoyed reading this blog on “Python Class” and are clear about each and every aspect that I have discussed above. After python class, I will be coming up with more blogs on Python for scikit learn library and array. Stay tuned!

Got a question for us? Please mention it in the comments section of this “Python Class” blog and we will get back to you as soon as possible.

To get in-depth knowledge of Python along with its various applications, you can enroll here with our live online training with 24/7 support and lifetime access.