Object-Oriented Programming (OOP) in Python: Classes and Objects Explained

Object-Oriented Programming (OOP) is a key approach used in software development.

In this article, we'll explore the main ideas of OOP, particularly looking at classes, objects, inheritance, and polymorphism in Python.

By the end of this guide, you'll understand how to organize your Python code using OOP principles, making your programs more modular, reusable, and easier to maintain.

If you prefer you can follow along with the video version:

What is Object-Oriented Programming?

Object-Oriented Programming (OOP) organizes software design around data, or objects, rather than functions and logic.

An object is like a container with unique attributes (data) and behaviors (functions). OOP focuses on several key concepts:

Encapsulation

This means bundling the data (attributes) and the methods (functions) that operate on that data into a single unit, called a class.

It also involves restricting access to some components of the object, making it more secure.

Abstraction

This is the idea of hiding the complex implementation details and showing only the essential features of the object.

It reduces complexity and allows the programmer to focus on higher-level interactions.

Inheritance

This is a mechanism for creating a new class (derived class) from an existing class (base class).

The new class inherits attributes and methods from the existing class.

Polymorphism

This is the ability to use a single interface to represent different data types.

It allows objects to be treated as instances of their parent class and makes it possible to define methods in a child class that have the same name as a method in the parent class.

OOP Basics in Python: Classes and Objects

At the core of Object-Oriented Programming (OOP) in Python are classes and objects.

Classes

A class is like a blueprint for creating objects.

It defines a set of properties (attributes) and actions (methods) that the objects will have.

In Python, you create a class using the class keyword. Here's an example:

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def start_engine(self):
        print(f"{self.make} {self.model}'s engine started.")

Objects

An object is an instance of a class.

Once you define a class, you can create multiple objects (instances) from it.

Each object can have its own unique values for the attributes defined in the class.

Here's how you create and use an object:

my_car = Car("Toyota", "Corolla", 2020)
my_car.start_engine()  # Output: Toyota Corolla's engine started.

In this example, my_car is an object of the Car class.

It has its own values for make, model, and year, and you can use methods like start_engine.

Inheritance in Python

Inheritance lets one class (the child class) take on the attributes and methods of another class (the parent class).

This is great for reusing code and setting up a hierarchy between classes.

Here's an example:

class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def drive(self):
        print("Driving...")


class Car(Vehicle):
    def __init__(self, make, model, year):
        super().__init__(make, model)
        self.year = year

    def start_engine(self):
        print(f"{self.make} {self.model}'s engine started.")


my_car = Car("Honda", "Civic", 2021)
my_car.drive()  # Output: Driving...
my_car.start_engine()  # Output: Honda Civic's engine started.

In this example, the Car class inherits from the Vehicle class.

Because of this, the Car class can use the drive method that's defined in the Vehicle class.

Method Overriding

Sometimes, a child class needs to change or add to the behavior of a method it inherits from a parent class.

This is done through method overriding.

Here's an example:

class Vehicle:
    def drive(self):
        print("Driving a vehicle...")


class Car(Vehicle):
    def drive(self):
        print("Driving a car...")


my_vehicle = Vehicle()
my_vehicle.drive()  # Output: Driving a vehicle...

my_car = Car()
my_car.drive()  # Output: Driving a car...

In this example, the drive method in the Car class overrides the drive method in the Vehicle class, allowing for customized behavior.

Multiple Inheritance

Python also supports multiple inheritance, where a class can inherit from more than one base class.

Here's an example: