Classes & Objects Visualised

Think of a Class as an architectural blueprint or a cookie cutter. The blueprint describes what an account has (data) and what it can do (methods), but the blueprint itself does not hold money. An Instance (Object) is the actual house built from that blueprint.

Instantiate accounts and deposit or withdraw funds. Watch how each instance protects its own private self.balance without interfering with others:

class BankAccount:
    bank_name = "Apex Bank"    # Class variable (shared)

    def __init__(self, owner, balance=0):
        self.owner = owner     # Instance variable (unique)
        self.balance = balance

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

    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
            return True
        return False

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

d1 = Dog('Buddy')
d2 = Dog('Rocky')

Where you define a variable matters tremendously. A variable declared directly inside the class is shared by all instances. A variable attached to self inside __init__ belongs solely to that instance:

class Item:
    tax = 0.05

i1 = Item()
i2 = Item()
Item.tax = 0.10
print(i1.tax)

Methods that start and end with double underscores (dunder) let your custom objects integrate seamlessly with Python's built-in operators and functions:

def __str__(self):
    return f"Order #{self.id} for {self.customer} ($ {self.total})"

Trap 1 — The Mutable Class Attribute Bug. If you define a list or dict directly in the class body, every single instance shares the exact same collection!

# ❌ THE TRAP: items is a CLASS variable!
class Store:
    items = []  # Shared across EVERY Store instance!

delhi = Store()
mumbai = Store()

Trap 2 — Forgetting 'self' in method definitions. If you write def bark(): without self, calling dog.bark() crashes with TypeError: bark() takes 0 positional arguments but 1 was given.

Trap 3 — Missing parentheses on method calls. Writing print(account.get_balance) prints the method reference rather than calling it. Always add parentheses: account.get_balance().

Trap 4 — Fragile deep inheritance. Don't force everything into a subclass hierarchy. Look at composition below:

Writing def __init__(self, a, b, c): self.a = a ... repeatedly is tedious. Python's built-in @dataclass decorator generates __init__, __repr__, and __eq__ for you automatically:

from dataclasses import dataclass

@dataclass
class Customer:
    id: int
    name: str
    email: str
    active: bool = True

c = Customer(1, "Asha", "asha@example.com")
print(c)  # Customer(id=1, name='Asha', email='asha@example.com', active=True)

Explore and run full classes, dataclasses, and method pipelines in the Python Playground.

Demonstrate your understanding of classes, self, dunder methods, and attribute scopes. Get all 5 correct to finish Chapter 6!

class Counter:
    def __init__(self, start=0):
        self.value = start
    def add(self, amount):
        self.value += amount

first = Counter(2)
first.add(3)
print(first.value)

1class Counter:
2    def __init__(self, start=0):
3        self.value = start
4    def add(self, amount):
5        self.value += amount
6 
7first = Counter(2)
8first.add(3)
9print(first.value)

Run the code to see its output.

Run the full e-commerce OOP pipeline with @dataclass and custom dunders in the Python Playground (code preloaded).

• A class is the blueprint; an instance (object) is the live entity.
• self is how an instance refers to its own private state inside methods.
• Initialize lists and dicts inside __init__ on self to avoid the shared class attribute trap.
• Use dunder methods (__str__, __len__, __eq__) to make your classes feel native.
• Prefer Composition ("has-a") over deep Inheritance ("is-a") for resilient design.
• Use @dataclass to eliminate boilerplate when building data containers.