Python Object-Oriented Programming

      Ankush More

      A Complete Journey Through Python OOP with Interactive Examples and Real-World Applications

      📚 Table of Contents

      Part I: Foundations

      1. Introduction to Python Programming
      2. Understanding Python Objects
      3. Classes and Objects Fundamentals

      Part II: Core Concepts

      1. The Four Pillars of OOP
      2. Object Creation and Lifecycle
      3. Methods vs Functions

      Part III: Advanced Topics

      1. OOP vs Functional Programming
      2. Advanced OOP Concepts
      3. Memory Management and Garbage Collection

      Part IV: Practical Applications

      1. Real-World Applications
      2. Best Practices and Design Patterns
      3. Interactive Exercises and Projects

      🎯 Learning Objectives

      By the end of this book, you will:

      • ✅ Master Python’s object-oriented programming paradigm
      • ✅ Understand when to use OOP vs functional programming
      • ✅ Build robust, maintainable applications
      • ✅ Apply industry-standard design patterns
      • ✅ Debug and optimize object-oriented code
      • ✅ Create real-world projects using OOP principles

      1. Introduction to Python Programming

      🔍 What Makes a Python Program?

      A Python program is composed of several core components that work together to create functional, executable code. Understanding these building blocks is essential before diving into object-oriented programming.

      💡 Key Insight: Python follows the principle “Everything is an object” – even simple numbers, strings, and functions are objects with methods and attributes!

      graph TD
    A["🐍 Python Program"] --> B["📊 Data & Variables"]
    A --> C["🔧 Functions & Methods"]
    A --> D["🏗️ Classes & Objects"]
    A --> E["📦 Modules & Packages"]

    B --> B1["int: 42"]
    B --> B2["str: 'Hello'"]
    B --> B3["list: [1,2,3]"]
    B --> B4["dict: {'key': 'value'}"]

    C --> C1["def my_function()"]
    C --> C2["lambda expressions"]
    C --> C3["Built-in functions"]

    D --> D1["Class Definition"]
    D --> D2["Object Instances"]
    D --> D3["Inheritance"]

    E --> E1["import statement"]
    E --> E2["Standard Library"]
    E --> E3["Third-party packages"]

    style A fill:#e1f5fe
    style B fill:#f3e5f5
    style C fill:#e8f5e8
    style D fill:#fff3e0
    style E fill:#fce4ec

      🧱 Core Building Blocks

      Expressions and Statements

      # 🔍 EXPRESSIONS - Code that evaluates to a value
age = 25                    # 25 is an expression
name = "Alice"             # "Alice" is an expression  
result = 2 + 3 * 4         # 2 + 3 * 4 is an expression (evaluates to 14)
is_adult = age >= 18       # age >= 18 is an expression (evaluates to True)

# 🔧 STATEMENTS - Instructions that Python executes
print("Hello, World!")     # print statement
if age >= 18:             # if statement
    print("You can vote!")
for i in range(3):        # for statement
    print(i)
      Python

      Variables and Data Types

      Python’s type system is both dynamic and strong:

      # 🏷️ Dynamic typing - type determined at runtime
x = 42          # x is an integer
print(type(x))  # <class 'int'>

x = "Hello"     # Now x is a string!
print(type(x))  # <class 'str'>

# 📊 Common data types
numbers = {
    'integer': 42,
    'float': 3.14159,
    'complex': 3 + 4j
}

text_data = {
    'string': "Hello, Python!",
    'multiline': """This is a
    multiline string""",
    'formatted': f"Age: {age}"
}

collections = {
    'list': [1, 2, 3, 4],           # Mutable, ordered
    'tuple': (1, 2, 3, 4),          # Immutable, ordered
    'dict': {'name': 'Alice', 'age': 25},  # Key-value pairs
    'set': {1, 2, 3, 4}             # Unique elements
}
      Python

      Control Flow

      # 🎯 Conditional statements
def categorize_age(age):
    if age < 13:
        return "child"
    elif age < 20:
        return "teenager"
    elif age < 60:
        return "adult"
    else:
        return "senior"

# 🔄 Loops
# For loop with range
for i in range(5):
    print(f"Count: {i}")

# For loop with collections
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(f"I love {fruit}!")

# While loop
countdown = 5
while countdown > 0:
    print(f"T-minus {countdown}")
    countdown -= 1
print("Blast off! 🚀")
      Python

      🎭 Python’s Philosophy: “Everything is an Object”

      One of Python’s most powerful concepts is that everything is an object:

      # Even simple numbers are objects!
number = 42
print(number.__class__)        # <class 'int'>
print(number.bit_length())     # 6 (method of integer objects!)

# Strings are objects too
text = "Hello, Python!"
print(text.upper())           # HELLO, PYTHON!
print(text.count('l'))        # 2

# Functions are objects
def greet(name):
    return f"Hello, {name}!"

print(greet.__name__)         # greet
print(callable(greet))        # True

# Even modules are objects!
import math
print(math.__name__)          # math
print(dir(math)[:5])          # ['__doc__', '__loader__', '__name__', '__package__', '__spec__']
      Python

      🎯 Try It Yourself: Basic Object Exploration

      # 🔬 Explore any object's capabilities
def explore_object(obj):
    """Discover what any Python object can do"""
    print(f"Object: {obj}")
    print(f"Type: {type(obj).__name__}")
    print(f"ID (memory address): {id(obj)}")
    print(f"String representation: {str(obj)}")
    print(f"Available methods: {[m for m in dir(obj) if not m.startswith('_')]}")
    print("-" * 50)

# Try with different types
explore_object(42)
explore_object("Hello")
explore_object([1, 2, 3])
explore_object({'a': 1})
      Python

      2. Understanding Python Objects

      🤔 Is Python Object a Data Type?

      Short Answer: object is not a data type itself, but rather the fundamental base class from which all Python data types inherit.

      The Big Picture: In Python’s object hierarchy, object sits at the very top:

      graph TD
    A["🏛️ object(Base of everything)"] --> B["🔢 int"]
    A --> C["📝 str"]
    A --> D["📋 list"]
    A --> E["📚 dict"]
    A --> F["🎭 function"]
    A --> G["🏗️ class"]
    A --> H["📦 module"]

    B --> B1["42"]
    C --> C1["'Hello'"]
    D --> D1["[1, 2, 3]"]
    E --> E1["{'key': 'value'}"]
    F --> F1["def my_func()"]
    G --> G1["class MyClass"]
    H --> H1["import math"]

    style A fill:#ffeb3b,stroke:#f57f17,stroke-width:3px
    style B fill:#e3f2fd
    style C fill:#f3e5f5
    style D fill:#e8f5e8
    style E fill:#fff3e0
    style F fill:#fce4ec
    style G fill:#f1f8e9
    style H fill:#e0f2f1

      🔍 What Exactly is an Object?

      Think of objects as smart containers that bundle together:

      graph LR
    A["🎯 Python Object"] --> B["📊 Data(Attributes)"]
    A --> C["⚙️ Behavior(Methods)"]
    A --> D["🆔 Identity(Unique ID)"]
    A --> E["🏷️ Type(Class)"]

    B --> B1["self.name = 'Alice'"]
    B --> B2["self.age = 25"]

    C --> C1["def greet(self)"]
    C --> C2["def celebrate_birthday(self)"]

    D --> D1["id(obj) = 140234567890"]

    E --> E1["type(obj) = Person"]

      🌟 The Three Pillars of Every Python Object

      Every Python object has exactly three fundamental characteristics:

      1. Identity – The Object’s Unique Fingerprint

      # 🆔 Identity: Unique, never-changing identifier
person1 = "Alice"
person2 = "Alice"
person3 = person1

print(f"person1 id: {id(person1)}")  # e.g., 140234567890
print(f"person2 id: {id(person2)}")  # Same as person1 (string interning)
print(f"person3 id: {id(person3)}")  # Same as person1 (same reference)

print(person1 is person2)  # True (same object due to interning)
print(person1 is person3)  # True (same reference)

# Different objects, different identities
list1 = [1, 2, 3]
list2 = [1, 2, 3]  # Same content, different objects!
print(list1 is list2)     # False
print(list1 == list2)     # True (same content)
      Python

      2. Type – The Object’s Blueprint

      # 🏷️ Type: Determines what operations are supported
number = 42
text = "Hello"
items = [1, 2, 3]

print(f"Type of {number}: {type(number).__name__}")  # int
print(f"Type of {text}: {type(text).__name__}")      # str
print(f"Type of {items}: {type(items).__name__}")    # list

# Type determines available methods
print(f"Number methods: {[m for m in dir(number) if not m.startswith('_')]}")
print(f"String methods: {[m for m in dir(text) if not m.startswith('_')][:5]}")
print(f"List methods: {[m for m in dir(items) if not m.startswith('_')][:5]}")
      Python

      3. Value – The Object’s Data

      # 📊 Value: The actual data stored (mutable vs immutable)

# Immutable objects - value can't change
immutable_text = "Hello"
original_id = id(immutable_text)
immutable_text += " World"  # Creates NEW object
new_id = id(immutable_text)
print(f"Original ID: {original_id}, New ID: {new_id}")  # Different!

# Mutable objects - value can change in-place
mutable_list = [1, 2, 3]
original_id = id(mutable_list)
mutable_list.append(4)  # Modifies SAME object
new_id = id(mutable_list)
print(f"Original ID: {original_id}, New ID: {new_id}")  # Same!
      Python

      🎭 Real-World Analogies to Understand Objects

      🚗 The Car Analogy

      """
Think of objects like cars in a parking lot:

🚗 Class = Car blueprint (design specifications)
🚙 Object = Specific car (your blue Honda, neighbor's red Ford)
🆔 Identity = License plate (unique identifier)
🏷️ Type = Car model (Honda Civic, Ford F-150)
📊 Value = Current state (fuel level, mileage, color)
⚙️ Methods = Car actions (start(), accelerate(), brake())
"""

