Python OOP: Beginner Friendly Guide

# Data is just loose variables
account_name = "Arjun"
account_balance = 1000
 
def deposit(balance, amount):
    return balance + amount
 
def withdraw(balance, amount):
    if amount > balance:
        raise ValueError("Insufficient funds")
    return balance - amount
 
# With 100 accounts this becomes chaos!
account_balance = deposit(account_balance, 500)

# Data + behavior in one clean unit
class BankAccount:
    def __init__(self, name, balance):
        self.name    = name
        self.balance = balance
 
    def deposit(self, amount):
        self.balance += amount
 
    def withdraw(self, amount):
        self.balance -= amount
 
# 100 accounts? No problem at all.
acc = BankAccount("Arjun", 1000)
acc.deposit(500)

# CLASS = Blueprint
class Dog:
    # __init__ is the constructor — runs when an object is created
    def __init__(self, name, breed, age):
        self.name  = name    # attribute
        self.breed = breed   # attribute
        self.age   = age     # attribute
 
    def bark(self):            # method
        print(f"{self.name} says: Woof!")
 
    def describe(self):         # method
        print(f"{self.name} is a {self.age}-year-old {self.breed}.")
 
# OBJECTS = Instances built from the blueprint
dog1 = Dog("Bruno", "Labrador", 3)
dog2 = Dog("Bella", "Poodle", 5)
 
dog1.bark()       # Bruno says: Woof!
dog2.describe()   # Bella is a 5-year-old Poodle.
 
# Each object has its OWN data
print(dog1.name)  # Bruno
print(dog2.name)  # Bella

class BankAccount:
    def __init__(self, owner, initial_balance=0):
        self.owner       = owner
        self.__balance   = initial_balance  # __ makes it PRIVATE
        self.__transactions = []
 
    # GETTER — controlled read access
    def get_balance(self):
        return self.__balance
 
    # SETTER with validation
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive!")
        self.__balance += amount
        self.__transactions.append(f"+{amount}")
 
    def withdraw(self, amount):
        if amount > self.__balance:
            raise ValueError("Insufficient funds!")
        self.__balance -= amount
        self.__transactions.append(f"-{amount}")
 
    def get_statement(self):
        return self.__transactions
 
# Usage
acc = BankAccount("Arjun", 5000)
acc.deposit(2000)
acc.withdraw(500)
print(acc.get_balance())     # 6500
print(acc.get_statement())   # ['+2000', '-500']
 
# This would FAIL — good! Data is protected.
# print(acc.__balance)  → AttributeError

# PARENT CLASS
class Vehicle:
    def __init__(self, brand, model, fuel_type):
        self.brand     = brand
        self.model     = model
        self.fuel_type = fuel_type
        self.speed     = 0
 
    def accelerate(self, amount):
        self.speed += amount
        print(f"{self.brand} accelerates to {self.speed} km/h")
 
    def brake(self):
        self.speed = 0
        print(f"{self.brand} stops.")
 
    def info(self):
        print(f"{self.brand} {self.model} ({self.fuel_type})")
 
# CHILD CLASS — inherits Vehicle, adds more
class Car(Vehicle):
    def __init__(self, brand, model, fuel_type, doors):
        super().__init__(brand, model, fuel_type)  # call parent
        self.doors = doors                          # new attribute
 
    def open_trunk(self):
        print(f"Trunk of {self.brand} opened!")
 
# ANOTHER CHILD CLASS
class ElectricCar(Car):           # Multi-level inheritance!
    def __init__(self, brand, model, battery_kwh):
        super().__init__(brand, model, "Electric", 4)
        self.battery_kwh = battery_kwh
 
    def charge(self):
        print(f"Charging {self.brand} ({self.battery_kwh} kWh)...")
 
# Usage
my_car = Car("Honda", "City", "Petrol", 4)
my_car.accelerate(60)     # Inherited from Vehicle!
my_car.open_trunk()       # Car-specific method
 
tesla = ElectricCar("Tesla", "Model 3", 75)
tesla.accelerate(100)     # Works! Inherited from Vehicle
tesla.charge()            # ElectricCar-specific
tesla.open_trunk()        # Inherited from Car

class PaymentMethod:
    def pay(self, amount):
        raise NotImplementedError("Subclass must implement pay()")
 
