Skip to content

Understanding Object-Oriented Programming Principles in Python

Updated: at 04:23 AM

Object-oriented programming (OOP) is a programming paradigm centered around the concept of objects. In OOP, objects are used to represent real-world entities and consist of both data (attributes) and behaviors (methods). OOP principles allow for easier code organization and reuse, making it popular for large applications and systems. This comprehensive guide will explain the fundamental principles of OOP in Python and how to utilize them effectively.

Table of Contents

Open Table of Contents

Introduction to Object-Oriented Programming

OOP models real-world entities through computer software. These real-world entities are modeled as objects in OOP. An object is an instance of a class. A class provides the blueprint for the object and defines its attributes (data) and behaviors (methods). Objects are instances of these classes.

For example, a Person class can have attributes like name, age, height, etc. It can also have behaviors like walk(), talk(), eat(), etc. We can create multiple objects (instances) from this Person class, each representing a specific person with their own attribute values and behaviors.

The four fundamental principles that make a language object-oriented are:

  1. Encapsulation - Wrapping data and behaviors within an object, separating the object’s internal implementation details from its external interface.

  2. Abstraction - Reducing complexity by exposing only essential details and hiding implementation complexity.

  3. Inheritance - Ability of a class to inherit attributes and behaviors from a parent class, allowing code reuse.

  4. Polymorphism - Ability to treat objects of different classes in the same manner due to common parent class, allowing for code extensibility.

We will explore each of these principles in detail with Python examples as we progress through this guide.

Advantages of Object-Oriented Programming

OOP provides several advantages over procedural programming:

Proper application of OOP principles and best practices can lead to code that is efficient, modular, reusable, and easy to maintain. Let’s now explore OOP concepts in Python through examples.

Python Classes and Objects

In Python, nearly everything is an object. This includes numbers, strings, functions, classes, modules, etc. They all have attributes and methods associated with them. Python classes provide full support for OOP.

To define a class in Python, we use the class keyword:

class MyClass:
  # class definition

The class name is capitalized by convention. Inside the class, we define attributes and methods:

