Python OOP
Python OOP

Python OOP: Python Beginner’s Course part 7

Object-Oriented Programming (OOP) in Python is a programming paradigm that uses objects and classes in programming. It aims to implement real-world entities like inheritance, hiding, polymorphism, etc. in programming. This article introduces the basics of OOP in Python, covering essential concepts like classes, objects, and inheritance.

Key Concepts in Python OOP

  • Encapsulation: Encapsulating data (attributes) and methods (functions) that work on the data into a single unit (class).
  • Inheritance: Extending the functionality of an existing class (parent class) into a new class (child class).
  • Polymorphism: The ability to present the same interface for different data types.
  • Abstraction: Hiding the complex reality while exposing only the necessary parts.

Understanding Python OOP

Python Classes

A class in Python is a blueprint for creating objects. Classes encapsulate data for the object and methods to manipulate that data.

Defining a Class:

class MyClass:
    x = 5

Creating Objects

Once a class is defined, you can create objects (instances) of that class, each with its own attributes and behaviors.

Creating an Object:

obj = MyClass()
print(obj.x)  # Output: 5

The __init__ Method

The __init__ method is a special method that gets called when a new object is instantiated. It’s used for initializing the object’s attributes.


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

Python Objects

Objects are instances of a class, created with specific data. Each object can have different data values.

Working with Object Attributes:

p1 = Person("Alice", 25)
print(  # Output: Alice
print(p1.age)   # Output: 25

Inheritance in Python OOP

Inheritance allows one class to inherit the attributes and methods of another class. This helps in code reusability and simplicity.

Defining a Parent Class:

class Animal:
    def speak(self):
        print("Some sound")

Creating a Child Class:

class Dog(Animal):
    def speak(self):
        print("Woof woof")

Abstract Classes

Abstract classes in Python are an important concept in object-oriented programming. They are used to define a blueprint for other classes, enforcing certain methods that the child classes must implement, but not providing implementations themselves. Abstract classes cannot be instantiated directly, meaning you cannot create objects of an abstract class. They are meant to be subclassed, and certain methods are to be implemented in the subclass.

Using Abstract Classes in Python

Python provides the abc module (Abstract Base Classes) to support the creation of abstract classes.

Defining an Abstract Class

To define an abstract class, you inherit from ABC (Abstract Base Class) provided by the abc module and define abstract methods using the @abstractmethod decorator.


from abc import ABC, abstractmethod

class AbstractClass(ABC):
    def do_something(self):

In this example, AbstractClass is an abstract class with an abstract method do_something.

Implementing an Abstract Class

To implement this abstract class, a subclass must override all its abstract methods.


class ConcreteClass(AbstractClass):
    def do_something(self):
        print("Doing something in the ConcreteClass")

# Now you can instantiate ConcreteClass
concrete = ConcreteClass()
concrete.do_something()  # Output: Doing something in the ConcreteClass

Why Use Abstract Classes?

  • Enforce Class Design: Abstract classes allow you to define a set of methods that must be created within any child classes built from the abstract class.
  • Code Organization: They provide a blueprint for other classes and enforce a design, making large software projects more organized and manageable.
  • Prevent Object Instantiation: Since abstract classes are only meant to be subclassed, they prevent the misuse of your class hierarchy by disallowing the instantiation of the base class.
  • Polymorphism: Abstract classes allow for polymorphism, where methods have the same name but behave differently for different classes.

Abstract Methods vs Regular Methods

While abstract methods define the structure and enforce implementation in subclasses, regular methods in abstract classes can still be used to provide common functionality that concrete subclasses can use or override.


Abstract classes in Python provide a way to create a set of methods that must be created within any child classes, ensuring a certain degree of uniformity across different implementations. This approach is beneficial in larger projects where a consistent interface is necessary, but the implementation details are dependent on specific use cases of the subclasses.

Resources and Further Reading


Understanding OOP concepts in Python is crucial for developing robust and reusable code. Python’s OOP features like classes and inheritance make it an ideal language for implementing real-world models and developing complex applications with ease. As you progress in your Python journey, a solid grasp of OOP principles will be invaluable in crafting efficient and scalable software solutions.

Leave a Reply