Python Classes and Objects

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

rex = Dog("Rex", 3)
bella = Dog("Bella", 5)
print(rex.name, bella.age)    # Rex 5

• class Dog: starts the definition. Class names use CapWords by convention.
• __init__ is a special method that runs automatically whenever a new object is created. It sets up the object's starting attributes.
• Calling the class like a function, Dog("Rex", 3), creates a new object, also called an instance.
• Each object has its own attributes, reached with a dot: rex.name.

Every method's first parameter is self: the particular object the method is working on. When you call rex.bark(), Python quietly turns it into Dog.bark(rex), so inside the method self is rex.

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

    def bark(self):
        return f"{self.name} says woof!"

self.name = name stores the argument on the object so other methods can use it later. Forgetting self. is a classic mistake: a plain name = name inside __init__ creates a temporary local variable that disappears when the method ends.

Methods can read and update the object's attributes, which keeps all the rules about the data in one place:

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

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self.balance += amount

Because the check lives inside deposit(), no part of your program can accidentally add a negative amount, as long as it uses the method. Python doesn't strictly stop people changing attributes directly, but by convention a name starting with an underscore, such as _balance, means "internal: please use the methods".

An attribute defined directly in the class body, outside any method, is a class attribute, shared by every object. It suits values that are the same for all instances, such as an interest rate.

Printing an object normally shows something unhelpful like <__main__.Account object at 0x10f3>. Define __str__ to choose what print() and str() display:

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

Methods with double underscores on both sides are called dunder methods. Python calls them automatically in particular situations, and they let your objects work naturally with built-in functions.

When you read obj.attribute, Python first looks on the object itself, then on its class. That explains how class attributes are shared, and why assigning through an object behaves differently:

class Account:
    interest_rate = 0.02        # class attribute

a = Account()
b = Account()
a.interest_rate = 0.05          # creates an attribute on a only
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.05 0.02 0.02

Assigning a.interest_rate didn't change the class; it gave a its own attribute that hides the shared one. To change the rate for everyone, assign to Account.interest_rate.

Objects are also compared by identity by default: two separate Account objects with identical balances are not == unless you define __eq__. The dataclasses lesson shows how to get sensible comparison for free, and magic methods covers __eq__, __repr__ and the rest.