class Car:
    def __init__(self, make, model, color):
        # 📊 Attributes (data/state)
        self.make = make
        self.model = model
        self.color = color
        self.fuel_level = 100
        self.is_running = False

    # ⚙️ Methods (behavior/actions)
    def start(self):
        if not self.is_running:
            self.is_running = True
            return f"🚗 {self.color} {self.make} {self.model} started!"
        return "🔧 Car is already running"

    def drive(self, distance):
        if self.is_running and self.fuel_level > 0:
            fuel_used = distance * 0.1  # 0.1 fuel per unit distance
            self.fuel_level = max(0, self.fuel_level - fuel_used)
            return f"🛣️ Drove {distance} units. Fuel remaining: {self.fuel_level:.1f}%"
        return "❌ Can't drive: car not running or no fuel"

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

# Create car objects (instances)
my_car = Car("Honda", "Civic", "blue")
friend_car = Car("Ford", "Mustang", "red")

# Each car has unique identity but same type
print(f"My car ID: {id(my_car)}")
print(f"Friend's car ID: {id(friend_car)}")
print(f"Both are Cars: {type(my_car) == type(friend_car)}")

# Cars can perform actions
print(my_car.start())
print(my_car.drive(50))
      Python

      🏠 The House Analogy

      """
Objects are like houses on a street:

🏠 Class = House blueprint (architectural plan)
🏡 Object = Specific house (123 Main St, 456 Oak Ave)
🆔 Identity = Street address (unique location)
🏷️ Type = House style (Victorian, Modern, Ranch)
📊 Value = Current condition (rooms, furniture, occupants)
⚙️ Methods = House functions (lock_doors(), turn_on_lights())
"""

class House:
    def __init__(self, address, style, rooms):
        self.address = address      # Unique identifier
        self.style = style         # House type
        self.rooms = rooms         # Current state
        self.lights_on = False
        self.doors_locked = False
        self.occupants = []

    def add_occupant(self, name):
        self.occupants.append(name)
        return f"🚪 {name} moved into {self.address}"

    def toggle_lights(self):
        self.lights_on = not self.lights_on
        status = "ON" if self.lights_on else "OFF"
        return f"💡 Lights are now {status} at {self.address}"

    def __str__(self):
        return f"{self.style} house at {self.address}"

# Create house objects
house1 = House("123 Main St", "Victorian", 4)
house2 = House("456 Oak Ave", "Modern", 3)

print(house1.add_occupant("Alice"))
print(house1.toggle_lights())
print(f"House 1: {house1}")
print(f"House 2: {house2}")
      Python

      🧠 Memory Exercise: Object Exploration

      Try this interactive exercise to understand objects better:

      def object_detective(obj, name="Object"):
    """
    🔍 Become an object detective! 
    Investigate any Python object and discover its secrets.
    """
    print(f"\n🔍 INVESTIGATING: {name}")
    print("=" * 50)

    # Basic properties
    print(f"📊 Value: {obj}")
    print(f"🏷️ Type: {type(obj).__name__}")
    print(f"🆔 ID: {id(obj)}")
    print(f"📏 Size in memory: {obj.__sizeof__()} bytes")

    # Capabilities
    public_methods = [m for m in dir(obj) if not m.startswith('_')]
    print(f"⚙️ Public methods: {len(public_methods)}")
    if public_methods:
        print(f"   Top 5: {public_methods[:5]}")

    # Special properties
    print(f"🔒 Is callable: {callable(obj)}")
    print(f"📝 Has documentation: {hasattr(obj, '__doc__') and obj.__doc__ is not None}")

    # Try some operations
    print(f"\n🧪 EXPERIMENTS:")
    print(f"   Can be compared: {hasattr(obj, '__eq__')}")
    print(f"   Can be hashed: {hasattr(obj, '__hash__') and obj.__hash__ is not None}")
    print(f"   Can be iterated: {hasattr(obj, '__iter__')}")
    print(f"   Has length: {hasattr(obj, '__len__')}")

# 🎯 Try investigating different objects:
object_detective(42, "Integer")
object_detective("Hello", "String")
object_detective([1, 2, 3], "List")
object_detective(lambda x: x*2, "Lambda Function")
      Python

      3. Classes and Objects Fundamentals

      🏗️ When are Python Objects Created?

      Objects come to life through a fascinating two-step dance that happens every time you create an instance:

      sequenceDiagram
    participant You as 👤 You
    participant Python as 🐍 Python
    participant Class as 🏗️ Class
    participant New as 🆕 __new__()
    participant Init as ⚙️ __init__()
    participant Object as 📦 Object

    You->>Python: car = Car("Honda", "Civic")
    Python->>Class: 1. Find Car class
    Class->>New: 2. Call __new__(Car)
    New->>Object: 3. Allocate memory
    Object->>Init: 4. Call __init__(self, "Honda", "Civic")
    Init->>Object: 5. Initialize attributes
    Object->>You: 6. Return ready-to-use object

    Note over New: Creates empty object structure
    Note over Init: Populates object with data

      🎬 The Object Creation Process – Behind the Scenes

      class Car:
    """🚗 A simple car class to demonstrate object creation"""

    def __new__(cls, make, model):
        """
        🆕 Step 1: __new__ is called FIRST
        - Allocates memory for the new object
        - Returns an empty instance
        """
        print(f"🔨 __new__ called: Creating empty Car object")
        instance = super().__new__(cls)  # Create empty object
        print(f"   📦 Empty object created at {id(instance)}")
        return instance

    def __init__(self, make, model):
        """
        ⚙️ Step 2: __init__ is called SECOND  
        - Receives the object created by __new__
        - Initializes the object with data
        """
        print(f"🎨 __init__ called: Initializing Car object")
        self.make = make
        self.model = model
        self.mileage = 0
        print(f"   ✅ Car initialized: {make} {model}")

    def __str__(self):
        return f"🚗 {self.make} {self.model} ({self.mileage} miles)"

# Watch the object creation process
print("🎬 Creating a new Car object:")
my_car = Car("Honda", "Civic")
print(f"🎯 Final result: {my_car}")
print(f"🆔 Object ID: {id(my_car)}")
      Python

      🔄 Object Creation Examples – From Simple to Complex

      📝 Creating a User-Defined Class

      class Student:
    """👨‍🎓 A student class demonstrating object creation and methods"""

    # 🏫 Class variable (shared by all instances)
    school_name = "Python High School"
    student_count = 0

    def __init__(self, name, age, grade):
        """🎨 Initialize a new student"""
        # 📊 Instance variables (unique to each object)
        self.name = name
        self.age = age  
        self.grade = grade
        self.courses = []
        self.gpa = 0.0

        # 📈 Update class variable
        Student.student_count += 1
        print(f"🎓 New student created: {name} (Total students: {Student.student_count})")

    def enroll_in_course(self, course_name):
        """📚 Add a course to student's schedule"""
        if course_name not in self.courses:
            self.courses.append(course_name)
            print(f"✅ {self.name} enrolled in {course_name}")
        else:
            print(f"⚠️ {self.name} already enrolled in {course_name}")

    def calculate_gpa(self, grades):
        """📊 Calculate student's GPA"""
        if grades:
            self.gpa = sum(grades) / len(grades)
            print(f"📈 {self.name}'s GPA: {self.gpa:.2f}")
        return self.gpa

    def display_info(self):
        """📋 Display student information"""
        print(f"\n👨‍🎓 STUDENT PROFILE")
        print(f"   Name: {self.name}")
        print(f"   Age: {self.age}")
        print(f"   Grade: {self.grade}")
        print(f"   School: {Student.school_name}")
        print(f"   Courses: {', '.join(self.courses) if self.courses else 'None'}")
        print(f"   GPA: {self.gpa:.2f}")

    def __str__(self):
        return f"Student({self.name}, Grade {self.grade})"

    def __repr__(self):
        return f"Student(name='{self.name}', age={self.age}, grade={self.grade})"

# 🎯 Create student objects
print("🏫 Welcome to Python High School!")
print("=" * 40)

student1 = Student("Alice", 16, 10)
student2 = Student("Bob", 17, 11) 
student3 = Student("Charlie", 15, 9)

# 📚 Enroll students in courses
student1.enroll_in_course("Python Programming")
student1.enroll_in_course("Data Structures")
student2.enroll_in_course("Web Development")
student3.enroll_in_course("Python Programming")

# 📊 Calculate GPAs
student1.calculate_gpa([95, 87, 92])
student2.calculate_gpa([78, 84, 91])
student3.calculate_gpa([88, 90, 85])

# 📋 Display information
student1.display_info()
student2.display_info()

print(f"\n🏫 Total students at {Student.school_name}: {Student.student_count}")
      Python

      🔧 Creating Objects Without __init__()

      class EmptyClass:
    """📦 A class without __init__ method"""
    pass

# 🎯 Create empty object and add attributes dynamically
empty_obj = EmptyClass()
print(f"📦 Created empty object: {empty_obj}")
print(f"🔍 Object attributes before: {vars(empty_obj)}")

# 🎨 Dynamically add attributes
empty_obj.name = "Dynamic Object"
empty_obj.created_at = "2025-09-05"
empty_obj.version = 1.0

print(f"🔍 Object attributes after: {vars(empty_obj)}")
print(f"📝 Name: {empty_obj.name}")

# 🎭 Even add methods dynamically!
def greet(self):
    return f"Hello! I'm {self.name}, created on {self.created_at}"

empty_obj.greet = greet.__get__(empty_obj, EmptyClass)
print(f"👋 Greeting: {empty_obj.greet()}")
      Python

      🔄 Evolution: From Variables/Functions to Attributes/Methods

      Understanding the transition from procedural to object-oriented programming:

      graph LR
    A["🔧 Procedural Programming"] --> B["🏗️ Object-Oriented Programming"]

    A1["🌐 Global Variablesbalance = 1000"] --> B1["📊 Instance Attributesself.balance = 1000"]
    A2["🔧 Standalone Functionsdef deposit(amount)"] --> B2["⚙️ Methodsdef deposit(self, amount)"]
    A3["📂 Scattered Datauser_name, user_age"] --> B3["📦 Encapsulated Dataself.name, self.age"]
    A4["🎛️ Manual State Managementif balance > amount"] --> B4["🎯 Object Stateif self.balance > amount"]

    A --> A1
    A --> A2
    A --> A3
    A --> A4

    B --> B1
    B --> B2
    B --> B3
    B --> B4

    style A fill:#ffcdd2
    style B fill:#c8e6c9

      🚫 Procedural Approach – The Old Way

      """
🔧 PROCEDURAL PROGRAMMING PROBLEMS:
- Global state is hard to manage
- Functions are scattered and unrelated  
- Data and behavior are separated
- Hard to create multiple instances
- No encapsulation or data protection
"""

