Home / Python / Day 6: Object-Oriented Programming / Classes & Objects

Classes & Objects

OOP basics — define classes, create objects, and use instance methods.

Classes and Objects

A class is a blueprint; an object is an instance. OOP organizes code around objects that combine data (attributes) and behavior (methods).

Syntax

<pre><code>class Car:
    """A class representing a car."""
    wheels = 4  # class attribute

    def __init__(self, make, model, year):
        self.make = make    # instance attributes
        self.model = model
        self.year = year
        self.speed = 0

    def accelerate(self, amount):
        self.speed += amount
        return self.speed

    def brake(self, amount):
        self.speed = max(0, self.speed - amount)

    def __str__(self):
        return f"{self.year} {self.make} {self.model}"

    def __repr__(self):
        return f"Car({self.make!r}, {self.model!r}, {self.year})"

# Creating objects
my_car = Car("Toyota", "Camry", 2023)
print(my_car)           # 2023 Toyota Camry
my_car.accelerate(60)
print(my_car.speed)     # 60
print(Car.wheels)       # 4 (class attribute)
</code></pre>

Revision Notes

• class ClassName: defines a class
• __init__(self, ...) is the constructor
• self refers to the current object
• Instance attributes unique per object; class attrs shared
• __str__ for human-readable string
• __repr__ for developer representation

Bank Account Class

Hard

Create a BankAccount class with:

Attributes:
- owner (str)
- balance (float, default 0)
- transactions (list)

Methods:
- deposit(amount): Add money, record transaction
- withdraw(amount): Remove money (raise ValueError if insufficient funds)
- get_balance(): Return current balance
- get_statement(): Print all transactions

Raise ValueError for negative amounts.

Input:

acc = BankAccount("Alice", 1000) acc.deposit(500) acc.withdraw(200)

Output:

Balance: 1300

Show Hint

Store transactions as dicts with type, amount, and balance fields.

Solve this Challenge

Show Solution

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []
        if balance > 0:
            self.transactions.append({"type": "initial", "amount": balance, "balance": balance})

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self.balance += amount
        self.transactions.append({"type": "deposit", "amount": amount, "balance": self.balance})
        return self.balance

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")
        if amount > self.balance:
            raise ValueError(f"Insufficient funds. Balance: {self.balance}")
        self.balance -= amount
        self.transactions.append({"type": "withdrawal", "amount": amount, "balance": self.balance})
        return self.balance

    def get_balance(self):
        return self.balance

    def get_statement(self):
        print(f"Account Statement for {self.owner}")
        print("-" * 40)
        for t in self.transactions:
            print(f"{t['type'].capitalize():15} | {t['amount']:8.2f} | Balance: {t['balance']:.2f}")

Inheritance & Polymorphism