Object-Oriented Programming: Python Classes and OOP

Object-Oriented Programming (OOP) lets you model real-world concepts as self-contained objects that bundle data and behaviour together. Instead of scattering functions and variables across a file, you define a class — a blueprint — and create as many instances of it as you need, each with its own data. This approach scales well for complex applications and is the basis of frameworks like FastAPI and Django.

Defining a Class

Use the class keyword followed by the class name (by convention, PascalCase) and a colon:

class Student:
    pass   # an empty but valid class

The `init` Method and `self`

__init__ is the constructor — Python calls it automatically whenever you create a new instance. The first parameter, self, is a reference to the instance being created. Every instance attribute you want the object to have is set on self:

class Student:
    def __init__(self, name, age):
        self.name = name   # instance attribute
        self.age  = age    # instance attribute

    def introduce(self):
        print(f"Hi, I'm {self.name} and I'm {self.age} years old.")

    def study(self, subject):
        print(f"{self.name} is studying {subject}.")

Creating Instances

Call the class like a function to create an instance:

student1 = Student("Alice", 20)
student2 = Student("Bob",   23)

student1.introduce()        # Hi, I'm Alice and I'm 20 years old.
student2.study("Python")    # Bob is studying Python.

print(student1.name)        # Alice
print(student2.age)         # 23

Each instance is independent — changing student1.name does not affect student2.

Instance Attributes vs Class Attributes

An instance attribute lives on the object itself (set via self). A class attribute lives on the class and is shared by all instances:

class Product:
    category = "General"          # class attribute — shared by all

    def __init__(self, name, price):
        self.name  = name         # instance attribute — unique per object
        self.price = price

laptop = Product("Laptop", 999.99)
phone  = Product("Phone",  499.99)

print(Product.category)    # General
print(laptop.category)     # General (inherited from class)
print(laptop.name)         # Laptop
print(phone.name)          # Phone

Product.category = "Electronics"
print(laptop.category)     # Electronics — class attribute changed for all

Methods

Instance Methods

Instance methods take self as their first argument and can read and modify the object’s attributes:

class BankAccount:
    def __init__(self, owner, balance=0.0):
        self.owner   = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        print(f"Deposited £{amount:.2f}. Balance: £{self.balance:.2f}")

    def withdraw(self, amount):
        if amount > self.balance:
            print("Insufficient funds.")
        else:
            self.balance -= amount
            print(f"Withdrew £{amount:.2f}. Balance: £{self.balance:.2f}")

account = BankAccount("Alice", 500)
account.deposit(200)     # Deposited £200.00. Balance: £700.00
account.withdraw(100)    # Withdrew £100.00. Balance: £600.00
account.withdraw(1000)   # Insufficient funds.

Inheritance

Inheritance lets a child class reuse everything from a parent class and add or override behaviour as needed. This avoids duplicating code across similar classes.

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

    def eat(self):
        return f"{self.name} is eating."

    def sleep(self):
        return f"{self.name} is sleeping."

Create a Dog subclass that inherits from Animal:

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)   # call the parent's __init__
        self.breed = breed

    def bark(self):
        return "Woof!"

buddy = Dog("Buddy", "Golden Retriever")
print(buddy.eat())    # Buddy is eating.   — inherited method
print(buddy.bark())   # Woof!              — Dog-specific method
print(buddy.breed)    # Golden Retriever

`super()`

super() gives you access to the parent class’s methods. You almost always call super().__init__() in a child’s constructor so the parent can set up its own attributes before the child adds its own.

Overriding Methods

Override a parent method in the child to change its behaviour:

class Cat(Animal):
    def __init__(self, name, indoor):
        super().__init__(name)
        self.indoor = indoor

    def speak(self):
        return "Meow!"

    def sleep(self):
        # Override — cats sleep differently (supposedly)
        return f"{self.name} curls up and sleeps for 16 hours."

whiskers = Cat("Whiskers", indoor=True)
print(whiskers.sleep())   # Whiskers curls up and sleeps for 16 hours.
print(whiskers.speak())   # Meow!

Practical Example: Product and Cart

Here is a realistic example that models an e-commerce cart. It demonstrates instance attributes, methods, inheritance, and __str__ for readable printing:

class Product:
    """Represents a single product in the store."""

    def __init__(self, name, price, quantity=1):
        if price < 0:
            raise ValueError("Price cannot be negative.")
        self.name     = name
        self.price    = price
        self.quantity = quantity

    def subtotal(self):
        """Return price × quantity."""
        return self.price * self.quantity

    def __str__(self):
        return f"{self.name} (x{self.quantity}) @ £{self.price:.2f}"


