Object-oriented programming (OOP) structures software design around data, or "objects," rather than functions and logic. This approach models real-world entities as code classes to manage complexity through inheritance, polymorphism, and encapsulation.

Procedural vs. Object-Oriented Thinking

Traditional procedural programming relies on a linear sequence of steps, similar to an assembly line. While effective for simple tasks, maintaining complex systems becomes difficult when one change affects many parts.

In contrast, OOP treats everything as an object with attributes and behaviors. Consider a game scenario requiring distinct characters. Instead of passing dictionaries between functions, we define blueprints (classes) that enforce structure. For instance, defining a generic Entity class allows all combatants to share common properties like health, while specific subclasses handle unique abilities.

class Entity:
    def __init__(self, name, hp):
        self.name = name
        self.hp = hp

# Instantiating specific types
player = Entity('Warrior', 100)
enemy = Entity('Slime', 50)

Classes and Instances

A Class is a blueprint for creating objects, defining their initial state (attributes) and behavior (methods). An Instance is a concrete realization of a class created during execution.

Defining a Class

To define a class in Python, use the class keyword followed by the class name (typically PascalCase).

class Character:
    '''Base blueprint for any character in the simulation.'''
    species = 'Human'  # Class attribute (shared across instances)

    def __init__(self, name, health, strength):
        # Instance attributes (specific to each object)
        self.name = name
        self.health = health
        self.strength = strength

    def move(self):
        print(f"{self.name} is moving...")

    def attack(self, target):
        damage = self.strength
        target.take_damage(damage)

Instantiation and The self Keyword

Instantiation occurs when you call the class like a function: Character("Alice", 100, 10). This triggers the __init__ method. The first parameter in methods is conventionally named self, representing the specific instance being operated on.

alice = Character("Alice", 100, 10)
print(alice.name)       # Accesses instance attribute
alice.move()            # Calls instance method

The self argument allows methods to access and modify the specific object's data. Its passed implicitly by the interpreter when calling instance methods.

Inheritance and Polymorphism

Inheritance promotes code reuse by allowing new classes to inherit attributes and methods from existing ones.

Single and Multiple Inheritance

Subclasses can extend parent classes to add functionality without rewriting common logic.

class Human(Character):
    species = 'Human'
    def talk(self):
        print(f"Hello, I am {self.name}")

class Beast(Character):
    species = 'Beast'
    def roar(self):
        print("Roar!")

hero = Human("Hero", 80, 20)
beast = Beast("Wolf", 60, 15)

hero.talk()   # Human-specific method
beast.roar()  # Beast-specific method

Python supports multiple inheritance, where a class derives from more than one base class. However, this introduces complexity known as the Diamond Problem regarding Method Resolution Order (MRO).

Overriding and Super()

Subclasses can override parent methods to customize behavior. To execute the original parent logic, use the super() function.

class SpecializedCharacter(Human):
    def attack(self, target):
        # Execute parent's attack logic
        super().attack(target)
        # Add custom effect
        print(f"Special power triggered against {target.name}")

Polymorphism allows different objects to respond to the same message (method call) in different ways. Functions can accept any object that possesses the required method, adhering to Duck Typing principles (if it walks like a duck...).

Encapsulation

Encapsulation restricts direct access to some of an object's components to prevent accidental modification of internal state.

Name Mangling

Attributes starting with double underscores (__) are considered private. Python alters their names internally to prevent accidental overriding, though they can still be accessed via mangled names (e.g., _ClassName__attribute).

class SecureAccount:
    def __init__(self, balance):
        self.__balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

Property Decorators

For read-only computed values or controlled access, the @property decorator is ideal. It behaves like a standard attribute during reading but executes a function.

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def area(self):
        return self.width * self.height

rect = Rectangle(10, 5)
print(rect.area)  # Accessed like an attribute

Composition

Composition involves building complex objects by combining simpler ones. Unlike inheritance (an "is-a" relationship), composition represents a "has-a" relationship.

class Weapon:
    def __init__(self, name, damage):
        self.name = name
        self.damage = damage

class Warrior(Character):
    def __init__(self, name, health):
        super().__init__(name, health, 10)
        self.weapon = None

    def equip(self, w: Weapon):
        self.weapon = w

    def attack(self, target):
        dmg = self.strength
        if self.weapon:
            dmg += self.weapon.damage
        target.take_damage(dmg)

Using composition reduces coupling compared to tight inheritance hierarchies. A character has a weapon; they are not the same type of thing.

Abstract Base Classes

Abstract classes cannot be instantiated directly. They serve as a template for subclasses, enforcing a specific interface using the abc module.

import abc

class Payment(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def process_payment(self, amount):
        pass

class Alipay(Payment):
    def process_payment(self, amount):
        print(f"Alipay processed {amount}")

class Cash(Payment):
    def process_payment(self, amount):
        print(f"Cash received: {amount}")

Advanced Methods

Beyond instance methods, Python supports static and class methods for utility purposes.

• @staticmethod: Does not require access to self or cls. Used for utility functions grouped within a namespace.
• @classmethod: Receives the class itself (cls) as the first argument. Useful for alternative constructors.

class Calculator:
    def __init__(self, value):
        self.value = value

    @classmethod
    def get_zero(cls):
        return cls(0)

Design Principles

When developing software, consider these guidelines:

1. Keep Classes Small: Focus on single responsibilities.
2. Use Composition over Inheritance: Prefer aggregating objects to extend behavior.
3. Follow Abstraction: Program against interfaces, not implementations.
4. Encapsulate Variability: Hide details that are likely to change.

Effective OOP design evolves through iteration. Start with clear models of entities involved in your system, refine relationships, and apply these patterns iteratively to maintain codebase health.