Procedural approach

Data and functions are separate — you pass data to functions and hope nothing breaks.

name = "Lia"
balance = 100.0

def deposit(balance, amount):
    return balance + amount

balance = deposit(balance, 50)

OOP approach

Data and behavior are bundled together — the object knows what it can do.

class BankAccount:
    def __init__(self, owner, balance):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount

acc = BankAccount("Lia", 100.0)
acc.deposit(50)

• A class is a blueprint.
• An instance is one concrete object created from that blueprint.
• self refers to this instance inside the class.
• Each instance has its own copy of instance attributes.

class Point:
    def __init__(self, x, y):
        self.x = x   # instance attribute
        self.y = y

    def distance_to(self, other):
        return ((self.x - other.x)**2 +
                (self.y - other.y)**2) ** 0.5

p1 = Point(0, 0)   # instance
p2 = Point(3, 4)

print(p1.distance_to(p2))  # 5.0
print(isinstance(p1, Point))  # True

• Called automatically when an instance is created.
• Sets up instance attributes on self.
• Can have default parameter values.
• Does not return anything (implicitly returns None).

class BankAccount:
    def __init__(self, owner="Unknown",
                 balance=0.0):
        self.owner = owner
        self._balance = balance  # _ = convention

acc = BankAccount("Lia", 500.0)
print(acc.owner)    # Lia
print(acc._balance) # 500.0

Bundle data + behavior together, and restrict direct access to internals.

class Thermostat:
    def __init__(self, temp):
        self._temp = temp   # internal state

    @property
    def temperature(self):
        return self._temp

    def set_temperature(self, value):
        if value < 0 or value > 40:
            raise ValueError("Out of range")
        self._temp = value

t = Thermostat(22)
t.set_temperature(25)   # OK
t.set_temperature(100)  # ValueError

• A child class inherits all attributes and methods of its parent.
• Use super() to call the parent's method.
• issubclass(Child, Parent) → True
• Child can override any parent method.

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

    def speak(self):
        return f"{self.name} makes a sound"

class Dog(Animal):
    def speak(self):          # override
        return f"{self.name} barks"

class Cat(Animal):
    def speak(self):          # override
        return f"{self.name} meows"

pets = [Dog("Rex"), Cat("Luna")]
for p in pets:
    print(p.speak())
# Rex barks
# Luna meows

• Same method name, different behavior depending on the object's type.
• Lets you write code that works on any object with the right interface.
• Achieved through method overriding and duck typing.

class Shape:
    def area(self): ...

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return 3.14159 * self.r ** 2

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w, self.h = w, h
    def area(self):
        return self.w * self.h

shapes = [Circle(5), Rectangle(3, 4)]
for s in shapes:
    print(s.area())   # each behaves correctly

• Hide implementation details; expose only what the caller needs.
• Abstract Base Class (ABC) defines a required interface.
• Any subclass must implement the abstract methods or Python raises TypeError.

from abc import ABC, abstractmethod

class PaymentMethod(ABC):
    @abstractmethod
    def charge(self, amount):
        ...   # no implementation here

class CreditCard(PaymentMethod):
    def charge(self, amount):
        print(f"Charging ${amount} to card")

class PayPal(PaymentMethod):
    def charge(self, amount):
        print(f"Sending ${amount} via PayPal")

# PaymentMethod()  ← TypeError!
cc = CreditCard()
cc.charge(50)   # Charging $50 to card

Class Variables

Shared across all instances of the class. Set on the class, not on self.

class Counter:
    count = 0           # class variable

    def __init__(self):
        Counter.count += 1

a = Counter()
b = Counter()
print(Counter.count)  # 2

super()

Call the parent class's method — especially __init__ — without hardcoding the parent's name.

class SavingsAccount(BankAccount):
    def __init__(self, owner, balance,
                 interest_rate):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate

    def apply_interest(self):
        self._balance *= (1 + self.interest_rate)

from functools import total_ordering

@total_ordering
class Student:
    def __init__(self, name, gpa):
        self.name = name
        self.gpa = gpa

    def __eq__(self, other):
        return self.gpa == other.gpa

    def __lt__(self, other):
        return self.gpa < other.gpa

s1 = Student("Alice", 3.8)
s2 = Student("Bob",   3.5)
print(s1 > s2)   # True  ← derived by decorator
print(sorted([s1, s2], reverse=True))  # by GPA

• Objects used as dict keys or in sets must be hashable.
• If you define __eq__, Python sets __hash__ = None (unhashable) by default.
• To restore hashability, define __hash__ explicitly — it must be consistent with __eq__.

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

    def __hash__(self):
        return hash((self.x, self.y))

p = Point(1, 2)
seen = {p}             # works — hashable
memo = {p: "origin"}   # works as dict key

Define dunder methods to make built-in operators work on your objects.

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):
        return Vector(self.x + other.x,
                      self.y + other.y)

    def __mul__(self, scalar):
        return Vector(self.x * scalar,
                      self.y * scalar)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)    # Vector(4, 6)
print(v1 * 3)     # Vector(3, 6)

A decorator that auto-generates __init__, __repr__, and __eq__ from annotated fields — eliminating boilerplate.

from dataclasses import dataclass, field

@dataclass(order=True)
class Student:
    name: str
    gpa: float
    courses: list = field(default_factory=list)

s1 = Student("Alice", 3.8)
s2 = Student("Bob",   3.5)
print(s1)          # Student(name='Alice', gpa=3.8, ...)
print(s1 > s2)     # True  (order=True)

@dataclass(frozen=True)
class Point:
    x: float
    y: float

p = Point(1, 2)
# p.x = 9   ← FrozenInstanceError
d = {p: "origin"}  # hashable!

• Instance variable: set on self; unique per object.
• Class variable: set on the class; shared across all instances.

# WRONG — all instances share one list!
class Broken:
    items = []    # class variable

# CORRECT — each instance gets its own list
class Fixed:
    def __init__(self):
        self.items = []    # instance variable

class Player:
    count = 0         # class variable

    def __init__(self, name):
        self.name = name      # instance var
        Player.count += 1     # update class var

p1 = Player("Lia")
p2 = Player("Kai")

print(Player.count)   # 2  (shared)
print(p1.name)        # Lia (unique)
print(p2.name)        # Kai (unique)

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):   # alt constructor
        return cls((f - 32) * 5/9)

    @staticmethod
    def is_valid(celsius):         # utility
        return -273.15 <= celsius

t = Temperature.from_fahrenheit(212)
print(t.celsius)              # 100.0
print(Temperature.is_valid(-300))  # False