Chapter 6: Python: Object-Oriented Programming

Don't forget to explore our basket section filled with 15000+ objective type questions.

Object-oriented programming (OOP) is a paradigm that provides a structured approach to organizing and designing code. It revolves around the concept of objects, which are instances of classes that encapsulate data and behavior. This chapter explores the core concepts of OOP, including classes, objects, inheritance, and polymorphism, and demonstrates how they can be used to create modular, reusable, and efficient code.

Introduction to Object-Oriented Programming

Object-oriented programming is a programming paradigm that focuses on representing real-world entities as objects and organizing code into classes. It emphasizes the concepts of encapsulation, inheritance, and polymorphism to promote code reusability and modularity.

Classes and Objects

A class is a blueprint or template that defines the structure and behavior of objects. It encapsulates data and functions into a single entity. Objects, on the other hand, are instances of classes. They represent individual entities that possess the characteristics defined by the class. Here's an example of a class:

class Car:
    def __init__(self, brand, model, color):
        self.brand = brand
        self.model = model
        self.color = color

    def start_engine(self):
        print("Engine started!")

    def stop_engine(self):
        print("Engine stopped!")

In this example, the Car class has attributes such as brand, model, and color, as well as methods like start_engine() and stop_engine(). These methods define the behavior associated with the car objects.

To create an object of a class, you simply instantiate it by calling the class as if it were a function:

my_car = Car("Tesla", "Model S", "Black")

Now, my_car is an object of the Car class, representing a black Tesla Model S. You can access its attributes and call its methods:

print(my_car.brand)  # Output: "Tesla"
my_car.start_engine()  # Output: "Engine started!"

Attributes and Methods

Attributes are the data or variables associated with a class or object. They store information that defines the state of the object. Methods, on the other hand, are functions associated with a class or object. They define the behavior and actions that can be performed on the object. Both attributes and methods are defined within the class.

Constructor and Self

The __init__() method is a special method known as the constructor. It is called automatically when an object is created from a class and is used to initialize the object's attributes. The self parameter refers to the instance of the object itself and is used to access its attributes and methods within the class.


Inheritance is a mechanism in OOP that allows a class to inherit attributes and methods from another class. The class that inherits is called the child class or subclass, and the class being inherited from is called the parent class or superclass. Inheritance promotes code reuse and enables the creation of specialized classes. Here's an example:

class ElectricCar(Car):
    def __init__(self, brand, model, color, battery_capacity):
        super().__init__(brand, model, color)
        self.battery_capacity = battery_capacity

    def charge_battery(self):
        print("Battery charging!")

In this example, the ElectricCar class inherits from the Car class. It adds an additional attribute, battery_capacity, and a method, charge_battery(). The super() function is used to call the constructor of the parent class to initialize the common attributes.


Polymorphism is the ability of objects to take on different forms or behaviors based on the context in which they are used. It allows objects of different classes to be treated as objects of a common superclass. Polymorphism enables code flexibility, extensibility, and modularity. Here's an example:

def start_vehicle(vehicle):

my_car = Car("Tesla", "Model S", "Black")
my_electric_car = ElectricCar("Tesla", "Model 3", "Red", 75)

start_vehicle(my_car)            # Output: "Engine started!"
start_vehicle(my_electric_car)   # Output: "Engine started!"

In this example, the start_vehicle() function accepts any object as a parameter, as long as it has a start_engine() method. Both the Car and ElectricCar objects can be passed to the function, demonstrating polymorphic behavior.

Encapsulation and Access Modifiers

Encapsulation is a principle in OOP that involves bundling data and methods within a class and controlling access to them. It promotes data hiding and abstraction, allowing for better code organization and maintenance. In Python, access modifiers are not explicitly defined, but naming conventions are followed to indicate the visibility of attributes and methods.

Public Attributes and Methods

Public attributes and methods are accessible from outside the class. They are typically defined without any naming convention. Here's an example:

class Person:
    def __init__(self, name, age): = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {}!")

In this example, both the name and age attributes are public, and the greet() method is also public. They can be accessed and called from outside the class.

Protected Attributes and Methods

Protected attributes and methods are indicated by a single underscore prefix (_). They are intended to be internal to the class or its subclasses. Although they can be accessed from outside the class, it is considered a convention that they should be treated as non-public. Here's an example:

class BankAccount:
    def __init__(self, account_number, balance):
        self._account_number = account_number
        self._balance = balance

    def _process_transaction(self, amount):
        # Internal method for processing transactions

In this example, the _account_number attribute and the _process_transaction() method are protected. They are intended for internal use within the class or its subclasses, but can still be accessed from outside the class.

Private Attributes and Methods

Private attributes and methods are indicated by a double underscore prefix (__). They are intended to be internal to the class and not accessed from outside. Python applies name mangling to these attributes and methods, making them harder to access from outside the class. Here's an example:

class Employee:
    def __init__(self, name, salary):
        self.__name = name
        self.__salary = salary

    def __calculate_bonus(self):
        # Internal method for calculating bonus

In this example, the __name attribute and the __calculate_bonus() method are private. They are intended for internal use within the class only, and their names are mangled to make them less accessible from outside.


This chapter provided an in-depth exploration of object-oriented programming (OOP) concepts in Python. OOP allows you to organize code into classes and objects, promoting code reusability and modularity. You learned about classes, objects, inheritance, polymorphism, and encapsulation. Understanding OOP concepts empowers you to write more structured, maintainable, and extensible code. In the next chapter, we will delve into an important aspect of software development: handling and working with data using libraries and frameworks.

If you liked the article, please explore our basket section filled with 15000+ objective type questions.