Object-Oriented Programming (OOP) Concepts

A beginner-friendly guide to the main Object-Oriented Programming concepts used in Python.

This document explains: - Classes - Objects - Inheritance - Encapsulation - Polymorphism - Abstraction - Composition vs Inheritance

These concepts are heavily used in: - game development - APIs - large Python applications - design patterns - 42 Python modules

What is OOP?

Object-Oriented Programming (OOP) is a programming style based on objects.

Objects: - store data - contain behavior - interact with each other

OOP helps organize large projects into reusable and maintainable structures.

Classes

A class is a blueprint for creating objects.

Example

class Duck:

    def quack(self) -> None:
        print("Quack!")

Creating an Object

duck = Duck()

duck.quack()

Output:

Quack!

Attributes

Attributes store data inside objects.

Example

class Player:

    def __init__(self, name: str) -> None:
        self.name = name

init()

__init__() is called automatically when an object is created.

It initializes the object attributes.

Creating the Object

player = Player("Sara")

Accessing Attributes

print(player.name)

Output:

Sara

Methods

Methods are functions inside classes.

Example

class Enemy:

    def attack(self) -> None:
        print("Enemy attacks!")

Inheritance

Inheritance allows one class to reuse another class.

A child class inherits: - attributes - methods - behavior

from a parent class.

Example

class Animal:

    def speak(self) -> None:
        print("Some sound")


class Dog(Animal):

    def bark(self) -> None:
        print("Woof!")

Using Inheritance

dog = Dog()

dog.speak()
dog.bark()

Output:

Some sound
Woof!

Why Use Inheritance?

Inheritance: - reduces duplicated code - improves organization - allows shared behavior

Overriding Methods

Child classes can replace parent behavior.

Example

class Animal:

    def speak(self) -> None:
        print("Animal sound")


class Cat(Animal):

    def speak(self) -> None:
        print("Meow")

Result

cat = Cat()

cat.speak()

Output:

Meow

This is called method overriding.

Polymorphism

Polymorphism means: - different objects - same method name - different behavior

Example

class Dog:

    def speak(self) -> None:
        print("Woof")


class Cat:

    def speak(self) -> None:
        print("Meow")

Using Polymorphism

animals = [Dog(), Cat()]

for animal in animals:
    animal.speak()

Output:

Woof
Meow

Same method: - different implementations

Encapsulation

Encapsulation means protecting internal object data.

Objects should control access to their own state.

Protected Attributes

Convention: - _name

Means: - "internal use" - should not be modified directly

Private Attributes

Convention: - __name

Makes direct access harder.

Example

class BankAccount:

    def __init__(self) -> None:
        self.__balance = 0

Access Problem

account = BankAccount()

print(account.__balance)

This raises an error.

Controlled Access

Use methods instead.

Example

class BankAccount:

    def __init__(self) -> None:
        self.__balance = 0

    def deposit(self, amount: int) -> None:
        self.__balance += amount

    def get_balance(self) -> int:
        return self.__balance

Abstraction

Abstraction hides implementation details.

The user interacts with: - simple interfaces - not internal complexity

Example

class CoffeeMachine:

    def make_coffee(self) -> None:
        print("Making coffee...")

The user: - presses a button - does not care about internal machine logic

Abstract Classes

Python supports abstract classes using ABC.

Example

from abc import ABC, abstractmethod


class Creature(ABC):

    @abstractmethod
    def attack(self) -> None:
        pass

Child Implementation

class Dragon(Creature):

    def attack(self) -> None:
        print("Fire breath!")

Why Use Abstraction?

Abstraction: - forces structure - improves consistency - defines required behavior

Very useful in: - game systems - factories - APIs - strategy patterns

Composition

Composition means: - objects contain other objects

Instead of inheriting behavior.

Example

class Engine:

    def start(self) -> None:
        print("Engine started")


class Car:

    def __init__(self) -> None:
        self.engine = Engine()

Using Composition

car = Car()

car.engine.start()

Composition vs Inheritance

Inheritance

Represents: - "is-a" relationship

Example:

Dog is an Animal

Composition

Represents: - "has-a" relationship

Example:

Car has an Engine

Which is Better?

Composition is often safer and more flexible.

Inheritance is useful when: - behavior is truly shared

Composition is useful when: - objects collaborate together

Real 42 Examples

Inheritance

class Enemy(GameObject):

Composition

class Game:
    self.player = Player()

Polymorphism

enemy.attack()
boss.attack()

Different enemies: - same method - different behavior

Common OOP Benefits

Better code organization
Reusability
Easier maintenance
Cleaner architecture
Scalability for large projects

Common OOP Problems

Bad OOP design may cause: - overly deep inheritance trees - tightly coupled systems - hard debugging - unnecessary complexity

Best Practices

Prefer composition over excessive inheritance
Keep classes focused on one responsibility
Use meaningful class names
Avoid giant classes
Encapsulate sensitive data
Use abstraction for shared interfaces

Summary Table

Concept	Meaning
Class	Blueprint for objects
Object	Instance of a class
Inheritance	Reuse behavior from another class
Encapsulation	Protect internal data
Polymorphism	Same method, different behavior
Abstraction	Hide implementation details
Composition	Objects containing objects

Final Notes

OOP is one of the most important programming paradigms in Python.

Understanding these concepts helps when building: - games - MLX projects - APIs - parsers - large applications - design pattern systems

Strong OOP foundations make code: - cleaner - safer - easier to scale