Object-Oriented Programming in Python: A Complete Guide

# Procedural way
def deposit_money(account_name, balance, amount):
    balance += amount
    return balance

# OOP way: the action belongs to the object
account.deposit(500)

acc1 = Account('Rishabh', 101, 25000)
# Python automatically calls Account.__init__(acc1, 'Rishabh', 101, 25000)

class Account:

    def __init__(self, name, accountnumber, balance):  # constructor
        self.name = name           # attribute: belongs to THIS object
        self.acc_no = accountnumber
        self.bal = balance

# Creating three different objects from the same class
acc1 = Account('Rishabh', 101, 25000)
acc2 = Account('Priya', 102, 67548)
acc3 = Account('Roshan', 103, 76000)

print(acc1.bal, acc1.name, acc1.acc_no)
print(acc2.bal, acc2.name, acc2.acc_no)
print(acc3.bal, acc3.name, acc3.acc_no)

class Student:

    def __init__(self, name, roll_number, marks):
        self.name = name
        self.roll_no = roll_number
        self.marks = marks

    def is_passing(self):
        return self.marks >= 50

    def get_grade(self):
        if self.marks >= 90:
            return 'A+'
        elif self.marks >= 75:
            return 'A'
        elif self.marks >= 60:
            return 'B'
        elif self.marks >= 50:
            return 'C'
        else:
            return 'F'

s1 = Student('Alice', 1, 92)
s2 = Student('Bob', 2, 47)
s3 = Student('Carol', 3, 68)

print(s1.name, '| Grade:', s1.get_grade(), '| Passing:', s1.is_passing())
print(s2.name, '| Grade:', s2.get_grade(), '| Passing:', s2.is_passing())
print(s3.name, '| Grade:', s3.get_grade(), '| Passing:', s3.is_passing())

class Account:
    def __init__(self, name, accountnumber, balance):
        self.name = name
        self.acc_no = accountnumber
        self.bal = balance

    def __str__(self):
        return f'Account #{self.acc_no} belongs to {self.name} | Balance: ${self.bal}'

class Product:

    def __init__(self, asin, title, price, seller, rating=0.0, review_count=0):
        self.asin = asin
        self.title = title
        self.price = price
        self.seller = seller
        self.rating = rating
        self.review_count = review_count

    def __str__(self):
        return f'[{self.asin}] {self.title} | ${self.price} | {self.rating}/5 ({self.review_count} reviews)'

    def apply_discount(self, percent):
        self.price = round(self.price * (1 - percent / 100), 2)

    def add_review(self, new_rating):
        total_combined_rating = self.rating * self.review_count + new_rating
        self.review_count += 1
        self.rating = round(total_combined_rating / self.review_count, 1)

laptop = Product('B09G9HDGY2', 'Apple MacBook Pro 14-inch', 1999.99, 'Apple Inc.', 4.8, 2341)
headphones = Product('B07Q9MJKBV', 'Sony WH-1000XM4 Headphones', 279.99, 'Sony', 4.7, 18923)

laptop.apply_discount(15)      # Prime Day 15% off
headphones.add_review(5)       # a new 5-star review comes in
print(laptop)
print(headphones)

class Account:
    counter = 1                  # class variable: shared by every Account
    bank_name = 'PyBank'         # class variable: same for all accounts
    ifsc_code = 'PYBN0001234'    # class variable: same branch for all

    def __init__(self, name, balance=0):
        self.name = name                # instance variable
        self.acc_no = Account.counter   # read the shared counter
        Account.counter += 1            # then bump it for the next account
        self.bal = balance              # instance variable

    def __str__(self):
        return f'[{Account.bank_name}] Account #{self.acc_no} | {self.name} | ${self.bal}'

acc1 = Account('Rishabh', 25000)
acc2 = Account('Priya', 67548)
acc3 = Account('Roshan', 76000)

print('Total accounts created so far:', Account.counter - 1)
print('Bank IFSC Code:', Account.ifsc_code)