# 🌐 Global variables (shared state - dangerous!)
account_balance = 1000
account_holder = "John Doe"
transaction_history = []

def deposit(amount):
    """💰 Deposit money (operates on global state)"""
    global account_balance, transaction_history
    if amount > 0:
        account_balance += amount
        transaction_history.append(f"Deposited: ${amount}")
        print(f"✅ Deposited ${amount}. New balance: ${account_balance}")
    else:
        print("❌ Invalid deposit amount")

def withdraw(amount):
    """💸 Withdraw money (operates on global state)"""
    global account_balance, transaction_history
    if amount > account_balance:
        print("❌ Insufficient funds!")
    elif amount > 0:
        account_balance -= amount
        transaction_history.append(f"Withdrew: ${amount}")
        print(f"✅ Withdrew ${amount}. New balance: ${account_balance}")
    else:
        print("❌ Invalid withdrawal amount")

def get_balance():
    """📊 Get current balance"""
    return account_balance

def print_statement():
    """📋 Print account statement"""
    print(f"\n💳 ACCOUNT STATEMENT")
    print(f"   Holder: {account_holder}")
    print(f"   Balance: ${account_balance}")
    print(f"   Transactions: {len(transaction_history)}")
    for transaction in transaction_history[-5:]:  # Last 5 transactions
        print(f"   - {transaction}")

# 🎯 Usage (limited to one account!)
print("🏦 PROCEDURAL BANKING SYSTEM")
deposit(500)
withdraw(200)
print_statement()

# ❌ PROBLEM: Can't handle multiple accounts easily!
# If we want another account, we need more global variables or complex data structures
      Python

      ✅ Object-Oriented Approach – The Better Way

      class BankAccount:
    """
    🏦 OBJECT-ORIENTED SOLUTION:
    ✅ Encapsulated data and behavior
    ✅ Easy to create multiple instances
    ✅ Data protection through methods
    ✅ Clear relationship between data and operations
    """

    # 🏛️ Class variable (shared by all accounts)
    bank_name = "Python Bank"
    total_accounts = 0

    def __init__(self, account_holder, initial_balance=0):
        """🎨 Initialize a new bank account"""
        # 📊 Instance variables (unique to each account)
        self.account_holder = account_holder
        self.balance = initial_balance
        self.transaction_history = []
        self.account_number = f"ACC{BankAccount.total_accounts + 1:04d}"

        # 📈 Update class variable
        BankAccount.total_accounts += 1

        # 📝 Record initial transaction
        if initial_balance > 0:
            self.transaction_history.append(f"Initial deposit: ${initial_balance}")

        print(f"🎉 Account created: {self.account_number} for {account_holder}")

    def deposit(self, amount):
        """💰 Deposit money to this specific account"""
        if amount > 0:
            self.balance += amount
            self.transaction_history.append(f"Deposited: ${amount}")
            print(f"✅ Deposited ${amount} to {self.account_number}. New balance: ${self.balance}")
            return True
        else:
            print("❌ Invalid deposit amount")
            return False

    def withdraw(self, amount):
        """💸 Withdraw money from this specific account"""
        if amount > self.balance:
            print(f"❌ Insufficient funds in {self.account_number}!")
            return False
        elif amount > 0:
            self.balance -= amount
            self.transaction_history.append(f"Withdrew: ${amount}")
            print(f"✅ Withdrew ${amount} from {self.account_number}. New balance: ${self.balance}")
            return True
        else:
            print("❌ Invalid withdrawal amount")
            return False

    def get_balance(self):
        """📊 Get current balance"""
        return self.balance

    def transfer_to(self, other_account, amount):
        """🔄 Transfer money to another account"""
        if self.withdraw(amount):  # Use existing withdraw method
            if other_account.deposit(amount):  # Use existing deposit method
                print(f"🔄 Transferred ${amount} from {self.account_number} to {other_account.account_number}")
                return True
        return False

    def print_statement(self):
        """📋 Print account statement"""
        print(f"\n💳 ACCOUNT STATEMENT - {BankAccount.bank_name}")
        print(f"   Account: {self.account_number}")
        print(f"   Holder: {self.account_holder}")
        print(f"   Balance: ${self.balance}")
        print(f"   Transactions: {len(self.transaction_history)}")
        print("   Recent Transactions:")
        for transaction in self.transaction_history[-5:]:  # Last 5 transactions
            print(f"   - {transaction}")

    def __str__(self):
        """📝 String representation"""
        return f"BankAccount({self.account_number}, {self.account_holder}, ${self.balance})"

    def __repr__(self):
        """🔍 Developer representation"""
        return f"BankAccount(account_holder='{self.account_holder}', initial_balance={self.balance})"

# 🎯 Usage (can easily handle multiple accounts!)
print("🏦 OBJECT-ORIENTED BANKING SYSTEM")
print("=" * 50)

# Create multiple accounts
john_account = BankAccount("John Doe", 1000)
alice_account = BankAccount("Alice Smith", 500)
bob_account = BankAccount("Bob Johnson")

# Each account operates independently
john_account.deposit(300)
alice_account.withdraw(100)
bob_account.deposit(750)

# Transfer between accounts
john_account.transfer_to(alice_account, 200)

# Print statements for each account
john_account.print_statement()
alice_account.print_statement()
bob_account.print_statement()

print(f"\n🏛️ Total accounts at {BankAccount.bank_name}: {BankAccount.total_accounts}")
      Python

      🎯 Key Takeaways: Procedural vs OOP

      Aspect🔧 Procedural🏗️ Object-Oriented
      Data StorageGlobal variablesInstance attributes
      BehaviorStandalone functionsMethods bound to objects
      State ManagementManual, error-proneAutomatic, encapsulated
      Multiple InstancesHard to implementNatural and easy
      Data ProtectionNo protectionControlled access
      Code OrganizationScatteredBundled together
      ReusabilityLimitedHigh
      MaintenanceDifficultEasier

      4. The Four Pillars of OOP

      The four pillars form the foundation of object-oriented programming. Think of them as the architectural principles that make OOP powerful and elegant.

      graph TD
    A["🏛️ Object-Oriented Programming"] --> B["🔒 EncapsulationBundle & Protect"]
    A --> C["🧬 InheritanceReuse & Extend"]
    A --> D["🎭 PolymorphismMany Forms"]
    A --> E["🎨 AbstractionHide Complexity"]

    B --> B1["🛡️ Data Protection"]
    B --> B2["📦 Bundling Data & Methods"]
    B --> B3["🚫 Access Control"]

    C --> C1["♻️ Code Reuse"]
    C --> C2["🌳 Class Hierarchies"]
    C --> C3["🔧 Method Overriding"]

    D --> D1["🔄 Method Overriding"]
    D --> D2["🦆 Duck Typing"]
    D --> D3["🎯 Same Interface, Different Behavior"]

    E --> E1["🎭 Hide Implementation"]
    E --> E2["✨ Essential Features Only"]
    E --> E3["🔧 Simple Interface"]

    style A fill:#e8f5e8,stroke:#4caf50,stroke-width:3px
    style B fill:#e3f2fd,stroke:#2196f3,stroke-width:2px
    style C fill:#fff3e0,stroke:#ff9800,stroke-width:2px
    style D fill:#f3e5f5,stroke:#9c27b0,stroke-width:2px
    style E fill:#fce4ec,stroke:#e91e63,stroke-width:2px

      🔒 1. Encapsulation – “Bundle and Protect”

      Core Concept: Encapsulation combines data and the methods that operate on that data into a single unit (class), while controlling access to prevent unwanted modifications.

      Think of it like: A medicine capsule 💊 that contains the active ingredients (data) and controls how they’re released (methods).

      class SmartPhone:
    """📱 Demonstrates encapsulation with a smartphone class"""

    def __init__(self, brand, model):
        # 🔓 Public attributes (accessible from outside)
        self.brand = brand
        self.model = model

        # 🔐 Protected attributes (convention: single underscore)
        self._battery_level = 100
        self._is_on = False

        # 🔒 Private attributes (name mangling: double underscore)
        self.__serial_number = self._generate_serial()
        self.__encryption_key = "secret123"

    def _generate_serial(self):
        """🔐 Protected method (internal use)"""
        import random
        return f"SN{random.randint(100000, 999999)}"

    def power_on(self):
        """🔓 Public method"""
        if self._battery_level > 0:
            self._is_on = True
            print(f"📱 {self.brand} {self.model} powered on")
            return True
        else:
            print("🔋 Battery dead! Cannot power on.")
            return False

    def power_off(self):
        """🔓 Public method"""
        self._is_on = False
        print(f"📱 {self.brand} {self.model} powered off")

    def use_phone(self, minutes):
        """📞 Public method that uses protected data"""
        if not self._is_on:
            print("❌ Phone is off. Power on first!")
            return

        battery_drain = minutes * 2  # 2% per minute
        if self._battery_level >= battery_drain:
            self._battery_level -= battery_drain
            print(f"📞 Used phone for {minutes} minutes. Battery: {self._battery_level}%")
        else:
            print("🔋 Not enough battery for that usage!")

    def charge(self, amount=None):
        """🔌 Public method to charge battery"""
        if amount is None:
            self._battery_level = 100
            print("🔋 Fully charged!")
        else:
            self._battery_level = min(100, self._battery_level + amount)
            print(f"🔋 Charged to {self._battery_level}%")

    def get_device_info(self):
        """📋 Public method to get safe device info"""
        return {
            "brand": self.brand,
            "model": self.model,
            "battery": self._battery_level,
            "status": "ON" if self._is_on else "OFF",
            "serial": self.__serial_number  # Accessed internally
        }

    def __factory_reset(self):
        """🏭 Private method (only for internal use)"""
        self._battery_level = 100
        self._is_on = False
        print("🏭 Factory reset completed")

    def emergency_reset(self, admin_code):
        """🆘 Public interface to private functionality"""
        if admin_code == "ADMIN123":
            self.__factory_reset()
        else:
            print("❌ Invalid admin code!")

# 🎯 Demonstration of encapsulation
phone = SmartPhone("Apple", "iPhone 15")

# ✅ Accessing public attributes/methods
print(f"📱 Phone: {phone.brand} {phone.model}")
phone.power_on()
phone.use_phone(30)
phone.charge(20)

