Object-Oriented Programming

class Person:
    # Class attribute (shared by all instances)
    species = "Human"

    # Constructor (initializer)
    def __init__(self, name, age):
        # Instance attributes (unique to each instance)
        self.name = name
        self.age = age

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

    # String representation
    def __str__(self):
        return f"Person({self.name}, {self.age})"

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

# Creating objects (instances)
alice = Person("Alice", 30)
bob = Person("Bob", 25)

print(alice.greet())     # "Hello, I'm Alice"
print(alice.species)     # "Human"
print(Person.species)    # "Human"

class Dog:
    # Class attribute
    species = "Canis familiaris"
    count = 0

    def __init__(self, name):
        # Instance attribute
        self.name = name
        Dog.count += 1  # Modify class attribute

dog1 = Dog("Buddy")
dog2 = Dog("Max")

print(dog1.name)    # "Buddy" (instance)
print(dog2.name)    # "Max" (instance)
print(Dog.count)    # 2 (class)
print(dog1.count)   # 2 (accessed via instance)

class MyClass:
    class_var = 0

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

    # Instance method - needs self, can access instance and class
    def instance_method(self):
        return f"Instance value: {self.value}"

    # Class method - needs cls, can access class but not instance
    @classmethod
    def class_method(cls):
        return f"Class var: {cls.class_var}"

    # Static method - no self/cls, utility function
    @staticmethod
    def static_method(x, y):
        return x + y

    # Alternative constructor (common classmethod use)
    @classmethod
    def from_string(cls, data_string):
        value = int(data_string)
        return cls(value)

obj = MyClass(10)
print(obj.instance_method())      # "Instance value: 10"
print(MyClass.class_method())     # "Class var: 0"
print(MyClass.static_method(2,3)) # 5

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

    @property
    def celsius(self):
        """Get temperature in Celsius."""
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        """Set temperature with validation."""
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value

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

temp = Temperature(25)
print(temp.celsius)      # 25
print(temp.fahrenheit)   # 77.0
temp.celsius = 30        # Uses setter
# temp.celsius = -300    # ValueError!

class BankAccount:
    def __init__(self, balance):
        self.public = "Anyone can access"    # Public
        self._protected = "Convention only"   # Protected (convention)
        self.__private = balance              # Private (name mangling)

    def get_balance(self):
        return self.__private

account = BankAccount(1000)
print(account.public)       # Works
print(account._protected)   # Works (but shouldn't)
# print(account.__private)  # AttributeError!
print(account._BankAccount__private)  # Works (name mangling)

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

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other):
        return self.x == other.x and self.y == other.y

    def __len__(self):
        return int((self.x**2 + self.y**2)**0.5)

v1 = Vector(2, 3)
v2 = Vector(4, 5)
v3 = v1 + v2         # Uses __add__
print(v3)            # Vector(6, 8)
print(v1 == v2)      # False