DEV Community

Anirban Das
Anirban Das

Posted on

Objects and Object Oriented Programming

Nowadays the modern software development resides around objects and its oriented programming for a good reason. As it gives a lot of benefits over the old paradigm of procedural programming.

  • Python is an object oriented programming language
  • Object orient programming is a way to design the program using classes and objects.
  • The main concepts of OOPs is to bind the data and the functions that work on the data together as a single unit os that no other part of the code can access this data
  • The four concepts that contructs the OOP are data abstraction, polymorphism, encapsulation and inheritance

Main concepts of OOP


  • Class consists of a collection of objects
  • Classes are known as the blueprint of objects
  • Classes have there own attributes and methods that has the accessibility only by the objects of that class
  • We can initialize the attributes of a Class using init method
class Mountblue:
    def __init__(self, name, company): = name = company

    def some_method_to_work(some arguments):
        # Statements to execute
        # return statements
Enter fullscreen mode Exit fullscreen mode


  • Objects are the instance of a class
  • Object are just like real world entities like a car, boy, girl, etc
  • An object consists of methods and attributes
  • Object of a class consist of self parameter which represents the attributes of its class.
  • We can use any parameters in any methods belong to the same class.
class Car:
    def __init__(self, brand, model, color):
        self.brand = brand
        self.model = model
        self.color = color

    def show_props(self):
        print(self.brand, self.model)

s = Car("Tata", "Nano", "Blue")

## output: 
Tata Nano
Enter fullscreen mode Exit fullscreen mode

Data Abstraction

  • Data Abstraction or data hiding is to avoid details of an object which are not used in the current task
  • For example, if we are driving a car, we do not need to know the mechanism of how the car works when we push gear, acceleration or brakes.
  • For Data hiding: We use double underscore("__") before the attributes names and those attributes will not be directly visible outside.
class MyClass:
    __thisvariablehidden = 0
    def adder(self, increment):
    self.__thisvariablehidden += increment

object1 = MyClass()

# output: 200
#          72

MyClass instance has 
no attribute '__thisvariablehidden'
Enter fullscreen mode Exit fullscreen mode


  • OOP allows us to encapsulate data and behaviour within objects.
  • This means that we can hide implementation details and only the interface is visible for the other parts of the program
  • It helps us for code maintainability and updation the code over time
  • Protected members(single underscore"_") are those classes which cannot be accessed outside the class but can be accessed from within the class
  • Private members(double underscore"__") are the class members that cannot be accessed outside the class as well as inside of any base class. Completely private protected file
class Account:
    def __init__(self, balance):
        self.__balance = balance # private attribute

    def deposit(self, amount):
        self.__balance += amount

    def get_balance(self):
        return self.__balance

# The __balance attribute is marked as private by using double underscore
# By using this the balance is secured 
a = BankAccount(50)
# 100
Enter fullscreen mode Exit fullscreen mode


  • Polymorphism means one type having many forms
  • It allows us to write code that can work with objects of different classes, as long as they have common interface
  • With polymorphism we can can the code more flexible and reusable
def add(x, y, z = 0):
    return z + y + z

print(add(4, 5))
print(add(4, 5, 6))
# output : 9
#          15
Enter fullscreen mode Exit fullscreen mode

Method Overriding

  • It allows a subclass or child class to provide a specific kind of implementation of a method that is already provided by one of its super-classes or parent classes.
  • When a method in a subclass has the same name, same parameters or signature and same return type as a method in its super-class, then the method in the subclass is said to override the method in the super-class.
class Parent():
    def __init__(self):
        self.value = "Inside Parent"

    def show(self):

class Child(Parent):
    def __init__(self):
        self.value = "Inside Child"
    def show(self):

obj1 = Parent()
obj2 = Child()
# Output: Inside Parent
#         Inside Child  
Enter fullscreen mode Exit fullscreen mode

Method Overloading

  • Two or more methods have the same name but different numbers of parameters or different types of parameters, or both.
  • The problem with method overloading in python is that we may overload the methods but can only use the latest defined method.
def product(a, b):
    d = a * b

def product(a, b, c):
    d = a * b * c

product(3, 4, 2)
# output : 24 
Enter fullscreen mode Exit fullscreen mode


  • Inheritance is the capability of one class to derive or inherit the properties from parent class.
  • This can be useful when we have several classes that share common properties or behavior
  • It provides reusability of a code and allows us to add more features to a class without modifying it.

Types of Inheritance

1. Single Inheritance

  • New class is called the derived class or subclass, and the existing class is called the base class or superclass.
  • The derived class inherits al the properties of the base class
class Animal:
    def __init__(self, name, sound): = name
        self.sound = sound

    def make_sound(self):
        print(f"{} says {self.sound}!")

class Dog(Animal):
    def __init__(self, name):
        super().__init__(name, "Woof")

dog = Dog("Tommy")

# output : "Tommy says Woof!"
Enter fullscreen mode Exit fullscreen mode

2. Multi-level Inheritance

  • In this inheritance a derived class is created based on another derived class, which is based on a base class.
class Animal:
    def __init__(self, name, sound): = name
        self.sound = sound

    def make_sound(self):
        print(f"{} says {self.sound}!")4

class DomesticAnimal(Animal):
    def __init__(self, name, sound, breed):
        super().__init__(name, sound)
        self.breed = breed

    def show_breed(self):
        print(f"{} is a {self.breed}.")

class Dog(DomesticAnimal):
    def __init__(self, name, breed):
        super().__init__(name, 'Woof', breed)

dog = Dog("Tommy", "German Spitz")

# output : "Tommy says Woof!"
# output : "Tommy is a German Spitz"
Enter fullscreen mode Exit fullscreen mode

References :

Top comments (0)