Python Classes And Objects -ObjectOriented 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 an 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:

1.What is a Python Class?

2. Methods and Attributes in a class

3. What are Objects?

4. OOPs Concepts:

• Inheritance
• Polymorphism
• Abstraction

Let’s get started.:-)

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 a cleaner and efficient ways. The attributes are data members (class variables and instance variables) and methods that are accessed via dot notation.

• The class variable is a variable that is shared by all the different objects/instances of a class.
• Instance variables are variables that 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 describe the behavior 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.

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 the “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 that act 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 that gets called whenever a new object of that class is instantiated. You can think of it as an initialize method or you can consider this as constructors if you’re coming from any other 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 the 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 us implement this practice.

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 that are shared among all the instances of a class. These are called class variables. Instance variables can be unique for each instance like names, email, sal, etc. Complicated? Let’s understand this with an example. Refer to 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 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 procedural and object-oriented programming. To clear your doubt, in 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.

1. Parent class ( Super or Base class)

2. Child class (Subclass or Derived class )

A class that 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)

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 an 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 sci-kit learn library and array. Stay tuned!

If you wish to check out more articles on the market’s most trending technologies like Artificial Intelligence, DevOps, Ethical Hacking, then you can refer to Edureka’s official site.

Do look out for other articles in this series which will explain the various other aspects of Python and Data Science.

1. Machine Learning Classifier in Python

2. Python Scikit-Learn Cheat Sheet

3. Machine Learning Tools

4. Python Libraries For Data Science And Machine Learning

5. Chatbot In Python

6. Python Collections

7. Python Modules

8. Python developer Skills

9. OOPs Interview Questions and Answers

10. Resume For A Python Developer

11. Exploratory Data Analysis In Python

12. Snake Game With Python’s Turtle Module

13. Python Developer Salary

14. Principal Component Analysis

15. Python vs C++

16. Scrapy Tutorial

17. Python SciPy

18. Least Squares Regression Method

19. Jupyter Notebook Cheat Sheet

20. Python Basics

21. Python Pattern Programs

22. Web Scraping With Python

23. Python Decorator

24. Python Spyder IDE

25. Mobile Applications Using Kivy In Python

26. Top 10 Best Books To Learn & Practice Python

27. Robot Framework With Python

28. Snake Game in Python using PyGame

29. Django Interview Questions and Answers

30. Top 10 Python Applications

31. Hash Tables and Hashmaps in Python

32. Python 3.8

33. Support Vector Machine

34. Python Tutorial

Originally published at https://www.edureka.co on December 26, 2017.