class Ride:
    total_rides = 0          # class variable: tracks every ride ever created
    surge_multiplier = 1.0   # class variable: changed globally during peak hours

    def __init__(self, rider, driver, pickup, destination, base_fare):
        self.rider = rider
        self.driver = driver
        self.destination = destination
        self.base_fare = base_fare
        Ride.total_rides += 1
        self.ride_id = Ride.total_rides

    def get_final_fare(self):
        return round(self.base_fare * Ride.surge_multiplier, 2)

ride1 = Ride('Alice', 'Carlos', 'Marina District', 'SFO Airport', 45.00)
ride2 = Ride('Bob', 'Priya', 'Downtown', 'Oakland', 22.50)

# Friday night: surge kicks in, and ONE change affects every ride created after it
Ride.surge_multiplier = 2.3
ride3 = Ride('Carol', 'Sam', 'Tenderloin', 'Caltrain', 15.00)

print(f'Ride 3 fare with surge: ${ride3.get_final_fare()}')
print('Total rides so far:', Ride.total_rides)

class Account:
    def __init__(self, name, accountnumber, balance):
        self.name = name
        self.acc_no = accountnumber
        self.bal = balance

    def deposit(self, amount):
        if amount > 0:
            self.bal += amount
            print(f"Deposited ${amount} to {self.name}'s account. New balance: ${self.bal}")
        else:
            print('Deposit amount must be positive.')

    def withdraw(self, amount):
        if amount <= 0:
            print('Withdraw amount must be positive.')
        elif amount > self.bal:
            print('Insufficient funds!')
        else:
            self.bal -= amount
            print(f"Withdrew ${amount} from {self.name}'s account. New balance: ${self.bal}")

    def transfer(self, amount, other_account):
        if amount <= 0:
            print('Transfer amount must be positive.')
        elif amount > self.bal:
            print('Insufficient funds to transfer!')
        else:
            self.withdraw(amount)
            other_account.deposit(amount)
            print('Transfer complete.')

acc1 = Account('Rishabh', 101, 25000)
acc2 = Account('Priya', 102, 67548)

acc1.deposit(10000)
acc1.transfer(20000, acc2)

class Account:
    def __init__(self, name, balance):
        self.name = name
        self.balance = balance   # public attribute; anyone can change it

acc = Account('Alice', 5000)
acc.balance = -99999999          # nothing stops this; it should never be allowed

class Account:
    def __init__(self, name, balance=0):
        self.name = name
        self.__balance = balance       # private

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def get_balance(self):             # getter: safe read
        return self.__balance

    def set_balance(self, amount):     # setter: write WITH validation
        if isinstance(amount, (int, float)) and amount >= 0:
            self.__balance = amount
            print(f'Balance updated to ${self.__balance}')
        else:
            print('Invalid amount. Balance must be a non-negative number.')

account = Account('John Doe', 100)
print(f'Current balance: ${account.get_balance()}')

account.set_balance('abc')     # rejected: not a number
account.set_balance(-500)      # rejected: negative
account.set_balance(9999)      # accepted

print(account.__balance)                  # fails: this exact name doesn't exist

print(account._Account__balance)          # works: this is the REAL, mangled name

class CreditCard:

    def __init__(self, holder_name, card_number, cvv, credit_limit):
        self.holder_name = holder_name
        self.__card_number = str(card_number)   # private, never exposed in full
        self.__cvv = cvv                        # private
        self.__balance = 0
        self.__credit_limit = credit_limit

    def get_masked_number(self):
        return f'**** **** **** {self.__card_number[-4:]}'

    def get_available_credit(self):
        return self.__credit_limit - self.__balance

    def get_utilization(self):
        return round((self.__balance / self.__credit_limit) * 100, 1)

    def charge(self, amount, merchant):
        if amount <= 0 or amount > self.get_available_credit():
            print(f'Declined at {merchant}.')
            return False
        self.__balance += amount
        print(f'Approved: ${amount} at {merchant} | Remaining credit: ${self.get_available_credit()}')
        return True

    def pay_bill(self, amount):
        payment = min(amount, self.__balance)   # can't ever overpay
        self.__balance -= payment
        print(f'Payment of ${payment} received. Remaining balance: ${self.__balance}')

    def __str__(self):
        return f'Card: {self.get_masked_number()} | {self.holder_name} | Utilization: {self.get_utilization()}%'

