Python Object Oriented Programming

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

    What are OOPs in Python?

    As we know 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
    • Behaviours

    Here attributes are the variable and behaviour 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 behaviour.

    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 are known as under 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