Classes & Objects: The Blueprint of Reality

class Robot:
    # The "Constructor". This runs automatically when you build a new Robot.
    def __init__(self, name, color):
        self.name = name    # Everyone gets a unique name
        self.color = color  # Everyone gets a unique color
        self.battery = 100  # Everyone starts with 100% battery

    # A "Action" (Method)
    def say_hello(self):
        print(f"I am {self.name}, a {self.color} robot.")

    def shoot(self):
        print("Pew! Pew!")
        self.battery -= 10 # Using actions costs energy!

# Creating Objects (Instantiation)
r1 = Robot("R2D2", "Blue")
r2 = Robot("C3PO", "Gold")

# Using the Objects
r1.say_hello() # "I am R2D2, a Blue robot."
r2.say_hello() # "I am C3PO, a Gold robot."

print(r1.battery) # 100
r1.shoot()        # Pew! Pew!
print(r1.battery) # 90 (Notice R2D2 lost battery, but C3PO is still at 100!)

class Robot:
    # specific to the Class (Shared by everyone)
    manufacturer = "CyberDyne Systems" 

    def __init__(self, name):
        # specific to the Instance (Unique to you)
        self.name = name

r1 = Robot("Terminator")
r2 = Robot("Wall-E")

print(r1.manufacturer) # CyberDyne Systems
print(r2.manufacturer) # CyberDyne Systems

# If we change the Class Attribute...
Robot.manufacturer = "Skynet"

# It changes for EVERYONE instantly!
print(r1.manufacturer) # Skynet
print(r2.manufacturer) # Skynet

print(r1.__dict__)
# Output: {'name': 'Terminator', 'battery': 100}

# You can even hack it directly (but don't!)
r1.__dict__['name'] = "Arnold"
print(r1.name) # Arnold

class Point:
    __slots__ = ['x', 'y'] # ONLY these variables are allowed!

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(10, 20)
# p.z = 30 # ❌ AttributeError!

class BankAccount:
    """A secure representation of a user bank account."""

    # Class Attribute (Interest Rate shared by all)
    interest_rate: float = 0.05

    def __init__(self, owner: str, balance: float):
        self.owner = owner
        # Private attribute (convention) - note the underscore
        self._balance = balance 
        self._is_frozen = False

    def deposit(self, amount: float):
        if self._is_frozen:
            print("❌ Account is frozen!")
            return
        
        if amount > 0:
            self._balance += amount
            print(f"✅ Deposited ${amount}. New Balance: ${self._balance}")
        else:
            print("❌ Amount must be positive.")

    def withdraw(self, amount: float):
        if self._is_frozen:
            print("❌ Account is frozen!")
            return

        if 0 < amount <= self._balance:
            self._balance -= amount
            print(f"💸 Withdrew ${amount}. Remaining: ${self._balance}")
        else:
            print("❌ Insufficient funds.")

    def apply_interest(self):
        """Adds interest based on the shared class rate."""
        interest = self._balance * BankAccount.interest_rate
        self._balance += interest
        print(f"📈 Interest applied: ${interest:.2f}")

# Usage
my_acc = BankAccount("Rohit", 1000)
my_acc.deposit(500)       # 1500
my_acc.withdraw(200)      # 1300
my_acc.apply_interest()   # Adds 5%

student = {
    "name": "Alice",
    "grades": [90, 85, 88]
}

def get_average(student):
    return sum(student["grades"]) / len(student["grades"])
# Risk: Typos! student["grade"] will break everything.

class Student:
    def __init__(self, name, grades):
        self.name = name
        self.grades = grades
    
    def get_average(self):
        return sum(self.grades) / len(self.grades)

s = Student("Alice", [90, 85, 88])
print(s.get_average())
# Benefit: Code Completion, Structure, and Validation!

from dataclasses import dataclass

@dataclass
class Product:
    name: str
    price: float
    in_stock: bool = True

# Python automatically generates __init__, __repr__, etc.
p = Product("Laptop", 999.99)
print(p) 
# Output: Product(name='Laptop', price=999.99, in_stock=True)

class HighCommander:
    _instance = None

    def __new__(cls):
        # Even if you try to make a new one, we give you the OLD one.
        if cls._instance is None:
            cls._instance = super(HighCommander, cls).__new__(cls)
            cls._instance.orders = "Attack!"
        return cls._instance

leader1 = HighCommander()
leader2 = HighCommander()

print(leader1 is leader2) # True (They are the SAME object in memory)
leader1.orders = "Retreat!"
print(leader2.orders) # "Retreat!"