card = CreditCard('John Doe', '4111111111111234', 123, 5000)

card.charge(1500, 'Amazon')
card.charge(2000, 'Apple Store')
card.charge(2000, 'Best Buy')   # should be declined

print(card)
card.pay_bill(1000)

class CurrentAccount(Account):
    def __init__(self, name, acc_no, balance, gender):
        super().__init__(name, acc_no, balance)   # run Account's setup first
        self.gender = gender                       # then add the child's own data

class Account:
    def __init__(self, name, accountnumber, balance):
        self.name = name
        self.acc_no = accountnumber
        self.bal = balance
        self.numtrans = 0     # transactions done today
        self.maxtrans = 2     # max transactions allowed per day

    def deposit(self, amount):
        if amount > 0 and self.numtrans < self.maxtrans:
            self.bal += amount
            self.numtrans += 1
            print(f'Deposited ${amount}. Balance: ${self.bal}')
        elif self.numtrans >= self.maxtrans:
            print('Transaction limit reached for today.')
        else:
            print('Deposit amount must be positive.')


class SavingsAccount(Account):
    pass   # 'pass' means no extra code: it uses everything from Account, unchanged

sav1 = SavingsAccount('Vinay', 301, 90800)

sav1.deposit(5000)   # transaction 1
sav1.deposit(5000)   # transaction 2
sav1.deposit(5000)   # refused: the daily limit is 2

class Vehicle:
    def __init__(self, make, model):
        self.make = make
        self.model = model
    def start(self):
        return f'{self.make} {self.model} is starting...'

class ElectricVehicle:
    def __init__(self, battery_kwh):
        self.battery = battery_kwh
        self.charge_level = 100
    def get_range(self):
        miles = int(self.battery * (self.charge_level / 100) * 2.5)
        return f'{miles} miles'

class GPSNavigator:
    def get_location(self):
        return '37.7749 N, 122.4194 W'
    def navigate(self, destination):
        return f'Routing to {destination} from {self.get_location()}'

class TeslaModel3(Vehicle, ElectricVehicle, GPSNavigator):
    def __init__(self, model, autopilot=True):
        Vehicle.__init__(self, 'Tesla', model)
        ElectricVehicle.__init__(self, battery_kwh=75)
        self.autopilot = autopilot

    def self_drive(self, destination):
        if self.autopilot:
            return f'Autopilot engaged. {self.navigate(destination)} | Range: {self.get_range()}'
        return 'Autopilot not available.'

tesla = TeslaModel3('Model 3')
print(tesla.start())                  # from Vehicle
print(tesla.get_range())              # from ElectricVehicle
print(tesla.self_drive('Palo Alto'))  # TeslaModel3's own method, using methods from ALL parents

class Animal:
    def breathe(self):
        return 'Breathing oxygen.'

class Mammal(Animal):              # Mammal IS an Animal
    def feed_young_with_milk(self):
        return 'Feeding young with milk.'

class Dog(Mammal):                 # Dog IS a Mammal (which is also an Animal)
    def bark(self):
        return 'Woof!'

dog = Dog()
print(dog.breathe())               # inherited from Animal, two levels up
print(dog.feed_young_with_milk())  # inherited from Mammal, one level up
print(dog.bark())                  # Dog's own method

print(isinstance(dog, Dog), isinstance(dog, Mammal), isinstance(dog, Animal))

class BankAccount:
    def __init__(self, holder, acc_no, balance):
        self.holder = holder
        self.acc_no = acc_no
        self.balance = balance
    def __str__(self):
        return f'{type(self).__name__} | {self.holder} | ${self.balance}'

class SavingsAccount(BankAccount):
    interest_rate = 0.04
    def apply_interest(self):
        earned = self.balance * self.interest_rate
        self.balance += earned
        print(f'Interest earned: ${round(earned, 2)}. New balance: ${round(self.balance, 2)}')

