모던 파이썬 중급 #2 typing 본격 — Generic, Protocol, TypedDict, Literal

def first(items: list) -> object:
    return items[0]

x = first([1, 2, 3])    # x: object  ← int 인 정보를 잃어버림

def first[T](items: list[T]) -> T:
    return items[0]

x = first([1, 2, 3])      # x: int
y = first(["a", "b"])     # y: str

from typing import TypeVar

T = TypeVar("T")

def first(items: list[T]) -> T:
    return items[0]

def pair[K, V](key: K, value: V) -> tuple[K, V]:
    return (key, value)

p = pair("name", 42)    # tuple[str, int]

class HasLength:
    def __len__(self) -> int: ...

def shortest[T: HasLength](items: list[T]) -> T:
    return min(items, key=len)

def add[T: (int, float)](a: T, b: T) -> T:
    return a + b

add(1, 2)      # int
add(1.0, 2.0)  # float
add(1, 2.0)    # ✗ T가 한 타입으로 결정 안 됨

class Stack[T]:
    def __init__(self):
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T | None:
        if not self._items:
            return None
        return self._items.pop()

s: Stack[int] = Stack()
s.push(1)
s.push(2)
x = s.pop()    # x: int | None

from typing import Protocol

class Closable(Protocol):
    def close(self) -> None: ...

# 무엇이 Closable 인가?
def safe_close(resource: Closable) -> None:
    resource.close()

# 위 함수는 .close()를 가진 모든 객체를 받음.
# 명시적인 상속 관계가 필요 없음.
class File:
    def close(self) -> None:
        print("file closed")

class Connection:
    def close(self) -> None:
        print("connection closed")

safe_close(File())         # OK — File은 Closable을 충족
safe_close(Connection())   # OK — Connection도 충족

from typing import Protocol, runtime_checkable

@runtime_checkable
class Closable(Protocol):
    def close(self) -> None: ...

print(isinstance(File(), Closable))   # True

from typing import Protocol

class Sized(Protocol):
    def __len__(self) -> int: ...

def first_n[T](items: Sized, n: int) -> ...:
    if len(items) < n:
        raise ValueError("부족함")
    ...

from collections.abc import (
    Iterable, Iterator, Sized, Container,
    Mapping, Sequence, Callable, Hashable
)

def process(items: Iterable[int]) -> None:
    for x in items:
        ...

def lookup(m: Mapping[str, int], key: str) -> int | None:
    return m.get(key)

from typing import TypedDict

class User(TypedDict):
    id: int
    name: str
    age: int

u: User = {"id": 1, "name": "커티스", "age": 30}
print(u["name"])   # name: str — 타입이 좁혀짐

from typing import TypedDict, NotRequired

class User(TypedDict):
    id: int                       # 필수
    name: str                      # 필수
    nickname: NotRequired[str]     # 선택

u1: User = {"id": 1, "name": "커티스"}                       # OK
u2: User = {"id": 1, "name": "커티스", "nickname": "C"}     # OK

from typing import TypedDict, Required

class Config(TypedDict, total=False):
    timeout: int
    retries: int
    base_url: Required[str]    # 이것만 필수

class BaseUser(TypedDict):
    id: int
    name: str

class AdminUser(BaseUser):
    permissions: list[str]

from typing import Literal

def set_log_level(level: Literal["debug", "info", "warning", "error"]) -> None:
    ...

set_log_level("info")     # OK
set_log_level("trace")    # ✗ 허용된 4개에 없음

type Color = Literal["red", "green", "blue"]
type Mode = Literal["light", "dark", "auto"]

def render(color: Color, mode: Mode) -> str:
    ...

from typing import Final, Literal

DEFAULT_LEVEL: Final = "info"
# DEFAULT_LEVEL의 타입이 Literal["info"] 로 좁혀짐

DEFAULT_LEVEL = "warn"   # ✗ Final — 재대입 불가

from typing import Literal, TypedDict

class ClickEvent(TypedDict):
    type: Literal["click"]
    x: int
    y: int

class KeyEvent(TypedDict):
    type: Literal["key"]
    code: str

type Event = ClickEvent | KeyEvent

def handle(event: Event) -> None:
    if event["type"] == "click":
        # 여기서 event는 ClickEvent로 좁혀짐
        print(event["x"], event["y"])
    else:
        # 여기는 KeyEvent
        print(event["code"])

# 옛
from typing import Optional
def find(id: int) -> Optional[str]: ...

# 새 — 항상 이쪽
def find(id: int) -> str | None: ...

from typing import Self

class Builder:
    def __init__(self):
        self.items: list[str] = []

    def add(self, item: str) -> Self:
        self.items.append(item)
        return self