class DigitalProduct(Product):
    """A downloadable product — no physical quantity limit."""

    def __init__(self, name, price, download_url):
        super().__init__(name, price, quantity=1)
        self.download_url = download_url

    def __str__(self):
        return f"{self.name} [digital] @ £{self.price:.2f}"


class Cart:
    """A shopping cart that holds multiple products."""

    def __init__(self, owner):
        self.owner    = owner
        self.items    = []

    def add(self, product):
        self.items.append(product)
        print(f"Added: {product}")

    def remove(self, product_name):
        self.items = [p for p in self.items if p.name != product_name]
        print(f"Removed '{product_name}' from cart.")

    def total(self):
        return sum(item.subtotal() for item in self.items)

    def summary(self):
        print(f"\n--- Cart for {self.owner} ---")
        for item in self.items:
            print(f"  {item}  →  £{item.subtotal():.2f}")
        print(f"  Total: £{self.total():.2f}\n")


# --- Usage ---
laptop  = Product("Laptop",  999.99)
mouse   = Product("Mouse",    29.99, quantity=2)
ebook   = DigitalProduct("Python Cookbook", 14.99, "https://example.com/dl/1")

cart = Cart("Alice")
cart.add(laptop)
cart.add(mouse)
cart.add(ebook)
cart.summary()

cart.remove("Mouse")
cart.summary()

Output:

Added: Laptop (x1) @ £999.99
Added: Mouse (x2) @ £29.99
Added: Python Cookbook [digital] @ £14.99

--- Cart for Alice ---
  Laptop (x1) @ £999.99  →  £999.99
  Mouse (x2) @ £29.99  →  £59.98
  Python Cookbook [digital] @ £14.99  →  £14.99
  Total: £1074.96

Removed 'Mouse' from cart.

--- Cart for Alice ---
  Laptop (x1) @ £999.99  →  £999.99
  Python Cookbook [digital] @ £14.99  →  £14.99
  Total: £1014.98

When to Use OOP vs Functions

Prefer classes when…

You have data and behaviour that naturally belong together (e.g., a BankAccount has a balance and deposit/withdraw methods).
You need multiple instances of the same kind of thing, each with its own state.
You want inheritance to avoid repeating yourself across similar types.
You are building a larger application where encapsulation and clear boundaries matter.

Prefer functions when…

The logic is a simple transformation: input → output with no persistent state.
You are writing small scripts or one-off data processing pipelines.
Keeping things functional makes the code easier to test in isolation.
A class would only ever have one instance and no meaningful attributes.

Start with functions. Introduce a class when you notice you keep passing the same group of variables into the same set of functions — that group is begging to become a class.

Key Takeaways

Class = blueprint

A class defines the structure. Every instance = ClassName() call creates a separate object with its own copy of instance attributes.

self is the instance

Always include self as the first parameter in instance methods. Python passes the instance automatically when you call obj.method().

Inheritance shares code

Use inheritance to let child classes reuse parent code. Call super().__init__() in the child’s constructor to ensure the parent sets up correctly first.

Override, don't repeat

Override a parent method in a child class when the behaviour needs to differ. The parent method is still accessible via super().method_name().

Core Python

Advanced Python

Pydantic

Object-Oriented Programming: Python Classes and OOP

Defining a Class

The `init` Method and `self`

Creating Instances

Instance Attributes vs Class Attributes

Methods

Instance Methods

Inheritance

`super()`

Overriding Methods

Practical Example: Product and Cart

When to Use OOP vs Functions

Key Takeaways

Class = blueprint

self is the instance

Inheritance shares code

Override, don't repeat

​Defining a Class

​The __init__ Method and self

​Creating Instances

​Instance Attributes vs Class Attributes

​Methods

​Instance Methods

​Inheritance

​super()

​Overriding Methods

​Practical Example: Product and Cart

​When to Use OOP vs Functions

​Key Takeaways

Class = blueprint

self is the instance

Inheritance shares code

Override, don't repeat

Defining a Class

The `init` Method and `self`

Creating Instances

Instance Attributes vs Class Attributes

Methods

Instance Methods

Inheritance

`super()`

Overriding Methods

Practical Example: Product and Cart

When to Use OOP vs Functions

Key Takeaways