Classes.
Data that knows how to behave.

# Define a class
class User:
def init(self, name, age):
self.name = name
self.age = age

def greet(self):
return f"Hello, {self.name}!"

def birthday(self):
self.age += 1
return self.age

# Create instances (objects)
alice = User("Alice", 30)
bob = User("Bob", 25)

# Access attributes
print(alice.name) # Alice
print(bob.age) # 25

# Call methods
print(alice.greet()) # Hello, Alice!
print(alice.birthday()) # 31
print(alice.age) # 31 — attribute changed
print(bob.age) # 25 — bob is unaffected

class Counter:
def init(self):
self.count = 0

def increment(self):
self.count += 1

def get(self):
return self.count

c = Counter()
c.increment()
c.increment()
c.increment()
print(c.get()) # 3

# What self actually is:
# c.increment() is short for Counter.increment(c)
# c.get() is short for Counter.get(c)

# Common error: forgetting self in the definition
class Broken:
def greet(): # no self!
return "hi"

b = Broken()
# b.greet() → TypeError: greet() takes 0 positional arguments but 1 was given
# Python passes b as the first argument, but greet() doesn't accept it.

# The fix:
class Fixed:
def greet(self):
return "hi"

class Money:
def init(self, amount, currency="USD"):
self.amount = amount
self.currency = currency

# repr — how the object shows in the REPL / print()
def repr(self):
return f"Money({self.amount}, '{self.currency}')"

# str — how it shows with str() (defaults to repr if not set)
def str(self):
return f"${self.amount:.2f} {self.currency}"

# eq — enables ==
def eq(self, other):
return self.amount == other.amount and self.currency == other.currency

# lt — enables < (needed for sorted())
def lt(self, other):
return self.amount < other.amount

# add — enables +
def add(self, other):
return Money(self.amount + other.amount, self.currency)

# len — enables len()
def len(self):
return len(str(self.amount))

m1 = Money(10)
m2 = Money(25)

print(m1) # $10.00 USD (uses str)
print(repr(m1)) # Money(10, 'USD') (uses repr)
print(m1 == m2) # False (uses eq)
print(m1 < m2) # True (uses lt)
print(m1 + m2) # $35.00 USD (uses add)
print(sorted([m2, m1])) # [Money(10), Money(25)] (uses lt)

# Base class
class Animal:
def init(self, name):
self.name = name

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

def describe(self):
return f"I am {self.name}"

# Child class — inherits everythingViewController
# Inherits everything from Animal, overrides speak()
class Dog(Animal):
def speak(self):
return f"{self.name} barks"

class Cat(Animal):
def init(self, name, indoor=True):
super().init(name) # call parent's init
self.indoor = indoor

def speak(self):
return f"{self.name} meows"

# Use them
a = Animal("Generic")
d = Dog("Rex")
c = Cat("Whiskers", indoor=False)

print(a.speak()) # Generic makes a sound
print(d.speak()) # Rex barks
print(c.speak()) # Whiskers meows

# Inherited methods work on children
print(d.describe()) # I am Rex (from Animal)
print(c.describe()) # I am Whiskers (from Animal)

# isinstance() checks the inheritance chain
print(isinstance(d, Dog)) # True
print(isinstance(d, Animal)) # True (Dog is an Animal)
print(isinstance(c, Dog)) # False

# Before: dict + free functions (a sign it wants to be a class)
def create_user(name, email):
return {"name": name, "email": email, "active": True}

def validate_email(user):
if "@" not in user["email"]:
raise ValueError("Invalid email")
return user

def deactivate(user):
user["active"] = False

def greet(user):
return f"Hello, {user['name']}"

# After: a class — everything the user can do is on the user
class User:
def init(self, name, email):
if "@" not in email:
raise ValueError("Invalid email")
self.name = name
self.email = email
self.active = True

def deactivate(self):
self.active = False

def greet(self):
return f"Hello, {self.name}"

# Now: u = User("Alice", "a@b.com"); u.deactivate(); u.greet()
# The data and behavior live together. That's the refactor.

class BankAccount:
"""A bank account with validation and transaction history."""

def init(self, owner, balance=0):
if balance < 0:
raise ValueError("Opening balance can't be negative")
self.owner = owner
self.balance = balance
self.history = []

def deposit(self, amount):
if amount <= 0:
raise ValueError("Deposit must be positive")
self.balance += amount
self.history.append(f"+$`{amount:.2f}")

def withdraw(self, amount):
if amount <= 0:
raise ValueError("Withdrawal must be positive")
if amount > self.balance:
raise ValueError(f"Insufficient funds: balance ${self.balance:.2f}"</span>) self.balance -= amount self.history.<span class="fn">append</span>(<span class="str">f"-${amount:.2f}")

def repr(self):
return f"BankAccount('{self.owner}', balance=`${self.balance:.2f})"

def str(self):
return f"{self.owner}'s account: $`{self.balance:.2f}"

def eq(self, other):
return self.owner == other.owner and self.balance == other.balance

# Use it
acct = BankAccount("Alice", 100)
acct.deposit(50)
acct.withdraw(30)

print(acct) # Alice's account: $120.00</span> <span class="fn">print</span>(<span class="fn">repr</span>(acct)) <span class="com"># BankAccount('Alice', balance=$120.00)
print(acct.history) # ['+$50.00', '-$30.00']

# Validation catches mistakes
try:
acct.withdraw(1000)
except ValueError as e:
print(f"Error: {e}") # Error: Insufficient funds: balance `$120.00