Lesson 22: Sets, Abstraction & Exam Practice

# Creating a Set
tags = {"python", "web", "security", "python"}   # duplicate "python" is silently dropped
print(tags)   # {'python', 'web', 'security'}   — order may vary

# Empty set — must use set(), not {} (that makes an empty dict)
empty = set()

# Adding and removing
tags.add("automation")
tags.discard("web")    # safe remove — no error if missing
tags.remove("web")     # also removes, but raises KeyError if missing

# Membership check — O(1), much faster than a List for large data
print("security" in tags)   # True
        

admins   = {"blake", "luis", "admin"}
students = {"blake", "kai", "mia", "jordan"}

# Union — everyone in either group
print(admins | students)      # {'blake', 'luis', 'admin', 'kai', 'mia', 'jordan'}

# Intersection — only people in BOTH groups
print(admins & students)      # {'blake'}

# Difference — in admins but NOT in students
print(admins - students)      # {'luis', 'admin'}

# Symmetric difference — in one or the other, but not both
print(admins ^ students)      # {'luis', 'admin', 'kai', 'mia', 'jordan'}
        

user_permissions    = {"view_shrine", "leave_comment", "view_gallery"}
required_for_page   = {"view_shrine", "view_gallery"}

# Does the user have ALL required permissions?
# Intersection should equal the required set
can_access = required_for_page.issubset(user_permissions)
print(can_access)   # True

# Or equivalently:
can_access = required_for_page <= user_permissions   # <= means "is subset of"
        

# Lesson 19 — the caller uses this simple interface:
pipeline = MLPipeline(LinearRegression())
pipeline.train(X_train, y_train)
result = pipeline.evaluate(X_test, y_test)

# The IMPLEMENTATION is hidden — they don't see this complexity:
def train(self, X, y):
    X_scaled = self.scaler.fit_transform(X)   # hidden
    self.model.fit(X_scaled, y)               # hidden
    self._is_trained = True                   # hidden
        

from abc import ABC, abstractmethod

class AuthProvider(ABC):
    """Anyone who implements authentication must provide these two methods."""

    @abstractmethod
    def login(self, username: str, password: str) -> bool:
        pass   # No implementation here — just the contract

    @abstractmethod
    def logout(self, username: str) -> None:
        pass


# A concrete class that fulfils the contract:
class JWTAuth(AuthProvider):
    def login(self, username, password):
        # Real JWT verification logic here
        return verify_jwt(username, password)

    def logout(self, username):
        invalidate_token(username)


# A different concrete class — same interface, different internals:
class SessionAuth(AuthProvider):
    def login(self, username, password):
        # Session-based login logic
        return check_session_db(username, password)

    def logout(self, username):
        clear_session(username)


# If you forget to implement login() or logout(), Python raises a TypeError at runtime:
class BrokenAuth(AuthProvider):
    pass   # Missing both methods

auth = BrokenAuth()   # TypeError: Can't instantiate abstract class BrokenAuth
        

from abc import ABC, abstractmethod

# ABSTRACTION: defines the interface — "what" without "how"
class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        pass

    @abstractmethod
    def perimeter(self) -> float:
        pass

    def describe(self):                   # concrete method — shared by all
        return f"Area: {self.area():.2f}, Perimeter: {self.perimeter():.2f}"


# INHERITANCE: Circle and Rectangle inherit from Shape
class Circle(Shape):
    def __init__(self, radius: float):
        self._radius = radius             # ENCAPSULATION: private attribute

    def area(self):
        return 3.14159 * self._radius ** 2

    def perimeter(self):
        return 2 * 3.14159 * self._radius


class Rectangle(Shape):
    def __init__(self, w: float, h: float):
        self._w = w
        self._h = h

    def area(self):
        return self._w * self._h

    def perimeter(self):
        return 2 * (self._w + self._h)


# POLYMORPHISM: same method name, different behaviour
shapes = [Circle(5), Rectangle(4, 6)]
for shape in shapes:
    print(shape.describe())   # calls each class's own area() + perimeter()