# ✅ Accessing protected members (possible but discouraged)
print(f"🔐 Battery level: {phone._battery_level}%")

# ❌ Accessing private members (requires name mangling)
try:
    print(phone.__serial_number)  # This will fail!
except AttributeError as e:
    print(f"❌ Cannot access private attribute: {e}")

# ✅ Proper way to access private data through public methods
info = phone.get_device_info()
print(f"📋 Device info: {info}")

# ✅ Using public interface to access private functionality
phone.emergency_reset("ADMIN123")
      Python

      💡 Encapsulation Benefits:

      • Data Protection: Prevents accidental corruption of internal state
      • Controlled Access: Provides safe interfaces to interact with data
      • Flexibility: Internal implementation can change without affecting external code
      • Debugging: Easier to track where data is modified

      🧬 2. Inheritance – “Reuse and Extend”

      Core Concept: Inheritance allows a class to acquire properties and methods from another class, creating a parent-child relationship.

      Think of it like: Family genetics 🧬 – children inherit traits from parents but can also have their own unique characteristics.

      graph TD
    A["👥 Person(Base Class)"] --> B["👨‍💼 Employee(Derived Class)"]
    A --> C["👨‍🎓 Student(Derived Class)"]

    B --> B1["👨‍💻 Developer"]
    B --> B2["👨‍🏫 Teacher"] 
    B --> B3["👨‍⚕️ Doctor"]

    C --> C1["👨‍🎓 Undergraduate"]
    C --> C2["👨‍🔬 Graduate"]

    A1["name, age, speak()"] --> A
    B1b["salary, work()"] --> B
    C1c["gpa, study()"] --> C

    style A fill:#e8f5e8,stroke:#4caf50,stroke-width:2px
    style B fill:#e3f2fd,stroke:#2196f3,stroke-width:2px
    style C fill:#fff3e0,stroke:#ff9800,stroke-width:2px
      class Person:
    """👥 Base class representing any person"""

    def __init__(self, name, age, email):
        self.name = name
        self.age = age
        self.email = email
        print(f"👤 Person created: {name}")

    def introduce(self):
        """👋 Basic introduction"""
        return f"Hi! I'm {self.name}, {self.age} years old."

    def send_email(self, message):
        """📧 Send email functionality"""
        print(f"📧 Email sent to {self.email}: {message}")

    def celebrate_birthday(self):
        """🎂 Age up by one year"""
        self.age += 1
        print(f"🎂 Happy birthday {self.name}! Now {self.age} years old.")

    def __str__(self):
        return f"Person(name='{self.name}', age={self.age})"

class Employee(Person):  # 👨‍💼 Employee inherits from Person
    """👨‍💼 Employee class extending Person"""

    def __init__(self, name, age, email, employee_id, salary, department):
        # 📞 Call parent constructor first
        super().__init__(name, age, email)

        # 📊 Add employee-specific attributes
        self.employee_id = employee_id
        self.salary = salary
        self.department = department
        self.vacation_days = 20

        print(f"👨‍💼 Employee created: {employee_id} in {department}")

    def introduce(self):  # 🔄 Override parent method
        """👋 Professional introduction"""
        base_intro = super().introduce()  # Get parent's introduction
        return f"{base_intro} I work in {self.department}."

    def work(self, hours):
        """💼 Work functionality"""
        print(f"👨‍💼 {self.name} worked {hours} hours in {self.department}")
        return hours * (self.salary / 2080)  # Hourly rate calculation

    def request_vacation(self, days):
        """🏖️ Request vacation days"""
        if days <= self.vacation_days:
            self.vacation_days -= days
            print(f"🏖️ {self.name} approved for {days} vacation days. Remaining: {self.vacation_days}")
            return True
        else:
            print(f"❌ Not enough vacation days. Available: {self.vacation_days}")
            return False

    def get_annual_salary(self):
        """💰 Calculate annual compensation"""
        return self.salary

    def __str__(self):
        return f"Employee(name='{self.name}', id='{self.employee_id}', dept='{self.department}')"

class Developer(Employee):  # 👨‍💻 Developer inherits from Employee (which inherits from Person)
    """👨‍💻 Developer class - demonstrates multi-level inheritance"""

    def __init__(self, name, age, email, employee_id, salary, programming_languages):
        # 📞 Call parent constructor (Employee)
        super().__init__(name, age, email, employee_id, salary, "Engineering")

        # 💻 Add developer-specific attributes
        self.programming_languages = programming_languages
        self.projects = []
        self.code_commits = 0

        print(f"👨‍💻 Developer created: {name} - Languages: {', '.join(programming_languages)}")

    def introduce(self):  # 🔄 Override again
        """👋 Technical introduction"""
        base_intro = super().introduce()
        languages = ", ".join(self.programming_languages)
        return f"{base_intro} I code in {languages}."

    def code(self, hours, project_name):
        """💻 Coding functionality"""
        earnings = self.work(hours)  # Use inherited work method
        self.code_commits += hours * 2  # Assume 2 commits per hour

        if project_name not in self.projects:
            self.projects.append(project_name)

        print(f"💻 {self.name} coded for {hours} hours on {project_name}")
        print(f"   💰 Earnings: ${earnings:.2f}")
        print(f"   📊 Total commits: {self.code_commits}")

        return earnings

    def learn_language(self, language):
        """📚 Learn new programming language"""
        if language not in self.programming_languages:
            self.programming_languages.append(language)
            print(f"📚 {self.name} learned {language}! Total languages: {len(self.programming_languages)}")
        else:
            print(f"💡 {self.name} already knows {language}")

    def debug_code(self, bug_description):
        """🐛 Debug functionality"""
        print(f"🔍 {self.name} is debugging: {bug_description}")
        print(f"🛠️ Using {self.programming_languages[0]} expertise...")
        print("✅ Bug fixed!")

    def __str__(self):
        return f"Developer(name='{self.name}', languages={len(self.programming_languages)})"

class Student(Person):  # 👨‍🎓 Student also inherits from Person
    """👨‍🎓 Student class - demonstrates parallel inheritance"""

    def __init__(self, name, age, email, student_id, major, gpa=0.0):
        super().__init__(name, age, email)
        self.student_id = student_id
        self.major = major
        self.gpa = gpa
        self.courses = []
        self.credits = 0

        print(f"👨‍🎓 Student created: {student_id} majoring in {major}")

    def introduce(self):  # 🔄 Override parent method
        """👋 Academic introduction"""
        base_intro = super().introduce()
        return f"{base_intro} I'm studying {self.major} with a {self.gpa:.2f} GPA."

    def enroll(self, course_name, credit_hours):
        """📚 Enroll in a course"""
        self.courses.append(course_name)
        self.credits += credit_hours
        print(f"📚 {self.name} enrolled in {course_name} ({credit_hours} credits)")
        print(f"   📊 Total credits: {self.credits}")

    def study(self, hours, subject):
        """📖 Study functionality"""
        print(f"📖 {self.name} studied {subject} for {hours} hours")
        # Studying might improve GPA
        gpa_improvement = hours * 0.01
        self.gpa = min(4.0, self.gpa + gpa_improvement)
        print(f"   📈 GPA improved to: {self.gpa:.2f}")

    def graduate(self):
        """🎓 Graduate functionality"""
        if self.credits >= 120 and self.gpa >= 2.0:
            print(f"🎓 Congratulations {self.name}! You graduated with a {self.major} degree!")
            print(f"   📊 Final GPA: {self.gpa:.2f}")
            print(f"   📚 Total Credits: {self.credits}")
            return True
        else:
            print(f"❌ {self.name} cannot graduate yet.")
            print(f"   Need: {max(0, 120-self.credits)} more credits, GPA: {self.gpa:.2f}")
            return False

    def __str__(self):
        return f"Student(name='{self.name}', major='{self.major}', gpa={self.gpa:.2f})"

# 🎯 Demonstration of inheritance
print("🧬 INHERITANCE DEMONSTRATION")
print("=" * 50)

# Create instances
person = Person("John Doe", 30, "john@email.com")
employee = Employee("Alice Smith", 28, "alice@company.com", "EMP001", 75000, "Marketing")
developer = Developer("Bob Johnson", 25, "bob@techco.com", "DEV001", 95000, ["Python", "JavaScript"])
student = Student("Charlie Brown", 20, "charlie@university.edu", "STU001", "Computer Science", 3.2)

print("\n👋 INTRODUCTIONS:")
print(person.introduce())
print(employee.introduce())
print(developer.introduce())
print(student.introduce())

print("\n💼 EMPLOYEE ACTIVITIES:")
employee.work(8)
employee.request_vacation(5)

print("\n💻 DEVELOPER ACTIVITIES:")
developer.code(6, "E-commerce Website")
developer.learn_language("Rust")
developer.debug_code("Memory leak in user authentication")

print("\n👨‍🎓 STUDENT ACTIVITIES:")
student.enroll("Data Structures", 3)
student.enroll("Algorithms", 4)
student.study(5, "Python Programming")

print("\n📧 EVERYONE CAN SEND EMAILS (inherited from Person):")
for person_obj in [person, employee, developer, student]:
    person_obj.send_email("Hello from the inheritance demo!")

print(f"\n🔍 OBJECT TYPES:")
print(f"Is employee a Person? {isinstance(employee, Person)}")
print(f"Is developer an Employee? {isinstance(developer, Employee)}")
print(f"Is developer a Person? {isinstance(developer, Person)}")
print(f"Is student an Employee? {isinstance(student, Employee)}")
      Python

      💡 Inheritance Benefits:

      • Code Reuse: Don’t repeat common functionality
      • Hierarchical Organization: Natural modeling of relationships
      • Polymorphism: Different classes can be treated uniformly
      • Extensibility: Easy to add new specialized classes

      🎭 3. Polymorphism – “Many Forms, One Interface”

      Core Concept: Polymorphism allows objects of different types to be treated as instances of the same type through a common interface, while each object responds in its own way.

      Think of it like: A universal remote control 📺 that can operate different devices (TV, DVD, sound system) with the same buttons, but each device responds differently.

      from abc import ABC, abstractmethod
import math

