Object-Oriented Programming (OOP) in Python

  1. Object-Oriented Programming (OOP) in Python
  2. Advanced Data Structures in Python: Deque, Stacks, Queues, and Beyond
  3. Lambda Functions and Map/Filter/Reduce: Unleashing Functional Programming in Python
  4. Generators and Iterators in Python: Mastering Lazy Evaluation
  5. Unveiling Python’s Advanced Features: Decorators and Metaprogramming
  6. Mastering Pattern Matching and Text Manipulation with Regular Expressions in Python
  7. Exploring Database Access with Python: Connecting, Querying, and Beyond
  8. Empowering Your Python Journey: An In-depth Introduction to Python Libraries
  9. Mastering Python: Debugging and Profiling Your Code
  10. Mastering Python: Advanced File Operations


Python’s versatility and readability have made it a top choice for developers, and one of its most essential features is Object-Oriented Programming (OOP). OOP is a programming paradigm that promotes code organization, reusability, and maintainability. In this first article of our Python programming series for intermediates, we will embark on an in-depth exploration of Object-Oriented Programming in Python, covering classes, objects, inheritance, polymorphism, and more. 

Classes and Objects

At the core of Object-Oriented Programming in Python are classes and objects. A class is a blueprint for creating objects, while an object is an instance of a class. Let’s delve deeper into this concept:

class Dog:
    def __init__(self, name, breed): = name
        self.breed = breed

    def bark(self):
        return f"{} barks!"

Creating an object of the Dog class
my_dog = Dog("Buddy", "Golden Retriever")

Accessing object properties and methods
print(f"{} is a {my_dog.breed}. {my_dog.bark()}")

In this example, we define a `Dog` class with a constructor (`__init__`) to initialize object properties (name and breed) and a `bark` method. We then create an object `my_dog` based on this class and access its properties and methods.


Inheritance is a fundamental concept in OOP that allows you to create a new class based on an existing one. The new class inherits attributes and methods from the base class. Let’s see an example:

class Animal:
    def __init__(self, name): = name

    def speak(self):

class Cat(Animal):
    def speak(self):
        return f"{} says Meow!"

class Dog(Animal):
    def speak(self):
        return f"{} says Woof!"

Creating objects of the derived classes
my_cat = Cat("Whiskers")
my_dog = Dog("Buddy")

Accessing overridden methods
print(my_cat.speak())  Output: Whiskers says Meow!
print(my_dog.speak())  Output: Buddy says Woof!

In this example, we have a base class `Animal` with a `speak` method. We then create two derived classes, `Cat` and `Dog`, which inherit from `Animal` and override the `speak` method to provide their own implementations.


Polymorphism allows objects of different classes to be treated as objects of a common base class. This is achieved through method overriding, as demonstrated in the previous example. Let’s explore polymorphism further:

def animal_sound(animal):
    return animal.speak()

Using polymorphism with different objects
my_animal = Animal("Generic Animal")
print(animal_sound(my_animal))  Output: (No specific sound)

my_cat = Cat("Whiskers")
my_dog = Dog("Buddy")

print(animal_sound(my_cat))  Output: Whiskers says Meow!
print(animal_sound(my_dog))  Output: Buddy says Woof!

Here, the `animal_sound` function takes an object of the base class `Animal` as a parameter and calls its `speak` method. This demonstrates how different objects can be treated polymorphically as long as they inherit from the same base class.

Encapsulation and Abstraction

In addition to classes, objects, inheritance, and polymorphism, OOP in Python also emphasizes encapsulation and abstraction. Encapsulation is the practice of bundling data (attributes) and methods that operate on that data into a single unit (the class). Abstraction, on the other hand, involves hiding complex implementation details and exposing only essential features.

Class Variables and Methods

Python classes can have class variables and methods. Class variables are shared among all instances of a class, while class methods are defined on the class rather than instances. Here’s an example:

class Circle:
    pi = 3.14159  Class variable

    def __init__(self, radius):
        self.radius = radius

    def circumference(cls, radius):
        return 2  cls.pi  radius

Using class variables and methods
circle1 = Circle(5)
print(f"Circle 1's circumference: {Circle.circumference(circle1.radius)}")

circle2 = Circle(7)
print(f"Circle 2's circumference: {Circle.circumference(circle2.radius)}")

In this example, the `pi` variable is a class variable, and the `circumference` method is a class method that uses the class variable.


In this comprehensive guide, we’ve explored the fundamentals of Object-Oriented Programming in Python, covering classes, objects, inheritance, polymorphism, encapsulation, abstraction, class variables, and methods. OOP is a powerful paradigm that enables you to write organized, reusable, and maintainable code, making it a valuable skill for any Python developer.

As you continue your journey into Python programming, remember that OOP is just one of the many tools at your disposal for creating elegant and efficient solutions to complex problems. Stay tuned for the next article in our series, where we’ll dive deeper into OOP concepts and explore advanced topics, including composition, interfaces, and design patterns.