Basic Syntax — Senior Level¶

import dis

# Local variable — uses LOAD_FAST (array index lookup)
def local_access():
    x = 42
    return x

# Global variable — uses LOAD_GLOBAL (dict lookup)
GLOBAL_X = 42
def global_access():
    return GLOBAL_X

dis.dis(local_access)
# LOAD_CONST  1 (42)
# STORE_FAST  0 (x)
# LOAD_FAST   0 (x)    ← array index, very fast
# RETURN_VALUE

dis.dis(global_access)
# LOAD_GLOBAL 0 (GLOBAL_X)  ← dict lookup, slower
# RETURN_VALUE

from typing import Protocol, runtime_checkable


@runtime_checkable
class Serializable(Protocol):
    def to_dict(self) -> dict: ...
    def from_dict(cls, data: dict) -> "Serializable": ...


class User:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age

    def to_dict(self) -> dict:
        return {"name": self.name, "age": self.age}

    @classmethod
    def from_dict(cls, data: dict) -> "User":
        return cls(**data)


# No inheritance needed — structural subtyping
def save(entity: Serializable) -> None:
    data = entity.to_dict()
    # save to database...


assert isinstance(User("Alice", 30), Serializable)  # True at runtime

class ValidatedString:
    """Descriptor that validates string attributes."""

    def __init__(self, min_length: int = 1, max_length: int = 255):
        self.min_length = min_length
        self.max_length = max_length

    def __set_name__(self, owner, name):
        self.storage_name = f"_{name}"

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return getattr(obj, self.storage_name, "")

    def __set__(self, obj, value):
        if not isinstance(value, str):
            raise TypeError(f"Expected str, got {type(value).__name__}")
        if not (self.min_length <= len(value) <= self.max_length):
            raise ValueError(
                f"Length must be {self.min_length}-{self.max_length}, got {len(value)}"
            )
        setattr(obj, self.storage_name, value)


class UserProfile:
    username = ValidatedString(min_length=3, max_length=50)
    email = ValidatedString(min_length=5, max_length=255)

    def __init__(self, username: str, email: str):
        self.username = username  # triggers __set__ validation
        self.email = email

# mypackage/utils.py
__all__ = ["retry", "timeout", "validate_input"]

# Only these are exported by `from mypackage.utils import *`
def retry(func, max_attempts=3): ...
def timeout(seconds): ...
def validate_input(data): ...

# Internal helper — not in __all__
def _format_error(msg): ...

# pyproject.toml
# [project.entry-points."myapp.plugins"]
# csv_handler = "myapp.plugins.csv:CSVPlugin"
# json_handler = "myapp.plugins.json:JSONPlugin"

from importlib.metadata import entry_points


def load_plugins(group: str = "myapp.plugins") -> dict:
    """Dynamically load all registered plugins."""
    plugins = {}
    for ep in entry_points(group=group):
        plugins[ep.name] = ep.load()
    return plugins

# repository.py
class UserRepository:
    def __init__(self, session: AsyncSession) -> None:
        self._session = session

    async def find_by_id(self, user_id: int) -> User | None:
        return await self._session.get(User, user_id)

# service.py
class UserService:
    def __init__(self, repo: UserRepository) -> None:
        self._repo = repo

    async def get_user(self, user_id: int) -> User:
        user = await self._repo.find_by_id(user_id)
        if not user:
            raise UserNotFoundError(user_id)
        return user

# router.py
@router.get("/users/{user_id}")
async def get_user(user_id: int, svc: UserService = Depends(get_user_service)):
    return svc.get_user(user_id)

import sys

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

class SlottedPoint:
    __slots__ = ("x", "y")
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y

regular = RegularPoint(1.0, 2.0)
slotted = SlottedPoint(1.0, 2.0)

print(sys.getsizeof(regular))   # ~48 bytes + __dict__
print(sys.getsizeof(slotted))   # ~56 bytes (no __dict__)
# At scale (1M objects): ~200MB vs ~56MB

import timeit

# Loop — interpreted per iteration
def loop_version():
    result = []
    for i in range(10000):
        result.append(i * 2)
    return result

# Comprehension — C-level iteration
def comp_version():
    return [i * 2 for i in range(10000)]

print(timeit.timeit(loop_version, number=1000))   # ~0.95s
print(timeit.timeit(comp_version, number=1000))    # ~0.45s (2.1x faster)

from functools import lru_cache
import timeit

# Without cache — exponential time
def fib_slow(n):
    if n < 2:
        return n
    return fib_slow(n - 1) + fib_slow(n - 2)

# With cache — O(n) time
@lru_cache(maxsize=None)
def fib_fast(n):
    if n < 2:
        return n
    return fib_fast(n - 1) + fib_fast(n - 2)

# fib_slow(35): ~3.2 seconds
# fib_fast(35): ~0.00001 seconds (320,000x faster)

# a.py
from b import helper  # tries to import b, which imports a → ImportError

# b.py
from a import utility

# Fix: restructure or use lazy imports
# a.py
def get_helper():
    from b import helper  # lazy import — only when called
    return helper

# ❌ Shadows built-in list
list = [1, 2, 3]
new_list = list(range(5))  # TypeError: 'list' object is not callable

# ❌ Shadows built-in id
id = 42
print(id(some_object))  # TypeError

# ✅ Use descriptive names
items = [1, 2, 3]
user_id = 42

# Generators can only be iterated once
gen = (x ** 2 for x in range(5))
print(list(gen))  # [0, 1, 4, 9, 16]
print(list(gen))  # [] — exhausted!

# If you need multiple iterations, use a list
squares = [x ** 2 for x in range(5)]