class Shape(ABC):
    """🎨 Abstract base class for all shapes"""

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

    @abstractmethod
    def calculate_area(self):
        """📏 Every shape must be able to calculate its area"""
        pass

    @abstractmethod
    def calculate_perimeter(self):
        """📐 Every shape must be able to calculate its perimeter"""
        pass

    def describe(self):
        """📝 Common description method"""
        return f"I am a {self.name}"

    def display_info(self):
        """📋 Display comprehensive shape information"""
        print(f"\n🎨 {self.describe()}")
        print(f"   📏 Area: {self.calculate_area():.2f} square units")
        print(f"   📐 Perimeter: {self.calculate_perimeter():.2f} units")

class Rectangle(Shape):
    """📦 Rectangle implementation"""

    def __init__(self, width, height):
        super().__init__("Rectangle")
        self.width = width
        self.height = height

    def calculate_area(self):
        """📏 Rectangle area formula"""
        return self.width * self.height

    def calculate_perimeter(self):
        """📐 Rectangle perimeter formula"""
        return 2 * (self.width + self.height)

    def describe(self):
        """📝 Rectangle-specific description"""
        return f"{super().describe()} with width {self.width} and height {self.height}"

class Circle(Shape):
    """⭕ Circle implementation"""

    def __init__(self, radius):
        super().__init__("Circle")
        self.radius = radius

    def calculate_area(self):
        """📏 Circle area formula"""
        return math.pi * self.radius ** 2

    def calculate_perimeter(self):
        """📐 Circle circumference formula"""
        return 2 * math.pi * self.radius

    def describe(self):
        """📝 Circle-specific description"""
        return f"{super().describe()} with radius {self.radius}"

class Triangle(Shape):
    """🔺 Triangle implementation"""

    def __init__(self, side_a, side_b, side_c):
        super().__init__("Triangle")
        self.side_a = side_a
        self.side_b = side_b
        self.side_c = side_c

        # Validate triangle inequality
        if not self._is_valid_triangle():
            raise ValueError("Invalid triangle: sides don't satisfy triangle inequality")

    def _is_valid_triangle(self):
        """✅ Check if sides can form a valid triangle"""
        a, b, c = self.side_a, self.side_b, self.side_c
        return (a + b > c) and (a + c > b) and (b + c > a)

    def calculate_area(self):
        """📏 Triangle area using Heron's formula"""
        s = self.calculate_perimeter() / 2  # Semi-perimeter
        return math.sqrt(s * (s - self.side_a) * (s - self.side_b) * (s - self.side_c))

    def calculate_perimeter(self):
        """📐 Triangle perimeter formula"""
        return self.side_a + self.side_b + self.side_c

    def describe(self):
        """📝 Triangle-specific description"""
        return f"{super().describe()} with sides {self.side_a}, {self.side_b}, {self.side_c}"

class Pentagon(Shape):
    """⭐ Regular Pentagon implementation"""

    def __init__(self, side_length):
        super().__init__("Regular Pentagon")
        self.side_length = side_length

    def calculate_area(self):
        """📏 Regular pentagon area formula"""
        return (1/4) * math.sqrt(25 + 10*math.sqrt(5)) * self.side_length**2

    def calculate_perimeter(self):
        """📐 Regular pentagon perimeter formula"""
        return 5 * self.side_length

    def describe(self):
        """📝 Pentagon-specific description"""
        return f"{super().describe()} with side length {self.side_length}"

# 🎯 Polymorphism in action
def shape_analyzer(shapes):
    """
    🔍 Polymorphic function that works with any shape
    Demonstrates polymorphism - same interface, different behaviors
    """
    print("🎭 POLYMORPHISM DEMONSTRATION")
    print("=" * 50)

    total_area = 0
    total_perimeter = 0

    for i, shape in enumerate(shapes, 1):
        print(f"\n📊 Shape #{i}:")
        shape.display_info()  # Same method call, different behavior!

        total_area += shape.calculate_area()
        total_perimeter += shape.calculate_perimeter()

    print(f"\n📈 SUMMARY:")
    print(f"   Total shapes analyzed: {len(shapes)}")
    print(f"   Combined area: {total_area:.2f} square units")
    print(f"   Combined perimeter: {total_perimeter:.2f} units")
    print(f"   Average area: {total_area/len(shapes):.2f} square units")

def shape_sorter(shapes):
    """📊 Sort shapes by area (polymorphism in sorting)"""
    print("\n🔄 SORTING SHAPES BY AREA:")
    sorted_shapes = sorted(shapes, key=lambda s: s.calculate_area())

    for shape in sorted_shapes:
        print(f"   {shape.describe()}: {shape.calculate_area():.2f} sq units")

def find_largest_shape(shapes):
    """🏆 Find the shape with the largest area"""
    if not shapes:
        return None

    largest = max(shapes, key=lambda s: s.calculate_area())
    print(f"\n🏆 LARGEST SHAPE:")
    print(f"   {largest.describe()}")
    print(f"   Area: {largest.calculate_area():.2f} square units")
    return largest

# Create different shape objects
shapes = [
    Rectangle(5, 3),
    Circle(4),
    Triangle(3, 4, 5),  # Right triangle
    Pentagon(2),
    Rectangle(2, 8),    # Tall rectangle
    Circle(2.5),        # Smaller circle
]

# 🎯 Demonstrate polymorphism
shape_analyzer(shapes)
shape_sorter(shapes)
find_largest_shape(shapes)

# 🦆 Duck typing demonstration
class Duck:
    """🦆 Duck class for duck typing demo"""
    def make_sound(self):
        return "Quack!"

    def move(self):
        return "Swims and flies"

class Dog:
    """🐕 Dog class for duck typing demo"""
    def make_sound(self):
        return "Woof!"

    def move(self):
        return "Runs and walks"

class Robot:
    """🤖 Robot class for duck typing demo"""
    def make_sound(self):
        return "Beep!"

    def move(self):
        return "Rolls on wheels"

def animal_show(creatures):
    """🎪 Duck typing - if it walks like a duck and quacks like a duck..."""
    print(f"\n🦆 DUCK TYPING DEMONSTRATION:")
    print("=" * 30)

    for creature in creatures:
        # We don't care about the type, just that it has the methods we need
        print(f"🎤 {creature.__class__.__name__} says: {creature.make_sound()}")
        print(f"🚶 {creature.__class__.__name__} moves: {creature.move()}")
        print()

# Duck typing in action
creatures = [Duck(), Dog(), Robot()]
animal_show(creatures)
      Python

      💡 Polymorphism Benefits:

      • Flexible Code: Same function works with different types
      • Easy Extension: Add new types without changing existing code
      • Clean Interfaces: Focus on what objects can do, not what they are
      • Duck Typing: Python’s powerful “if it looks like a duck…” approach

      🎨 4. Abstraction – “Hide Complexity, Show Essentials”

      Core Concept: Abstraction presents essential features while hiding complex implementation details, providing a clean and simple interface.

      Think of it like: A car dashboard 🚗 – you see speedometer, fuel gauge, and steering wheel (essential features) but not the complex engine internals.

      from abc import ABC, abstractmethod

class MediaPlayer(ABC):
    """🎵 Abstract media player - defines what all players must do"""

    def __init__(self, name):
        self.name = name
        self.is_playing = False
        self.volume = 50
        self.current_media = None

    @abstractmethod
    def play(self, media_file):
        """▶️ Every media player must implement play"""
        pass

    @abstractmethod
    def stop(self):
        """⏹️ Every media player must implement stop"""
        pass

    @abstractmethod
    def get_supported_formats(self):
        """📋 Return list of supported file formats"""
        pass

    # 🔧 Common functionality (concrete methods)
    def set_volume(self, level):
        """🔊 Volume control (same for all players)"""
        self.volume = max(0, min(100, level))
        print(f"🔊 {self.name} volume set to {self.volume}%")

    def get_status(self):
        """📊 Get player status"""
        status = "Playing" if self.is_playing else "Stopped"
        media = self.current_media or "No media"
        return f"{self.name} - {status} - {media} - Volume: {self.volume}%"

class MP3Player(MediaPlayer):
    """🎵 Concrete MP3 player implementation"""

    def play(self, media_file):
        """▶️ Play MP3 files"""
        if media_file.endswith('.mp3'):
            self.current_media = media_file
            self.is_playing = True
            print(f"🎵 {self.name} playing: {media_file}")
        else:
            print(f"❌ {self.name} cannot play {media_file} (MP3 only)")

    def stop(self):
        """⏹️ Stop MP3 playback"""
        if self.is_playing:
            print(f"⏹️ {self.name} stopped playing: {self.current_media}")
            self.is_playing = False
            self.current_media = None
        else:
            print(f"⏹️ {self.name} is already stopped")

    def get_supported_formats(self):
        """📋 MP3 player supports only MP3"""
        return ['.mp3']

