OOP & Classes

class Student:
    """Represents a student with name, age, and grades."""

    # Class attribute — shared by ALL instances
    school = "BitWithBite Academy"

    def __init__(self, name, age, gpa=0.0):
        # Instance attributes — unique per object
        self.name   = name
        self.age    = age
        self.gpa    = gpa
        self.grades = []   # mutable — create fresh per instance!

    def add_grade(self, score):
        """Add a grade and recalculate GPA."""
        self.grades.append(score)
        self.gpa = sum(self.grades) / len(self.grades)

    def is_honours(self):
        """Return True if GPA is 3.7 or above."""
        return self.gpa >= 3.7

    def profile(self):
        return f"{self.name}, {self.age}, GPA {self.gpa:.2f}"


# Creating instances
ali  = Student("Ali", 20)
sara = Student("Sara", 22, 3.9)

# Access instance attributes
print(ali.name)        # Ali
print(sara.gpa)        # 3.9

# Access class attribute (shared)
print(ali.school)      # BitWithBite Academy
print(Student.school) # BitWithBite Academy — same

# Call instance methods
ali.add_grade(88)
ali.add_grade(92)
ali.add_grade(78)
print(ali.profile())    # Ali, 20, GPA 86.00
print(ali.is_honours()) # False (86 < 87 threshold)

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

    def add(self, item, price):
        self.items.append((item, price))

    def total(self):
        return sum(p for _, p in self.items)

    # __str__ — called by print() and str()
    def __str__(self):
        lines = [f"  {i:20} PKR {p:,.0f}" for i, p in self.items]
        return f"🛒 {self.owner}'s Cart\n" + "\n".join(lines) + f"\n  Total: PKR {self.total():,.0f}"

    # __repr__ — called in the REPL / for debugging
    def __repr__(self):
        return f"ShoppingCart(owner={self.owner!r}, items={len(self.items)})"

    # __len__ — called by len(cart)
    def __len__(self):
        return len(self.items)

    # __contains__ — called by 'item' in cart
    def __contains__(self, item_name):
        return item_name in [i for i, _ in self.items]

    # __add__ — called by cart1 + cart2
    def __add__(self, other):
        merged = ShoppingCart(f"{self.owner}&{other.owner}")
        merged.items = self.items + other.items
        return merged


cart = ShoppingCart("Fatima")
cart.add("Python Book", 1500)
cart.add("Keyboard", 3200)
cart.add("Mouse", 1800)

print(cart)            # calls __str__
print(len(cart))       # 3
print("Mouse" in cart) # True

class BankAccount:
    _total_accounts = 0    # class attribute — tracked globally
    INTEREST_RATE   = 0.05 # constant — class attribute

    def __init__(self, owner, balance=0):
        self.owner   = owner
        self.balance = balance
        BankAccount._total_accounts += 1

    # Instance method — needs self
    def deposit(self, amount):
        self.balance += amount

    def apply_interest(self):
        self.balance *= (1 + BankAccount.INTEREST_RATE)

    # Class method — receives cls, not self
    @classmethod
    def total_accounts(cls):
        """How many accounts have been created?"""
        return cls._total_accounts

    # Alternative constructor — common pattern
    @classmethod
    def from_dict(cls, data):
        """Create an account from a dict."""
        return cls(data["owner"], data["balance"])

    # Static method — utility, no cls/self needed
    @staticmethod
    def validate_amount(amount):
        """Return True if amount is a positive number."""
        return isinstance(amount, (int, float)) and amount > 0

    def __str__(self):
        return f"Account({self.owner}, PKR {self.balance:,.2f})"


acc1 = BankAccount("Ali", 10000)
acc2 = BankAccount.from_dict({"owner": "Sara", "balance": 25000})

print(BankAccount.total_accounts())     # 2
print(BankAccount.validate_amount(-50)) # False
acc1.deposit(5000)
acc1.apply_interest()
print(acc1)   # Account(Ali, PKR 15,750.00)

class Temperature:
    """Store temperature in Celsius with validation."""

    def __init__(self, celsius):
        self.celsius = celsius   # triggers the setter below

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Temperature below absolute zero!")
        self._celsius = value

    @property
    def fahrenheit(self):
        """Read-only computed property."""
        return self._celsius * 9/5 + 32

    @property
    def kelvin(self):
        return self._celsius + 273.15

    def __str__(self):
        return f"{self.celsius:.1f}°C = {self.fahrenheit:.1f}°F = {self.kelvin:.2f}K"


t = Temperature(100)
print(t)                 # 100.0°C = 212.0°F = 373.15K
print(t.fahrenheit)      # accessed like attribute, not method call!

t.celsius = 0             # triggers setter — validated
print(t)                 # 0.0°C = 32.0°F = 273.15K

# t.celsius = -300  ← ValueError: Temperature below absolute zero!