class CurrentAccount(BankAccount):
    overdraft_limit = 10000
    def withdraw(self, amount):
        if amount <= self.balance + self.overdraft_limit:
            self.balance -= amount
            print(f'Withdrew ${amount}. Balance: ${self.balance}')
        else:
            print('Amount exceeds overdraft limit.')

class FixedDepositAccount(BankAccount):
    def __init__(self, holder, acc_no, balance, lock_months):
        super().__init__(holder, acc_no, balance)
        self.lock_months = lock_months
    def is_locked(self, months_passed):
        locked = months_passed < self.lock_months
        print(f'FD after {months_passed} months:', 'LOCKED' if locked else 'FD MATURED, can withdraw now')
        return locked

savings = SavingsAccount('Alice', 101, 50000)
current = CurrentAccount('Bob', 102, 2000)
fd = FixedDepositAccount('Carol', 103, 100000, lock_months=12)

savings.apply_interest()
current.withdraw(10000)   # within the overdraft limit
current.withdraw(5000)    # exceeds it
fd.is_locked(6)
fd.is_locked(13)

class A:
    def hello(self): return 'Hello from A'
class B(A):
    def hello(self): return 'Hello from B'
class C(A):
    def hello(self): return 'Hello from C'
class D(B, C):   # B is listed before C
    pass

d = D()
print(d.hello())     # 'Hello from B'

for cls in D.__mro__:
    print(f'  -> {cls.__name__}')

class Cat:
    def speak(self): return 'Meow!'
class Dog:
    def speak(self): return 'Woof!'
class Duck:
    def speak(self): return 'Quack!'

animals = [Cat(), Dog(), Duck()]
for animal in animals:
    print(f'{type(animal).__name__}: {animal.speak()}')

class Account:
    def __init__(self, name, accountnumber, balance):
        self.name = name
        self.acc_no = accountnumber
        self.bal = balance

    def withdraw(self, amount):
        # The default version every account type inherits, unless it overrides this
        if amount > 0 and amount <= self.bal:
            self.bal -= amount
            print(f'Withdrew ${amount}. Balance: ${self.bal}')
        else:
            print('Insufficient funds.')


class SavingsAccount(Account):
    # Override: savings accounts charge a $1 fee per withdrawal
    def withdraw(self, amount):
        fee = 1
        total = amount + fee
        if amount > 0 and total <= self.bal:
            self.bal -= total
            print(f'[SavingsAccount] Withdrew ${amount} + ${fee} fee. Balance: ${self.bal}')
        else:
            print('Insufficient funds after applying the fee.')

class CurrentAccount(Account):
    # Override: no fee for current accounts
    def withdraw(self, amount):
        if amount > 0 and amount <= self.bal:
            self.bal -= amount
            print(f'[CurrentAccount] Withdrew ${amount}. Balance: ${self.bal}')
        else:
            print('Insufficient funds.')

savings = SavingsAccount('Alice', 'SA123', 100)
current = CurrentAccount('Bob', 'CA456', 200)

savings.withdraw(20)   # same method NAME as current.withdraw...
current.withdraw(20)   # ...but different behavior, because of the object's TYPE

class StripePayment:
    def process(self, amount): return f'Stripe: processed ${amount} via card'
class PayPalPayment:
    def process(self, amount): return f'PayPal: processed ${amount} via PayPal account'
class ApplePayPayment:
    def process(self, amount): return f'Apple Pay: processed ${amount} via device token'
class CryptoPayment:
    def process(self, amount):
        btc = round(amount / 60000, 6)   # a rough, illustrative conversion rate
        return f'Crypto: processed {btc} BTC (≈${amount})'

def checkout(payment_method, amount):
    # Works with ANY object that has a .process() method, no shared parent needed
    print(payment_method.process(amount))

for method in [StripePayment(), PayPalPayment(), ApplePayPayment(), CryptoPayment()]:
    checkout(method, 99.99)

class Calculator:
    def add(self, a, b):
        return a + b
    def add(self, a, b, c):    # this REPLACES the add(a, b) above
        return a + b + c