# 🎯 Usage demonstration
mp3_player = MP3Player("iPod Classic")
mp3_player.play("song.mp3")  # Works
mp3_player.play("video.mp4") # Doesn't work
mp3_player.set_volume(80)    # Inherited method
      Python

      💡 Abstraction Benefits:

      • Simplified Interface: Users don’t need to know complex internals
      • Consistent Behavior: All implementations follow the same contract
      • Flexibility: Easy to swap different implementations
      • Focus on What, Not How: Clients care about capabilities, not details

      🏆 The Four Pillars Working Together

      graph TD
    A["🏛️ Real-World System(E-commerce Platform)"] --> B["🔒 EncapsulationProtected user data"]
    A --> C["🧬 InheritanceUser → Customer → PremiumCustomer"]
    A --> D["🎭 PolymorphismPaymentProcessor interface"]
    A --> E["🎨 AbstractionSimple checkout process"]

    B --> B1["🛡️ Private: _password"]
    B --> B2["📊 Public: get_profile()"]

    C --> C1["👤 User: login, logout"]
    C --> C2["🛒 Customer: add_to_cart"]
    C --> C3["⭐ Premium: free_shipping"]

    D --> D1["💳 CreditCard.process()"]
    D --> D2["📱 PayPal.process()"]
    D --> D3["₿ Bitcoin.process()"]

    E --> E1["🛒 Simple: checkout()"]
    E --> E2["🔧 Hidden: payment validation"]

    style A fill:#e8f5e8,stroke:#4caf50,stroke-width:3px
    style B fill:#e3f2fd
    style C fill:#fff3e0
    style D fill:#f3e5f5
    style E fill:#fce4ec

      5. Object Creation and Lifecycle {#object-lifecycle}

      Object Lifecycle

      stateDiagram-v2
    [*] --> Created: Class instantiation
    Created --> Active: __init__() called
    Active --> Active: Methods called
    Active --> Destroyed: Reference count = 0
    Destroyed --> [*]: Garbage collected

    note right of Created: __new__() allocates memory
    note right of Active: Object is usable
    note right of Destroyed: __del__() called (optional)

      Immutable vs Mutable Objects

      Immutable Objects (like sealed letters):

      • Cannot be changed after creation
      • “Modifications” create new objects
      • Examples: int, str, tuple

      Mutable Objects (like whiteboards):

      • Can be modified in-place
      • Same identity preserved
      • Examples: list, dict, set
      # Immutable example
x = "hello"
print(id(x))  # Memory address: e.g., 140234567890
x = x + " world"
print(id(x))  # Different memory address: e.g., 140234567891

# Mutable example
my_list = [1, 2, 3]
print(id(my_list))  # Memory address: e.g., 140234567892
my_list.append(4)
print(id(my_list))  # Same memory address: 140234567892
      Python

      6. Methods vs Functions

      Key Differences

      graph LR
    A[Functions] --> A1[Independent]
    A --> A2[No implicit parameters]
    A --> A3[Called directly]
    A --> A4[Operate on arguments]

    B[Methods] --> B1[Belong to objects]
    B --> B2[Implicit 'self' parameter]
    B --> B3[Called with dot notation]
    B --> B4[Access object attributes]
      FeatureFunctionMethod
      AssociationIndependent, not tied to objectsBelongs to a class/object
      Access to dataOnly accesses passed argumentsCan access object attributes
      Invocationmy_function()my_object.my_method()
      First parameterNo implicit parameterself (instance) or cls (class)

      Example Comparison

      # Function
def add(x, y):
    """Independent function"""
    return x + y

result = add(5, 3)  # Called directly

# Method
class Calculator:
    def __init__(self):
        self.history = []

    def add(self, x, y):
        """Method that can access object state"""
        result = x + y
        self.history.append(f"{x} + {y} = {result}")
        return result

calc = Calculator()
result = calc.add(5, 3)  # Called on object
print(calc.history)  # ['5 + 3 = 8']
      Python

      Method Parameters vs Instance Variables

      class Car:
    def __init__(self, color):
        self.color = color  # Instance variable

    def repaint(self, new_color):  # new_color is method parameter
        print(f"Repainting {self.color} car to {new_color}")
        self.color = new_color  # Modifying instance variable

car = Car("blue")
car.repaint("red")  # Method parameter provided at call time
      Python

      7. OOP vs Functional Programming

      When to Use Each Paradigm

      graph TD
    A[Programming Paradigms] --> B[Object-Oriented Programming]
    A --> C[Functional Programming]

    B --> B1[GUI Applications]
    B --> B2[Game Development]
    B --> B3[Enterprise Software]
    B --> B4[Complex State Management]

    C --> C1[Data Processing]
    C --> C2[Mathematical Computations]
    C --> C3[Concurrent Systems]
    C --> C4[Pure Transformations]

      Key Differences

      AspectOOPFunctional Programming
      Primary conceptObjects with data and behaviorPure functions and immutable data
      StateMutable state in objectsImmutable data
      Side effectsCommon and encouragedAvoided (pure functions)
      Control flowImperative (how to do)Declarative (what to do)
      ConcurrencyComplex due to shared stateNatural due to immutability

      OOP Example: Banking System

      class BankAccount:
    def __init__(self, account_number, initial_balance=0):
        self.account_number = account_number
        self.balance = initial_balance
        self.transaction_history = []

    def deposit(self, amount):
        self.balance += amount
        self.transaction_history.append(f"Deposited: ${amount}")
        return self.balance

    def withdraw(self, amount):
        if self.balance >= amount:
            self.balance -= amount
            self.transaction_history.append(f"Withdrew: ${amount}")
            return True
        return False

# Usage
account = BankAccount("12345", 1000)
account.deposit(500)
account.withdraw(200)
      Python

      Functional Programming Example: Data Processing

      from functools import reduce

# Pure functions
def filter_positive(numbers):
    return [n for n in numbers if n > 0]

def square(numbers):
    return [n ** 2 for n in numbers]

def sum_all(numbers):
    return reduce(lambda x, y: x + y, numbers, 0)

# Function composition
def process_data(numbers):
    positive = filter_positive(numbers)
    squared = square(positive)
    total = sum_all(squared)
    return total

# Usage
data = [-2, -1, 0, 1, 2, 3, 4]
result = process_data(data)  # 30 (1² + 2² + 3² + 4²)
      Python

      What Makes Functional Programming in Python?

      Python supports functional programming through:

      1. First-class functions: Functions can be assigned, passed, and returned
      2. Higher-order functions: map(), filter(), reduce()
      3. Lambda expressions: Anonymous functions
      4. Immutable data types: tuple, frozenset
      5. List comprehensions: Declarative data processing
      # First-class functions
def greet(name):
    return f"Hello, {name}!"

# Assign function to variable
greeting_func = greet

# Pass function as argument
def apply_to_names(names, func):
    return [func(name) for name in names]

names = ["Alice", "Bob", "Charlie"]
greetings = apply_to_names(names, greet)

# Higher-order functions with lambda
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
evens = list(filter(lambda x: x % 2 == 0, numbers))
      Python

      8. Advanced OOP Concepts

      Import: Class vs Object

      graph LR
    A[import statement] --> B[Module Object]
    B --> C[Class Definition]
    C --> D[Object Creation]

    B1["person.py"] --> C1[Person class]
    C1 --> D1["alice = Person('Alice')"]

      When you import, you get the class definition, not an object instance:

      # person.py
class Person:
    def __init__(self, name):
        self.name = name

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

# main.py
from person import Person  # Import the CLASS

# Create OBJECTS from the class
alice = Person("Alice")
bob = Person("Bob")
      Python

      Python Object Model vs SQL Database

      graph TD
    A[Python OOP] -.-> B[SQL Database]

    A1[Class] -.-> B1[Table Schema]
    A2[Object/Instance] -.-> B2[Row/Record]
    A3[Attribute] -.-> B3[Column]
    A4[Method] -.-> B4[Stored Procedure]

    A --> A1
    A --> A2
    A --> A3
    A --> A4

    B --> B1
    B --> B2
    B --> B3
    B --> B4
      Python OOPSQL Database
      ClassTable Schema
      Object InstanceRow/Record
      AttributeColumn
      MethodStored Procedure

      Bridging with ORM:

      # Using SQLAlchemy ORM
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class Employee(Base):  # Python class
    __tablename__ = 'employees'  # SQL table

    id = Column(Integer, primary_key=True)  # SQL column
    name = Column(String(50))  # SQL column
    salary = Column(Integer)  # SQL column

    def give_raise(self, amount):  # Python method
        self.salary += amount

# Create object
emp = Employee(name="John", salary=50000)
emp.give_raise(5000)  # Method call
# ORM translates to SQL UPDATE
      Python

      9. Memory Management and Garbage Collection

      How Python’s Garbage Collection Works

      graph TD
    A[Python GC] --> B[Reference Counting]
    A --> C[Cyclic GC]

    B --> B1[Immediate cleanup]
    B --> B2[Count = 0 → Delete]

    C --> C1[Generation 0: Young objects]
    C --> C2[Generation 1: Survivors]
    C --> C3[Generation 2: Long-lived]

    C1 --> D[Mark & Sweep]
    C2 --> D
    C3 --> D

      Reference Counting

      import sys

# Create object
my_list = [1, 2, 3]
print(sys.getrefcount(my_list))  # 2 (my_list + getrefcount parameter)

# Add reference
another_ref = my_list
print(sys.getrefcount(my_list))  # 3

# Remove reference
del another_ref
print(sys.getrefcount(my_list))  # 2
      Python

      Cyclic References

      class Node:
    def __init__(self, value):
        self.value = value
        self.parent = None
        self.children = []

# Create circular reference
parent = Node("parent")
child = Node("child")

parent.children.append(child)  # parent → child
child.parent = parent          # child → parent

# Even after deleting variables, objects remain due to cycle
del parent
del child
# Cyclic GC needed to clean up
      Python

      Manual GC Control

      import gc

# Disable automatic GC
gc.disable()

# Manual collection
collected = gc.collect()
print(f"Collected {collected} objects")

# Get GC stats
print(gc.get_stats())

# Re-enable automatic GC
gc.enable()
      Python

      10. Real-World Applications

      Enterprise Usage: OOP vs Functional

      graph LR
    A[Enterprise Python] --> B[Predominantly OOP]
    A --> C[Growing FP Usage]
    A --> D[Hybrid Approach]

    B --> B1[Web Frameworks]
    B --> B2[Business Logic]
    B --> B3[APIs]

    C --> C1[Data Processing]
    C --> C2[ML Pipelines]
    C --> C3[Concurrent Systems]

    D --> D1[Best of Both]
    D --> D2[Problem-Specific]

      Real-World OOP Scenarios

      1. GUI Applications

      class Button:
    def __init__(self, text, x, y):
        self.text = text
        self.x = x
        self.y = y
        self.clicked = False

    def on_click(self, callback):
        self.callback = callback

    def handle_click(self):
        self.clicked = True
        if hasattr(self, 'callback'):
            self.callback()

class Window:
    def __init__(self, title):
        self.title = title
        self.buttons = []

    def add_button(self, button):
        self.buttons.append(button)
      Python

      2. Game Development

      class GameObject:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.health = 100

    def update(self):
        pass  # Override in subclasses

class Player(GameObject):
    def __init__(self, x, y, name):
        super().__init__(x, y)
        self.name = name
        self.inventory = []

    def move(self, dx, dy):
        self.x += dx
        self.y += dy

class Enemy(GameObject):
    def __init__(self, x, y, damage):
        super().__init__(x, y)
        self.damage = damage

    def attack(self, target):
        target.health -= self.damage
      Python

      Real-World Functional Programming Scenarios

      1. Data Processing Pipeline

      from functools import reduce
import json

def load_data(filename):
    with open(filename, 'r') as f:
        return json.load(f)

def filter_active_users(users):
    return filter(lambda u: u['active'], users)

def extract_emails(users):
    return map(lambda u: u['email'], users)

def validate_emails(emails):
    return filter(lambda e: '@' in e and '.' in e, emails)

# Pipeline
def process_user_emails(filename):
    return list(
        validate_emails(
            extract_emails(
                filter_active_users(
                    load_data(filename)
                )
            )
        )
    )
      Python

      2. Financial Calculations

      def calculate_compound_interest(principal, rate, time, compounds_per_year):
    return principal * (1 + rate / compounds_per_year) ** (compounds_per_year * time)

def present_value(future_value, rate, time):
    return future_value / (1 + rate) ** time

def portfolio_value(investments):
    return reduce(
        lambda total, inv: total + calculate_compound_interest(**inv),
        investments,
        0
    )

investments = [
    {'principal': 10000, 'rate': 0.05, 'time': 5, 'compounds_per_year': 12},
    {'principal': 5000, 'rate': 0.07, 'time': 3, 'compounds_per_year': 4}
]

total_value = portfolio_value(investments)
      Python

      11. Best Practices and Patterns

      Design Principles

      graph TD
    A[SOLID Principles] --> B[Single Responsibility]
    A --> C[Open/Closed]
    A --> D[Liskov Substitution]
    A --> E[Interface Segregation]
    A --> F[Dependency Inversion]

    B --> B1[One reason to change]
    C --> C1[Open for extension, closed for modification]
    D --> D1[Substitutable subclasses]
    E --> E1[Small, specific interfaces]
    F --> F1[Depend on abstractions]

      Common Design Patterns

      1. Singleton Pattern

      class Database:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super(Database, cls).__new__(cls)
            cls._instance.connection = None
        return cls._instance

    def connect(self):
        if self.connection is None:
            self.connection = "Connected to DB"
        return self.connection

# Usage
db1 = Database()
db2 = Database()
print(db1 is db2)  # True - same instance
      Python

      2. Factory Pattern

      class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory:
    @staticmethod
    def create_animal(animal_type):
        if animal_type.lower() == 'dog':
            return Dog()
        elif animal_type.lower() == 'cat':
            return Cat()
        else:
            raise ValueError(f"Unknown animal type: {animal_type}")

# Usage
factory = AnimalFactory()
dog = factory.create_animal('dog')
cat = factory.create_animal('cat')
      Python

      3. Observer Pattern

      class Subject:
    def __init__(self):
        self._observers = []

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self, message):
        for observer in self._observers:
            observer.update(message)

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

    def update(self, message):
        print(f"{self.name} received: {message}")