class Person:
  name = ""
  age = 0

  def say_hello(self):
    print("Hello, my name is " +

The self parameter refers to the current instance when called and is automatically passed. It allows accessing the attributes and methods of that particular object instance.

We can now create objects of this class:

person1 = Person() = "John"
person1.age = 20

person2 = Person() = "Sarah"
person2.age = 25

This creates two distinct person objects with their own name and age. We can call their methods:

person1.say_hello() # Hello, my name is John
person2.say_hello() # Hello, my name is Sarah

This demonstrates encapsulation and abstraction. The implementation details are encapsulated within the class, while the abstraction is the object instance itself.

Constructor Method

The constructor method __init__() is called automatically when an object is created from a class. It allows initializing attributes:

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

p1 = Person("John", 20)
print( # John
print(p1.age) # 20

Parameters like name and age are passed during object creation. The constructor assigns them to the instance attributes and self.age respectively.

Class and Static Methods

Along with instance methods that need a class instance, we can also have class and static methods.

Class methods receive the class itself as the first argument instead of self. We use the @classmethod decorator:

class Person:
  num_people = 0

  def print_people_count(cls):
    print("Number of people created:", cls.num_people)

p1 = Person()
p2 = Person()
Person.print_people_count() # Number of people created: 2

Static methods do not receive any additional arguments. We use the @staticmethod decorator:

class Math:

  def add(x, y):
    return x + y

print(Math.add(5, 7)) # 12

Static methods behave like regular functions but belong to the class’s namespace.


Inheritance allows a new class (child) to inherit attributes and methods from an existing class (parent). This promotes code reuse.

The child class can access all public attributes and methods of the parent:

class Vehicle:

  def __init__(self, make, color):
    self.make = make
    self.color = color

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

class Car(Vehicle):
  def open_trunk(self):
    print("Opening trunk of", self.make)

c = Car("Toyota", "grey") # Driving Toyota
c.open_trunk() # Opening trunk of Toyota

Car inherits from Vehicle and can access its __init__() and drive() methods. It has also defined its own open_trunk() method.

We can override inherited methods in the child class:

class Vehicle:

class Car(Vehicle):

  def drive(self):
    print("Driving car:", self.make, self.color)

c = Car("Toyota", "grey") # Driving car: Toyota grey

The drive() method is overridden in Car to have custom logic while reusing the constructor from Vehicle.

Multiple Inheritance

Python supports multiple inheritance, inheriting from multiple parent classes:

class A:
  def method(self):
    print("This is class A")

class B:
  def method(self):
    print("This is class B")

class C(A, B):

c = C()
c.method() # This is class A

C inherits from both A and B and resolves methods based on the order of inheritance.

Multiple inheritance should be used carefully as it can lead to increased complexity and ambiguity if not designed properly.


Polymorphism allows treating child class objects as parent class objects. For example:

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

class Dog(Animal):
  def make_sound(self):

class Cat(Animal):
  def make_sound(self):

dog = Dog()
cat = Cat()

def make_animal_sound(animal):

make_animal_sound(dog) # Bark
make_animal_sound(cat) # Meow

The make_animal_sound() function treats different objects polymorphically based on their class inheritance. This makes the code extensible - we can add more animal classes without modifying existing code.

Duck Typing

Duck typing allows polymorphism when inheritance is not used. Objects of different unrelated types are treated alike if they have the same methods and attributes.

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

class Cat:
  def speak(self):

def animal_speak(animal):

dog = Dog()
cat = Cat()

animal_speak(dog) # woof woof
animal_speak(cat) # meow

Different objects like Dog and Cat can be passed to animal_speak() since they have the same speak() method, allowing polymorphic behavior. This is duck typing - “If it walks like a duck and talks like a duck, it’s a duck”.

Data Encapsulation

Encapsulation involves bundling data with methods that operate on that data within a class. This prevents external code from accessing the internal state of the object.

In Python, we denote private attributes using a double underscore prefix:

class Person:

  def __init__(self, name, age):
    self.__name = name
    self.__age = age

p = Person('Mark', 23)

print(p.__name) # AttributeError

This restricts external access to __name and __age. We can access them through getter methods:

class Person:


  def get_name(self):
    return self.__name

  def get_age(self):
    return self.__age

p = Person('Mark', 23)

print(p.get_name()) # Mark

Setter methods allow modifying private attributes:

class Person:


  def set_age(self, new_age):
    if new_age < 0:
      raise ValueError("Invalid age")
    self.__age = new_age

p = Person('Mark', 23)

This encapsulates the internal state securely while providing a controlled interface to modify it if required.


Composition allows creating complex objects by combining simpler objects. We create new classes from existing classes that provide the desired functionality:

class Engine:

class Body:

class Car:

  def __init__(self):
    self.engine = Engine()
    self.body = Body()

  # methods that use self.engine and self.body

c = Car() # Car object with Engine and Body parts

The Engine and Body classes provide modular pieces of core functionality that is reused in the Car class via composition.


Object-oriented programming allows modeling complex systems by using objects to represent real-world entities along with their attributes and behaviors. The four pillars of OOP - encapsulation, abstraction, inheritance, and polymorphism - provide the fundamental principles for effective object-oriented design.

Python provides full support for implementing OOP through its classes, inheritance, and polymorphism mechanisms. Proper use of OOP concepts such as inheritance versus composition, public versus private access, and duck typing allow creating Python programs and applications that are modular, extensible and easier to maintain.

Understanding these core OOP principles is essential for Python developers. With its balance of simplicity, readability and power, Python makes an excellent language for demonstrating OOP concepts clearly and effectively to beginners and experts alike. This guide summarizes the key OOP ideas along with illustrative Python code examples for hands-on practice applying these principles in Python programs.