Python Object Oriented Programming

By | June 23, 2019

In this tutorial, we will discuss Python Object Oriented Programming concept and learn its fundamentals.

What is OOP’s in Python?

As we know that python is a high-level programming language with multi-paradigm, here Object-Oriented Programming is one of those paradigms.

Object-oriented programming is a programming technique that most of the high-level programming language support in this we use class and object to make a program.

An Object has two characteristics:

  • Attribute
  • Behaviors

Here attributes are the variable and behavior can be taken as the function of those variables.

Let’s understand it with an example:

Consider a Car as an Object

So, its color, brand name, considered as its attributes

Where the gear mechanism and speed would be considered as its behavior.

OOP’s Properties:

  • Inheritance

When we use the properties of one class in another class.

  • Encapsulation

All the code is inside a Class block.

  • Polymorphism

Operators performing different operations on different data types

Two Main Component of OPP’s

  • Class
  • Object

Class:

A class is a Keyword which is used to make the blueprint of an Object.  A class has no existence until its object gets created.

Class Syntax:

class Class_Name:

                #class body which includes its properties 

Example:

class Car:
    car_colour = "blue"
    car_brand = "BMW"

Object:

The object of a class is also known as the instance of the class. When we create an object of the class the class come in existence, and with the help of object, we can access the properties of the class. A class has many objects.

Object creation syntax:

obj_name = Class_name()

Example:

Suppose Bob and Sam has same car, and if we represent it with OOP’s concept the car would be a class and Bob and Sam will be Objects.

 class Car:
     car_colour = "blue"         #Class attributes
     car_brand = "BMW"        #class attributes

bob = Car()                          # Bob is an object here
sam = Car()                         # Sam is the another object of Car

print("the brand of Bob's car is:",bob.car_brand)
print("the Colour of Sam car is:", sam.car_colour) 

# Output

the brand of Bob's car is: BMW
the Colour of Sam car is: blue

Behind the code:

Here in the above code, we made two objects (sam and bob) of the same class (Car), and we have used the car attributes outside the Class block using its object and dot operator. 

Class Methods:

Functions inside a Class know as class methods. There are two types of Class methods user-defined methods and magical methods. The python magical methods also known as dunders these methods contain double underscores (__) before and after the method name.

Example:

class Car:
    def __init__(self,car_brand,car_colour):                 #Class megical method and class Constructor
        self.car_colour =car_colour
        self.car_brand = car_brand

    def car_details(self):      #Class method
        print("The car brand is", self.car_brand, "and it",self.car_colour, "in colour")


bob = Car("BMW", "Blue")                          
sam = Car("Ferrari", "Red")                         
bob.car_details()             #Calling class method using object
sam.car_details()

#Output

The car brand is BMW and it Blue in colour
The car brand is Ferrari and it Red in colour

Python Object Oriented Programming Properties:

Inheritance:

Inheritance is one of the most important properties of OPP’s concept and it used more often as compared to other OOP’s properties.

In inheritance, we can use the properties ( Attributes and Method) of one class in another. The main motto of inheritance is the reusability, code written in one class can be used in another.

Inheritance has two components: base class and derived class. The Base class also known as Parent class and the derived also know as child class. The derived class inherit the properties from the base class.

Inheritance Syntax:

class base_class:
     # Base Class block

class derived_class (base_class):                # here derived class inherit base class
    #base class block

Example:

class Mammals:
    def __init__(self):
        print("Mammals Class has been created")
    def type(self):
        print("It is a Mammals")
class Dog(Mammals):
    def __init__(self):
        print('dog class has been created')

bob_pet = Dog()               #When we create class object it invoke __init__ method
bob_pet.type()                 # Here we call Mammals method using Dog object.

#Output:

dog class has been created
It is a Mammals

Encapsulation:

Encapsulation deal with data hiding from an Object.  In python class, we use single or double underscore before the attributes name to tell the object that particular attribute is private for class only and object not supposed to access those attributes directly.

Example:

class make():
    def __init__(self):
        self.item = 200                  
        self.__item = 200              #Private member
    def itemsvalue(self):
        print("Total no. of __items",self.__item)
        print("Total no. of items",self.item)
m= make()
m.itemsvalue()
print("-----------change the value of item and __item using object--------- ")
m.item = 300
m.__item = 300
m.itemsvalue()

#Output:

Total no. of __items 200
Total no. of items 200
-----------change the value of item and __item using object---------
Total no. of __items 200
Total no. of items 300

Polymorphism:

With polymorphism, we can have the same method name for different classes. Polymorphism applies on operators too for example if we use + operator between two integers it will add both integers, but if we use the same + operator between two string it will concatenate them.

Example:

class Cat:
    def eat(self):
        print("cat eat fish")
    def swim(self):
        print("Cat can't swim")
class Dog:
    def eat(self):
        print("Dog Food, Meat")
    def swim(self):
        print("Dogs can swim")
james_pet = Dog()
sofi_pet = Cat()
james_pet.swim()
sofi_pet.swim()

#Output:

Dogs can swim
Cat can't swim

Some Advantages of OOP’s:

  • OPP’s provide a modular way to complete the project
  • It increases the code reusability
  • Give more data security.

Python Tutorials


Introduction

Flow Control

Functions

Datatypes

File Handling

Object & Class

Additional Tutorials

 

Leave a Reply

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