# Usage
subject = Subject()
observer1 = Observer("Observer 1")
observer2 = Observer("Observer 2")

subject.attach(observer1)
subject.attach(observer2)
subject.notify("Hello Observers!")
      Python

      Code Quality Guidelines

      1. Clear Class Design

      class Rectangle:
    """A rectangle with width and height."""

    def __init__(self, width, height):
        self._width = self._validate_dimension(width)
        self._height = self._validate_dimension(height)

    @staticmethod
    def _validate_dimension(value):
        if value <= 0:
            raise ValueError("Dimensions must be positive")
        return value

    @property
    def width(self):
        return self._width

    @width.setter
    def width(self, value):
        self._width = self._validate_dimension(value)

    @property
    def height(self):
        return self._height

    @height.setter
    def height(self, value):
        self._height = self._validate_dimension(value)

    def area(self):
        return self._width * self._height

    def perimeter(self):
        return 2 * (self._width + self._height)

    def __str__(self):
        return f"Rectangle({self._width}x{self._height})"

    def __eq__(self, other):
        if not isinstance(other, Rectangle):
            return False
        return self._width == other._width and self._height == other._height
      Python

      2. Proper Error Handling

      class InsufficientFundsError(Exception):
    """Raised when account has insufficient funds for withdrawal."""
    pass

class BankAccount:
    def __init__(self, account_number, initial_balance=0):
        self.account_number = account_number
        self._balance = initial_balance

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Withdrawal amount must be positive")

        if amount > self._balance:
            raise InsufficientFundsError(
                f"Insufficient funds. Balance: {self._balance}, "
                f"Requested: {amount}"
            )

        self._balance -= amount
        return self._balance
      Python

      Testing Your Classes

      import unittest

class TestBankAccount(unittest.TestCase):
    def setUp(self):
        self.account = BankAccount("12345", 1000)

    def test_initial_balance(self):
        self.assertEqual(self.account._balance, 1000)

    def test_successful_withdrawal(self):
        new_balance = self.account.withdraw(500)
        self.assertEqual(new_balance, 500)

    def test_insufficient_funds(self):
        with self.assertRaises(InsufficientFundsError):
            self.account.withdraw(1500)

    def test_negative_withdrawal(self):
        with self.assertRaises(ValueError):
            self.account.withdraw(-100)

if __name__ == '__main__':
    unittest.main()
      Python

      Conclusion

      This comprehensive guide has taken you through the journey from Python programming fundamentals to advanced object-oriented programming concepts. Here are the key takeaways:

      For Beginners:

      • Understand that everything in Python is an object
      • Master the basic concepts of classes, objects, and methods
      • Practice the four pillars of OOP: encapsulation, inheritance, polymorphism, and abstraction

      For Intermediate Developers:

      • Learn when to use OOP vs functional programming approaches
      • Understand memory management and garbage collection
      • Master design patterns and SOLID principles

      For Expert Practitioners:

      • Combine OOP and functional programming paradigms effectively
      • Design robust, maintainable systems using proper architectural patterns
      • Consider performance implications and choose the right approach for each problem

      Final Recommendations:

      1. Practice Regularly: Build projects using different OOP concepts
      2. Read Code: Study well-written Python libraries and frameworks
      3. Test Your Code: Write comprehensive tests for your classes
      4. Refactor: Continuously improve your code structure
      5. Stay Updated: Keep learning about new Python features and best practices

      Remember, Python’s flexibility allows you to use the best approach for each specific problem. Sometimes it’s pure OOP, sometimes functional programming, and often it’s a thoughtful combination of both paradigms.

      The journey from beginner to expert is continuous – keep coding, keep learning, and keep building amazing things with Python!

      12. Interactive Exercises and Projects

      🎯 Beginner Level Exercises

      Exercise 1: Personal Profile Class

      """
🎯 CHALLENGE: Create a PersonalProfile class
Requirements:
- Store name, age, hobbies (list), and city
- Method to add new hobby
- Method to display profile information
- Method to calculate birth year
"""

class PersonalProfile:
    def __init__(self, name, age, city):
        # YOUR CODE HERE
        pass

    def add_hobby(self, hobby):
        # YOUR CODE HERE
        pass

    def display_profile(self):
        # YOUR CODE HERE
        pass

    def get_birth_year(self):
        # YOUR CODE HERE
        pass

# Test your implementation:
# profile = PersonalProfile("Alice", 25, "New York")
# profile.add_hobby("Reading")
# profile.add_hobby("Cooking")
# profile.display_profile()
# print(f"Birth year: {profile.get_birth_year()}")
      Python

      💡 Solution

      class PersonalProfile:
    def __init__(self, name, age, city):
        self.name = name
        self.age = age
        self.city = city
        self.hobbies = []

    def add_hobby(self, hobby):
        if hobby not in self.hobbies:
            self.hobbies.append(hobby)
            print(f"✅ Added '{hobby}' to hobbies")
        else:
            print(f"⚠️ '{hobby}' already in hobbies")

    def display_profile(self):
        print(f"👤 Profile for {self.name}")
        print(f"   Age: {self.age}")
        print(f"   City: {self.city}")
        print(f"   Hobbies: {', '.join(self.hobbies) if self.hobbies else 'None'}")

    def get_birth_year(self):
        from datetime import datetime
        return datetime.now().year - self.age
      Python

      Exercise 2: Simple Calculator Class

      """
🎯 CHALLENGE: Build a Calculator class with history
Requirements:
- Basic operations: add, subtract, multiply, divide
- Keep history of all operations
- Method to show last N operations
- Handle division by zero
"""

class Calculator:
    def __init__(self):
        # YOUR CODE HERE
        pass

    def add(self, a, b):
        # YOUR CODE HERE
        pass

    def subtract(self, a, b):
        # YOUR CODE HERE
        pass

    def multiply(self, a, b):
        # YOUR CODE HERE
        pass

    def divide(self, a, b):
        # YOUR CODE HERE
        pass

    def get_history(self, n=5):
        # YOUR CODE HERE - return last n operations
        pass
      Python

      🚀 Intermediate Level Exercises

      Exercise 3: Library Management System

      """
🎯 CHALLENGE: Create a complete library system
Use all four OOP pillars:
- Abstraction: Abstract LibraryItem class
- Inheritance: Book, Magazine, DVD classes
- Encapsulation: Private/protected attributes
- Polymorphism: Different item types behave differently
"""

from abc import ABC, abstractmethod
from datetime import datetime, timedelta

class LibraryItem(ABC):
    def __init__(self, title, item_id):
        # YOUR CODE HERE - implement encapsulation
        pass

    @abstractmethod
    def get_details(self):
        # Each item shows different details
        pass

    @abstractmethod
    def calculate_late_fee(self, days_late):
        # Different items have different late fees
        pass

    def borrow(self, borrower_name):
        # YOUR CODE HERE
        pass

    def return_item(self):
        # YOUR CODE HERE
        pass

class Book(LibraryItem):
    def __init__(self, title, item_id, author, pages):
        # YOUR CODE HERE
        pass

    def get_details(self):
        # YOUR CODE HERE
        pass

    def calculate_late_fee(self, days_late):
        # Books: $0.50 per day late
        # YOUR CODE HERE
        pass

# Implement Magazine and DVD classes
      Python

      Exercise 4: E-commerce Shopping Cart

      """
🎯 CHALLENGE: Build a shopping cart system
Features needed:
- Product class with name, price, quantity
- Shopping cart that can add/remove products
- Calculate total with tax and discounts
- Different customer types (Regular, Premium, VIP)
"""

class Product:
    def __init__(self, name, price, category):
        # YOUR CODE HERE
        pass

    def __str__(self):
        # YOUR CODE HERE
        pass

