1~3주차 — 타입 힌트와 dataclass · 데코레이터와 컨텍스트 매니저 · 이터레이터·제너레이터 심화

def greet(name: str, age: int = 20) -> str:
    return f"{name}({age})"

count: int = 0
items: list[str] = []

from typing import Optional, Union, Any, Callable

def find_user(uid: int) -> Optional[dict]:
    """Optional[X] = X | None"""
    ...

def parse(value: Union[str, int]) -> int:
    """str 또는 int (Python 3.10+ 에서는 str | int)"""
    ...

handler: Callable[[int], str] = lambda x: str(x)

def find_user(uid: int) -> dict | None: ...
def parse(value: str | int) -> int: ...

nums: list[int] = [1, 2, 3]
scores: dict[str, int] = {"Alice": 90}
pair: tuple[int, str] = (1, "a")
unique: set[int] = {1, 2, 3}

pip install mypy
mypy main.py
mypy --strict main.py    # 엄격 모드

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

p = Point(1, 2)
print(p)              # Point(x=1, y=2)
print(p == Point(1, 2))   # True

from dataclasses import dataclass, field

@dataclass
class Book:
    title: str
    author: str
    tags: list[str] = field(default_factory=list)
    price: float = 0.0

b = Book("Python", "Guido")
b.tags.append("language")

@dataclass(frozen=True)
class Point:
    x: int
    y: int

p = Point(1, 2)
# p.x = 99   # FrozenInstanceError
{Point(1, 2)}   # OK

def loud(func):
    def wrapper(*args, **kwargs):
        print(f">>> {func.__name__} 호출")
        result = func(*args, **kwargs)
        print(f"<<< 결과: {result}")
        return result
    return wrapper

@loud
def add(a, b):
    return a + b

add(3, 5)
# >>> add 호출
# <<< 결과: 8

from functools import wraps

def loud(func):
    @wraps(func)            # 이거 없으면 .__name__ 이 'wrapper' 됨
    def wrapper(*args, **kwargs):
        ...
    return wrapper

def retry(times):
    def deco(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"재시도 {i+1}/{times}: {e}")
            raise
        return wrapper
    return deco

@retry(3)
def fragile():
    ...

class FileLock:
    def __init__(self, path):
        self.path = path
    def __enter__(self):
        print(f"잠금: {self.path}")
        return self
    def __exit__(self, exc_type, exc, tb):
        print("해제")

with FileLock("data.txt"):
    print("작업 중")

from contextlib import contextmanager
import time

@contextmanager
def timer(label):
    start = time.perf_counter()
    yield
    print(f"{label}: {time.perf_counter() - start:.4f}s")

with timer("작업"):
    sum(range(1_000_000))

def memoize(func):
    cache = {}
    @wraps(func)
    def wrapper(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrapper

@memoize
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

fib(100)   # 빠름

class Range:
    def __init__(self, start, stop):
        self.cur = start
        self.stop = stop

    def __iter__(self):
        return self

    def __next__(self):
        if self.cur >= self.stop:
            raise StopIteration
        self.cur += 1
        return self.cur - 1

print(list(Range(1, 5)))   # [1, 2, 3, 4]

def chain(*iters):
    for it in iters:
        yield from it

print(list(chain([1, 2], (3, 4), "ab")))   # [1, 2, 3, 4, 'a', 'b']

import itertools as it

# 무한 시퀀스
counter = it.count(1, 2)        # 1, 3, 5, 7, ...
print(list(it.islice(counter, 5)))  # [1, 3, 5, 7, 9]

# 조합/순열
print(list(it.combinations([1, 2, 3, 4], 2)))
print(list(it.permutations([1, 2, 3], 2)))

# 그룹
data = [("a", 1), ("a", 2), ("b", 3), ("b", 4)]
for key, group in it.groupby(data, key=lambda x: x[0]):
    print(key, list(group))

# 사전 곱
print(list(it.product([1, 2], "ab")))

# 누적
print(list(it.accumulate([1, 2, 3, 4])))   # [1, 3, 6, 10]

def echo():
    while True:
        x = yield
        print(f"받음: {x}")

co = echo()
next(co)            # 첫 yield까지 진행 (필수)
co.send("hello")
co.send("world")