Object-oriented programming

What you'll learn

How to define a class, create objects from it, give them data and behaviour, and reuse code with inheritance.

Why it matters

As programs grow, functions and variables floating around get hard to manage. Classes bundle data and the functions that work on it into one unit, which mirrors how we think about things: a bank account, a player, a product.

Explanation

A class is a blueprint. An object (or instance) is one thing built from the blueprint.

• __init__ is the constructor. It runs when you create an object and sets up its data.
• self is the object itself. Every method receives it as its first parameter.
• Variables on self are attributes; functions in the class are methods.
• Create an object by calling the class: rex = Dog("Rex").

Inheritance lets a class reuse another: class Puppy(Dog): gets everything from Dog and can add or override methods. super() calls the parent's version.

Special methods such as __str__ control how an object prints.

Example

Step-by-step walkthrough

1. Account stores an owner and a balance. deposit and withdraw are methods that change self.balance.
2. __str__ decides what print(a) shows.
3. For a: start 100, deposit 50 gives 150, withdraw 30 gives 120. It prints Asha: 120.
4. Savings inherits from Account. super().__init__ runs the parent's setup, then adds a rate.
5. add_interest calls the inherited deposit: 200 plus 10 gives 210.0, so it prints Ravi: 210.0.
6. Withdrawing 1000 raises ValueError, which we catch and print: Error: Not enough money.

Try it yourself

Add a Dog class with a speak method, then a Puppy subclass that overrides speak.

ClassesPython

Editable codeclass Account: def __init__(self, owner, balance=0): self.owner = owner self.balance = balance def deposit(self, amount): self.balance += amount def __str__(self): return f"{self.owner}: {self.balance}" a = Account("Asha", 100) a.deposit(50) print(a)

Run ResetCopyCtrl+Enter to run

Common mistakes

• Forgetting self in method definitions or when accessing attributes.
• Misspelling __init__ (it has two underscores on each side).
• Sharing a mutable default such as items=[] in __init__.
• Deep inheritance trees. Prefer small classes and composition.

Quick quiz

Summary

• A class is a blueprint; an object is an instance with its own data.
• __init__, self, methods and attributes make up a class.
• Inheritance reuses and extends behaviour; super() calls the parent.

Next: handling things that go wrong.

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

    def speak(self):
        return self.name + " says woof"

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

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

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Not enough money")
        self.balance -= amount

    def __str__(self):
        return f"{self.owner}: {self.balance}"


class Savings(Account):
    def __init__(self, owner, balance=0, rate=0.05):
        super().__init__(owner, balance)
        self.rate = rate

    def add_interest(self):
        self.deposit(self.balance * self.rate)


a = Account("Asha", 100)
a.deposit(50)
a.withdraw(30)
print(a)

s = Savings("Ravi", 200)
s.add_interest()
print(s)

try:
    a.withdraw(1000)
except ValueError as e:
    print("Error:", e)