class ShoppingCart:
    def __init__(self, customer_type="regular"):
        # YOUR CODE HERE
        pass

    def add_product(self, product, quantity=1):
        # YOUR CODE HERE
        pass

    def remove_product(self, product_name, quantity=1):
        # YOUR CODE HERE
        pass

    def calculate_total(self, tax_rate=0.08):
        # Apply discounts based on customer type
        # Regular: no discount
        # Premium: 5% discount
        # VIP: 10% discount + free shipping
        # YOUR CODE HERE
        pass
      Python

      🏆 Advanced Level Projects

      Project 1: Task Management System

      """
🎯 ADVANCED PROJECT: Build a complete task management system
Features:
- User authentication system
- Task creation with priorities and due dates
- Task categories and filtering
- Progress tracking and statistics
- Data persistence (save/load from files)
"""

import json
from datetime import datetime
from enum import Enum

class Priority(Enum):
    LOW = 1
    MEDIUM = 2
    HIGH = 3
    URGENT = 4

class TaskStatus(Enum):
    TODO = "todo"
    IN_PROGRESS = "in_progress" 
    COMPLETED = "completed"

class User:
    def __init__(self, username, email):
        # YOUR CODE HERE
        pass

    def authenticate(self, password):
        # YOUR CODE HERE - implement basic auth
        pass

class Task:
    def __init__(self, title, description, priority=Priority.MEDIUM):
        # YOUR CODE HERE
        pass

    def mark_completed(self):
        # YOUR CODE HERE
        pass

    def is_overdue(self):
        # YOUR CODE HERE
        pass

class TaskManager:
    def __init__(self):
        # YOUR CODE HERE
        pass

    def add_task(self, task):
        # YOUR CODE HERE
        pass

    def get_tasks_by_priority(self, priority):
        # YOUR CODE HERE
        pass

    def get_overdue_tasks(self):
        # YOUR CODE HERE
        pass

    def save_to_file(self, filename):
        # YOUR CODE HERE - save tasks to JSON
        pass

    def load_from_file(self, filename):
        # YOUR CODE HERE - load tasks from JSON
        pass
      Python

      Project 2: Banking System Simulation

      """
🎯 ADVANCED PROJECT: Complete banking system
Features:
- Multiple account types (Checking, Savings, Credit)
- Transaction history and statements
- Interest calculations
- ATM simulation
- Account freezing/unfreezing
- Multi-currency support
"""

from abc import ABC, abstractmethod
from decimal import Decimal
from datetime import datetime
import uuid

class Transaction:
    def __init__(self, amount, transaction_type, description):
        # YOUR CODE HERE
        pass

class Account(ABC):
    def __init__(self, account_holder, initial_balance=0):
        # YOUR CODE HERE - implement proper encapsulation
        pass

    @abstractmethod
    def calculate_interest(self):
        # Different accounts have different interest rates
        pass

    def deposit(self, amount, description="Deposit"):
        # YOUR CODE HERE
        pass

    def withdraw(self, amount, description="Withdrawal"):
        # YOUR CODE HERE - check account-specific rules
        pass

    def transfer_to(self, target_account, amount):
        # YOUR CODE HERE
        pass

class CheckingAccount(Account):
    def __init__(self, account_holder, initial_balance=0, overdraft_limit=0):
        # YOUR CODE HERE
        pass

    def calculate_interest(self):
        # Checking accounts: 0.1% annual interest
        # YOUR CODE HERE
        pass

class SavingsAccount(Account):
    def __init__(self, account_holder, initial_balance=0):
        # YOUR CODE HERE
        pass

    def calculate_interest(self):
        # Savings accounts: 2.5% annual interest
        # YOUR CODE HERE
        pass

class ATM:
    def __init__(self, bank_name):
        # YOUR CODE HERE
        pass

    def authenticate_user(self, account_number, pin):
        # YOUR CODE HERE
        pass

    def display_menu(self):
        # YOUR CODE HERE
        pass

    def process_transaction(self, account, transaction_type):
        # YOUR CODE HERE
        pass
      Python

      🎮 Gamified Learning Challenges

      Challenge 1: OOP Debugging Championship

      """
🐛 DEBUG CHALLENGE: Fix all the OOP violations in this code
This code has multiple OOP principle violations. Find and fix them all!

Score: 
- Each bug found and fixed: 10 points
- Bonus for explaining the violation: 5 points
"""

# BUGGY CODE - FIX ME!
class car:  # Bug 1: Class names should be PascalCase
    def __init__(self, make, model):
        self.make = make
        self.model = model
        self.speed = 0
        self.fuel = 100
        self.engine_temperature = 0  # Should be private/protected

    def accelerate(self):
        if self.fuel > 0:
            self.speed += 10
            self.fuel -= 5
            self.engine_temperature += 15  # Direct access - breaks encapsulation
        else:
            print("No fuel!")

    def get_speed():  # Bug: Missing self parameter
        return speed  # Bug: Should be self.speed

    def refuel(self, amount):
        self.fuel = amount  # Bug: No validation

class SportsCar(car):
    def accelerate(self):  # Good: Method overriding
        if self.fuel > 0:
            self.speed += 20  # Faster acceleration
            self.fuel -= 10   # More fuel consumption
            # Bug: Not calling any engine temperature logic
        else:
            print("No fuel!")

# Usage (also has bugs)
my_car = car("toyota", "camry")  # Bug: Inconsistent naming
my_car.fuel = -50  # Bug: Direct attribute access allows invalid state
print(my_car.get_speed())  # Will cause error
      Python

      Challenge 2: Design Pattern Implementation

      """
🏗️ DESIGN PATTERN CHALLENGE: Implement common patterns
Choose one and implement it properly:

1. Singleton Pattern - Database connection manager
2. Factory Pattern - Shape creator  
3. Observer Pattern - News subscription system
4. Strategy Pattern - Payment processing
5. Decorator Pattern - Coffee shop order system
"""

# Example: Implement the Strategy Pattern for payment processing
class PaymentStrategy(ABC):
    @abstractmethod
    def process_payment(self, amount):
        pass

class CreditCardPayment(PaymentStrategy):
    def __init__(self, card_number, cvv):
        # YOUR CODE HERE
        pass

    def process_payment(self, amount):
        # YOUR CODE HERE
        pass

class PayPalPayment(PaymentStrategy):
    def __init__(self, email):
        # YOUR CODE HERE
        pass

    def process_payment(self, amount):
        # YOUR CODE HERE
        pass

class PaymentProcessor:
    def __init__(self, strategy):
        # YOUR CODE HERE
        pass

    def set_strategy(self, strategy):
        # YOUR CODE HERE
        pass

    def process_order(self, amount):
        # YOUR CODE HERE
        pass
      Python

      🧪 Testing Your OOP Knowledge

      Quiz: OOP Concepts

      """
📝 QUICK QUIZ: Test your understanding

1. What's the output of this code?
"""

class Parent:
    class_var = "I'm from Parent"

    def __init__(self):
        self.instance_var = "Parent instance"

    def method(self):
        return "Parent method"

class Child(Parent):
    class_var = "I'm from Child"

    def method(self):
        return f"{super().method()} -> Child method"

p = Parent()
c = Child()

print(p.class_var)      # ?
print(c.class_var)      # ?
print(c.method())       # ?
print(Parent.class_var) # ?
print(Child.class_var)  # ?

"""
2. What's wrong with this code?
"""

class BankAccount:
    def __init__(self, balance):
        self.balance = balance  # Should this be public?

    def withdraw(self, amount):
        self.balance -= amount  # What's missing?

account = BankAccount(100)
account.balance = -1000  # Is this allowed? Should it be?
account.withdraw(50)     # What happens?

"""
3. Implement the missing method to make this work:
"""

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

    @fahrenheit.setter
    def fahrenheit(self, value):
        # YOUR CODE HERE - convert Fahrenheit to Celsius
        pass

    def __str__(self):
        return f"{self._celsius}°C ({self.fahrenheit}°F)"

# Should work:
temp = Temperature(25)
print(temp)  # 25°C (77.0°F)
temp.fahrenheit = 86
print(temp)  # Should show 30°C (86°F)
      Python

      🏅 Certification Projects

      Final Project: Choose Your Adventure

      Pick one of these comprehensive projects to demonstrate mastery:

      1. 🎮 Game Development Framework
        • Create a framework for 2D games
        • Use all OOP principles
        • Include: Game objects, collision detection, scoring, levels
      2. 📊 Data Analysis Library
        • Build a mini pandas-like library
        • Support CSV reading, data filtering, grouping
        • Use method chaining and operator overloading
      3. 🌐 Web Framework Basics
        • Create a simple web framework
        • Route handling, middleware support
        • Template engine basics
      4. 🤖 AI Chatbot Framework
        • Design a chatbot system
        • Plugin architecture for different AI providers
        • Conversation history and context management

      🎯 Success Metrics

      Track your progress with these milestones:

      • ✅ Beginner: Can create classes with methods and attributes
      • ✅ Intermediate: Uses inheritance and polymorphism effectively
      • ✅ Advanced: Implements design patterns and abstract classes
      • ✅ Expert: Designs complete systems with proper OOP architecture
      • ✅ Master: Mentors others and contributes to open-source OOP projects

      📚 Additional Resources

      Practice Platforms:

      • HackerRank OOP challenges
      • LeetCode design problems
      • Codewars Python kata
      • Python.org’s OOP tutorial

      Further Reading:

      • “Clean Code” by Robert Martin
      • “Design Patterns” by Gang of Four
      • “Effective Python” by Brett Slatkin
      • “Python Tricks” by Dan Bader

      Open Source Projects to Study:

      • Django framework (web development)
      • Requests library (HTTP handling)
      • Flask framework (lightweight web)
      • SQLAlchemy (database ORM)

      📝 Final Thoughts

      Congratulations on completing this comprehensive journey through Python OOP! Remember:

      1. Practice Regularly: The best way to master OOP is by building projects
      2. Read Others’ Code: Study well-designed libraries and frameworks
      3. Refactor Often: Continuously improve your code structure
      4. Teach Others: Explaining concepts helps solidify your understanding
      5. Stay Curious: Keep exploring new patterns and techniques

      Discover more from Altgr Blog

      Subscribe to get the latest posts sent to your email.

      Related Posts

      Leave a Reply

      Your email address will not be published. Required fields are marked *