calc = Calculator()
calc.add(3, 4)

# Fix 1: default parameter values
class Calculator:
    def add(self, a, b=0, c=0):
        return a + b + c

calc = Calculator()
print(calc.add(5))          # 5
print(calc.add(5, 10))      # 15
print(calc.add(5, 10, 15))  # 30

# Fix 2: *args accepts any number of arguments (the most flexible option)
class Calculator:
    def add(self, *args):
        return sum(args)

calc = Calculator()
print(calc.add(5, 10, 15, 20))   # 50

print('Python' + 'Programming')    # strings: concatenation
print([1, 2, 3] + [4, 5, 6])      # lists: joins them together
print(10 + 12)                      # numbers: addition

class Account:
    # A template base class: defines WHAT every account must do,
    # leaves HOW to each subclass.
    def __init__(self, name, accountnumber, balance):
        self.name = name
        self.acc_no = accountnumber
        self.bal = balance

    def deposit(self, amount):
        raise NotImplementedError('Subclasses must implement their own deposit() method')

    def withdraw(self, amount):
        raise NotImplementedError('Subclasses must implement their own withdraw() method')


class SavingsAccount(Account):
    def deposit(self, amount):
        if amount > 0:
            self.bal += amount
            print(f'[Savings] Deposited ${amount}. Balance: ${self.bal}')

    def withdraw(self, amount):
        fee = 1
        total = amount + fee
        if amount > 0 and total <= self.bal:
            self.bal -= total
            print(f'[Savings] Withdrew ${amount} + ${fee} fee. Balance: ${self.bal}')


# A subclass that forgets to implement the required methods
class BrokenAccount(Account):
    pass

broken = BrokenAccount('Test', 999, 0)
broken.deposit(100)   # raises NotImplementedError immediately

class PaymentGateway:
    # Base class: the contract every gateway must follow
    def charge(self, amount, token):
        raise NotImplementedError('Every gateway must implement charge()')
    def refund(self, transaction_id, amount):
        raise NotImplementedError('Every gateway must implement refund()')

    def charge_with_tax(self, amount, token, tax_rate=0.1):
        # Shared logic, lives once in the base class, calls self.charge()
        # which each subclass overrides in its own way
        total = round(amount * (1 + tax_rate), 2)
        return self.charge(total, token)


class StripeGateway(PaymentGateway):
    _counter = 1000   # a simple, predictable way to generate transaction IDs

    def charge(self, amount, token):
        StripeGateway._counter += 1
        txn_id = f'ch_stripe_{StripeGateway._counter}'
        return {'status': 'success', 'id': txn_id, 'amount': amount, 'gateway': 'Stripe'}

    def refund(self, transaction_id, amount):
        print(f'[Stripe] Refunding ${amount} for transaction {transaction_id}')
        return True


class PayPalGateway(PaymentGateway):
    _counter = 5000   # PayPal's own counter, kept separate from Stripe's

    def charge(self, amount, token):
        PayPalGateway._counter += 1
        txn_id = f'PAY-{PayPalGateway._counter}'
        return {'status': 'success', 'id': txn_id, 'amount': amount, 'gateway': 'PayPal'}

    def refund(self, transaction_id, amount):
        print(f'[PayPal] Refunding ${amount} for transaction {transaction_id}')
        return True


class OrderProcessor:
    def __init__(self, gateway):
        self.gateway = gateway   # accepts ANY gateway that follows the contract

    def process_order(self, order_amount, card_token, customer_name):
        result = self.gateway.charge_with_tax(order_amount, card_token)
        if result['status'] == 'success':
            print(f"Order complete! [{result['gateway']}] Transaction ID: {result['id']}")
        return result

stripe_processor = OrderProcessor(StripeGateway())
stripe_processor.process_order(89.99, 'tok_visa_4242', 'Alice')

# A completely different gateway, running through the exact same OrderProcessor,
# with zero changes to OrderProcessor itself
paypal_processor = OrderProcessor(PayPalGateway())
paypal_processor.process_order(89.99, 'tok_pp_sandbox', 'Bob')