class CreditCard(PaymentMethod):
    def __init__(self, card_number):
        self.card_number = card_number
 
    def pay(self, amount):  # Override parent's pay()
        print(f"Charged ₹{amount} to card ending in {self.card_number[-4:]}")
 
class UPI(PaymentMethod):
    def __init__(self, upi_id):
        self.upi_id = upi_id
 
    def pay(self, amount):
        print(f"₹{amount} sent via UPI to {self.upi_id}")
 
class Wallet(PaymentMethod):
    def __init__(self, wallet_name, balance):
        self.wallet_name = wallet_name
        self.balance     = balance
 
    def pay(self, amount):
        self.balance -= amount
        print(f"₹{amount} paid from {self.wallet_name}. Balance: ₹{self.balance}")
 
# POLYMORPHISM IN ACTION
# All different objects, but we treat them the SAME way
payment_methods = [
    CreditCard("4111111111112024"),
    UPI("arjun@upi"),
    Wallet("Paytm", 2000)
]
 
for method in payment_methods:
    method.pay(500)   # Same call, different behavior!

from abc import ABC, abstractmethod
 
# ABSTRACT CLASS — defines the contract
class Notification(ABC):
    @abstractmethod
    def send(self, recipient, message):
        """Every notification type MUST implement this."""
        pass
 
    @abstractmethod
    def get_channel_name(self):
        pass
 
    # Non-abstract shared method
    def notify(self, recipient, message):
        print(f"[{self.get_channel_name()}] → {recipient}")
        self.send(recipient, message)
 
# CONCRETE CLASS — fills in the contract
class EmailNotification(Notification):
    def send(self, recipient, message):
        print(f"Email sent to {recipient}: {message}")
 
    def get_channel_name(self):
        return "EMAIL"
 
class SMSNotification(Notification):
    def send(self, recipient, message):
        print(f"SMS sent to {recipient}: {message}")
 
    def get_channel_name(self):
        return "SMS"
 
# Usage
channels = [EmailNotification(), SMSNotification()]
 
for channel in channels:
    channel.notify("user@example.com", "Your order is confirmed!")

from abc import ABC, abstractmethod
 
# ── ABSTRACTION: Define what every product must have
class Product(ABC):
    def __init__(self, name, price):
        self.name       = name
        self.__price    = price    # ENCAPSULATION
 
    def get_price(self):
        return self.__price
 
    @abstractmethod
    def get_description(self):
        pass
 
    @abstractmethod
    def calculate_tax(self):
        pass
 
# ── INHERITANCE: Specific product types inherit Product
class Electronics(Product):
    def __init__(self, name, price, warranty_years):
        super().__init__(name, price)
        self.warranty_years = warranty_years
 
    def get_description(self):        # POLYMORPHISM
        return f"{self.name} ({self.warranty_years}yr warranty)"
 
    def calculate_tax(self):          # POLYMORPHISM
        return self.get_price() * 0.18
 
class Clothing(Product):
    def __init__(self, name, price, size):
        super().__init__(name, price)
        self.size = size
 
    def get_description(self):
        return f"{self.name} (Size: {self.size})"
 
    def calculate_tax(self):
        return self.get_price() * 0.05
 
# ── ENCAPSULATION: Order hides its internal cart logic
class Order:
    def __init__(self, customer_name):
        self.customer      = customer_name
        self.__cart        = []
        self.__is_confirmed = False
 
    def add_item(self, product):
        if self.__is_confirmed:
            print("Cannot modify a confirmed order!")
            return
        self.__cart.append(product)
 
    def get_total(self):
        # POLYMORPHISM: calculate_tax works differently per product!
        subtotal = sum(p.get_price() + p.calculate_tax() for p in self.__cart)
        return round(subtotal, 2)
 
    def confirm(self):
        self.__is_confirmed = True
        print(f"Order confirmed for {self.customer}! Total: ₹{self.get_total()}")
        for p in self.__cart:
            print(f"  • {p.get_description()} — ₹{p.get_price()}")
 
# ── IN ACTION
phone  = Electronics("iPhone 15", 79999, 1)
tshirt = Clothing("Polo T-Shirt", 999, "L")
 
order = Order("Arjun")
order.add_item(phone)
order.add_item(tshirt)
order.confirm()