OOP Basics — Classes & Inheritance

Core lesson 01

self is the instance the method was called on; Python passes it automatically as the first argument when you call obj.method(), which is really sugar for Class.method(obj).

Python doesn't have hidden magic for accessing 'the current object' — when you call obj.method(arg), Python translates it to Class.method(obj, arg) behind the scenes. self is just a parameter name (convention, not a keyword) that receives that instance. This is also why calling a method directly on the class requires passing the instance explicitly.

class Dog:
    def __init__(self, name):
        self.name = name
    def bark(self):
        return f"{self.name} says woof"

rex = Dog("Rex")
print(rex.bark())          # Rex says woof
print(Dog.bark(rex))       # identical -- same call, spelled explicitly

Core lesson 02

Instance attributes (self.x = ...) belong to one object. Class attributes (defined in the class body) are shared until an instance attribute shadows them. Lookup follows the Method Resolution Order (MRO) up through parent classes.

When you access obj.attr, Python first checks the instance's own __dict__. If not found there, it walks the class hierarchy (the MRO) looking on the class, then its parents, in a well-defined order. A class attribute acts like a shared default that any instance can override just by assigning to self.attr — which creates a new instance attribute rather than modifying the shared one.

class Counter:
    total_created = 0   # class attribute, shared
    def __init__(self):
        Counter.total_created += 1
        self.count = 0      # instance attribute, per-object

a, b = Counter(), Counter()
a.count += 5
print(a.count, b.count)          # 5 0 -- independent
print(Counter.total_created)     # 2  -- shared, tracked once

class Counter:
    total_created = 0     <- lives on the CLASS
    def __init__(self):
        self.count = 0    <- lives on EACH INSTANCE

a.count         -> instance dict first, found there
a.total_created -> not on instance, found on class (shared)

Core lesson 03

Overriding means redefining a method with the same name in a subclass, replacing the parent's version. super() lets the subclass call the parent's implementation too, usually to extend rather than fully replace it.

If a subclass defines a method with the same name as its parent, calling it on a subclass instance uses the subclass's version — this is overriding. Often you still want the parent's behavior to run too (e.g. its __init__ setting up base attributes); super().method(...) calls the next class in the MRO's version of that method, letting you layer behavior instead of duplicating it.

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):
        base = super().speak()
        return f"{base}, specifically: Woof!"

print(Dog("Rex").speak())   # Rex makes a sound, specifically: Woof!