class Dog:
    # Class Attribute: Shared by ALL instances of Dog
    species = "Canis familiaris"

    # Initializer (Constructor)
    # 'self' refers to the specific object being created
    def __init__(self, name, age):
        # Instance Attributes: Unique to each instance
        self.name = name
        self.age = age

    # Instance Method
    def bark(self):
        return f"{self.name} says Woof!"

# Usage
buddy = Dog("Buddy", 5)
print(buddy.bark())

class Animal:
    def speak(self):
        raise NotImplementedError("Subclasses must implement speak()")

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

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

# Polymorphism: treat different types uniformly
animals = [Cat(), Dog(), Cat()]
for animal in animals:
    print(animal.speak())  # Each calls its own version of speak()

class GoldenRetriever(Dog):
    def speak(self):
        # Call parent's speak(), then add to it
        return super().speak() + " (Golden Style)"

class A:
    def greet(self):
        return "A"

class B(A):
    def greet(self):
        return "B"

class C(A):
    def greet(self):
        return "C"

class D(B, C):
    pass  # Inherits from both B and C

print(D().greet())   # "B" -- B comes before C in the MRO
print(D.__mro__)     # (D, B, C, A, object) -- the full resolution order

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

    def __repr__(self):
        # __repr__ should be unambiguous -- ideally you could copy-paste to recreate
        return f"Vector({self.x}, {self.y})"

    def __str__(self):
        # __str__ is for human-friendly display
        return f"({self.x}, {self.y})"

    def __add__(self, other):
        # Called when you do v1 + v2
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other):
        # Called when you do v1 == v2
        return self.x == other.x and self.y == other.y

v1 = Vector(1, 2)
v2 = Vector(3, 4)
v3 = v1 + v2

print(v3)        # Output: (4, 6)      -- calls __str__
print(repr(v3))  # Output: Vector(4, 6) -- calls __repr__
print(v1 == Vector(1, 2))  # True       -- calls __eq__

class Circle:
    def __init__(self, radius):
        self._radius = radius # Convention: _variable means "internal use only"

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("Radius cannot be negative")
        self._radius = value

c = Circle(5)
c.radius = 10 # Calls the setter method!
# c.radius = -1 # Raises ValueError

from dataclasses import dataclass, field

@dataclass
class Point:
    x: int
    y: int
    z: int = 0  # Default value

p1 = Point(1, 2)
p2 = Point(1, 2)

print(p1)        # Output: Point(x=1, y=2, z=0) -- auto-generated __repr__
print(p1 == p2)  # Output: True -- auto-generated __eq__ compares field values

@dataclass(frozen=True)
class Config:
    host: str
    port: int
    debug: bool = False

config = Config("localhost", 8080)
# config.port = 9090  # FrozenInstanceError! Cannot modify.
# Frozen dataclasses are hashable -- can be used as dict keys or set members

class PointWithSlots:
    __slots__ = ("x", "y")  # Only these attributes are allowed

    def __init__(self, x, y):
        self.x = x
        self.y = y
        # self.z = 0  # AttributeError! z is not in __slots__

# In Python 3.10+, dataclasses support slots directly:
@dataclass(slots=True)
class Point:
    x: float
    y: float

# This function works with ANY object that has a .read() method --
# a file, a StringIO, a network socket, a mock in tests.
def process_stream(stream):
    data = stream.read()
    return data.upper()

# Since Python 3.8+, you can formalize duck typing with Protocol:
from typing import Protocol

class Readable(Protocol):
    def read(self) -> str: ...

def process_stream(stream: Readable) -> str:  # Type checker enforces the contract
    return stream.read().upper()