Python 데코레이터 — 작동 방식과 사용 시점

def greet(name: str) -> str:
    return f"Hello, {name}"

# 변수에 할당 — ()가 없으면 호출이 아닌 참조
say_hello = greet
print(say_hello("Alice"))   # 'Hello, Alice'

# 함수를 인수로 전달
def run_twice(fn, value):
    return fn(value), fn(value)

run_twice(greet, "Bob")     # ('Hello, Bob', 'Hello, Bob')

# 함수에서 함수 반환 — "팩토리"
def make_prefixer(prefix: str):
    def prefixed_greet(name: str) -> str:
        return f"{prefix}, {name}"
    return prefixed_greet

morning_hello = make_prefixer("Good morning")
morning_hello("Carol")      # 'Good morning, Carol'

import time
import functools

def timer(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = fn(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{fn.__name__} finished in {elapsed:.4f}s")
        return result
    return wrapper

@timer
def fetch_user_records(db, user_id: int):
    """데이터베이스에서 주어진 사용자의 모든 레코드를 가져옵니다."""
    return db.query("SELECT * FROM records WHERE user_id = ?", user_id)

# fetch_user_records를 호출하는 것은 이제: timer(fetch_user_records)(db, 42)
# @timer가 역설탕화되는 것과 정확히 같습니다

import functools

# @functools.wraps 없이 — 깨진 버전
def bad_timer(fn):
    def wrapper(*args, **kwargs):
        return fn(*args, **kwargs)
    return wrapper

@bad_timer
def process_batch(batch_id: int):
    """단일 배치 작업을 처리합니다."""
    pass

print(process_batch.__name__)   # 'wrapper'   ← 잘못됨
print(process_batch.__doc__)    # None         ← 독스트링 없어짐

# @functools.wraps 사용 — 올바른 버전
def good_timer(fn):
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        return fn(*args, **kwargs)
    return wrapper

@good_timer
def process_batch(batch_id: int):
    """단일 배치 작업을 처리합니다."""
    pass

print(process_batch.__name__)   # 'process_batch'  ← 올바름
print(process_batch.__doc__)    # '단일 배치 작업을 처리합니다.'  ← 유지됨

import functools
import time

def retry(max_attempts: int = 3, delay: float = 1.0, backoff: float = 2.0):
    """
    지수 백오프로 예외 발생 시 함수를 재시도합니다.

    사용법:
        @retry(max_attempts=5, delay=0.5, backoff=2.0)
        def call_external_api(endpoint: str) -> dict:
            ...
    """
    def decorator(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            current_delay = delay
            last_exception = None

            for attempt in range(1, max_attempts + 1):
                try:
                    return fn(*args, **kwargs)
                except Exception as exc:
                    last_exception = exc
                    if attempt < max_attempts:
                        print(
                            f"{fn.__name__}: 시도 {attempt}/{max_attempts} 실패 "
                            f"({exc!r}), {current_delay:.1f}s 후 재시도..."
                        )
                        time.sleep(current_delay)
                        current_delay *= backoff
                    else:
                        print(f"{fn.__name__}: 모든 {max_attempts}번의 시도 실패.")

            raise last_exception

        return wrapper
    return decorator

@retry(max_attempts=4, delay=0.5, backoff=2.0)
def fetch_price_data(ticker: str) -> dict:
    """외부 API에서 주가 데이터를 가져옵니다."""
    response = requests.get(f"https://api.example.com/prices/{ticker}", timeout=5)
    response.raise_for_status()
    return response.json()

import functools
import time

class RateLimiter:
    """
    함수가 호출될 수 있는 빈도를 제한하는 데코레이터.
    이전 호출로부터 `min_interval` 초 이내에 함수가 호출되면
    RuntimeError를 발생시킵니다.
    """

    def __init__(self, min_interval: float):
        self.min_interval = min_interval
        self._last_called: float = 0.0

    def __call__(self, fn):
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            now = time.monotonic()
            since_last = now - self._last_called
            if since_last < self.min_interval:
                wait = self.min_interval - since_last
                raise RuntimeError(
                    f"{fn.__name__} 너무 빨리 호출됨 — "
                    f"다시 호출하기 전에 {wait:.2f}s 기다리세요."
                )
            self._last_called = now
            return fn(*args, **kwargs)
        return wrapper

# 사용 — 2초당 한 번 호출
@RateLimiter(min_interval=2.0)
def send_sms_alert(phone: str, message: str) -> None:
    """게이트웨이 API를 통해 SMS 알림을 보냅니다."""
    sms_gateway.send(phone, message)

from functools import lru_cache, cache
import requests

# @cache — 무한 메모이제이션 (파이썬 3.9+)
# 모든 고유한 인수 조합을 영구적으로 캐시합니다.
# 입력 도메인이 작은 순수 함수에 좋습니다.
@cache
def get_country_name(country_code: str) -> str:
    """ISO 3166 코드에서 국가 이름을 조회합니다. 첫 번째 호출 후 캐시됩니다."""
    response = requests.get(f"https://restcountries.com/v3.1/alpha/{country_code}")
    return response.json()[0]["name"]["common"]

get_country_name("DE")   # API 호출
get_country_name("DE")   # 캐시에서 제공, 네트워크 호출 없음

# @lru_cache(maxsize=N) — 경계가 있는 LRU 캐시
# 캐시가 `maxsize`에 도달하면 최근에 가장 적게 사용된 항목을 제거합니다.
# 입력 도메인이 크고 메모리가 걱정될 때 더 좋습니다.
@lru_cache(maxsize=256)
def compute_discount(base_price: float, tier: str) -> float:
    """무거운 계산 — 가격은 등급에 따라 다릅니다. 상위 256개 조합을 캐시합니다."""
    discount_table = load_discount_table()          # 비용이 많이 드는 DB 호출
    rate = discount_table.get(tier, 0.0)
    return round(base_price * (1 - rate), 2)

# 캐시 성능 검사
print(compute_discount.cache_info())
# CacheInfo(hits=142, misses=14, maxsize=256, currsize=14)

from dataclasses import dataclass, field
from typing import Optional
from datetime import datetime

@dataclass
class WebhookEvent:
    event_type: str
    source_id: int
    payload: dict
    received_at: datetime = field(default_factory=datetime.utcnow)
    retry_count: int = 0
    error_message: Optional[str] = None

# @dataclass는 이 모든 것을 무료로 생성합니다:
# - __init__(self, event_type, source_id, payload, received_at=..., retry_count=0, error_message=None)
# - 모든 필드를 보여주는 __repr__
# - 필드별로 비교하는 __eq__

event = WebhookEvent(event_type="order.created", source_id=9912, payload={"order_id": 44501})
print(event)
# WebhookEvent(event_type='order.created', source_id=9912, payload={...}, retry_count=0, ...)

class UserProfile:
    def __init__(self, first_name: str, last_name: str, email: str):
        self._first_name = first_name
        self._last_name = last_name
        self._email = email.strip().lower()

    @property
    def display_name(self) -> str:
        return f"{self._first_name} {self._last_name}"

    @property
    def email(self) -> str:
        return self._email

    @email.setter
    def email(self, value: str) -> None:
        if "@" not in value:
            raise ValueError(f"유효하지 않은 이메일 주소: {value!r}")
        self._email = value.strip().lower()

profile = UserProfile("Alice", "Smith", "  [email protected]  ")
print(profile.display_name)   # 'Alice Smith'
print(profile.email)          # '[email protected]'

profile.email = "[email protected]"    # setter가 유효성 검사 실행
profile.email = "not-an-email"           # ValueError 발생

import functools
from flask import request, jsonify, g

def require_auth(fn):
    """
    라우트 핸들러가 실행되기 전에 Bearer 토큰을 검증하는 데코레이터.
    성공 시 g.current_user를 설정하고, 실패 시 401 JSON을 반환합니다.
    """
    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        auth_header = request.headers.get("Authorization", "")
        if not auth_header.startswith("Bearer "):
            return jsonify({"error": "Authorization 헤더가 없거나 잘못됨"}), 401

        token = auth_header[len("Bearer "):]
        user = verify_token(token)          # 토큰 검증 로직
        if user is None:
            return jsonify({"error": "유효하지 않거나 만료된 토큰"}), 401

        g.current_user = user               # 라우트 핸들러에서 사용 가능
        return fn(*args, **kwargs)
    return wrapper

# 사용 — auth 확인이 핸들러 본문 전에 실행됨
@app.route("/api/v1/reports/<int:report_id>")
@require_auth
def get_report(report_id: int):
    report = Report.query.get_or_404(report_id)
    if report.owner_id != g.current_user.id:
        return jsonify({"error": "접근 금지됨"}), 403
    return jsonify(report.to_dict())

@decorator_a
@decorator_b
@decorator_c
def my_function():
    pass

# 이것은 다음과 정확히 동일합니다:
my_function = decorator_a(decorator_b(decorator_c(my_function)))

# my_function()이 호출될 때:
# 1. decorator_a의 wrapper가 먼저 실행됩니다 (가장 바깥쪽)
# 2. decorator_b의 wrapper가 두 번째 실행됩니다
# 3. decorator_c의 wrapper가 세 번째 실행됩니다 (가장 안쪽, 실제 함수에 가장 가까움)
# 4. 실제 my_function 본문이 실행됩니다
# 5. 언와인딩: decorator_c → decorator_b → decorator_a

# 실용적인 예: @timer와 @retry의 순서가 중요합니다
# timer가 가장 바깥쪽이면 재시도 대기 시간을 포함한 총 시간을 측정합니다.
# retry가 가장 바깥쪽이면 마지막 성공적인 호출만 측정합니다.

@timer          # 측정: 모든 재시도 + 대기 시간을 포함한 총 시간
@retry(max_attempts=3, delay=1.0)
def sync_with_partner_api(partner_id: int) -> dict:
    ...

# vs.

@retry(max_attempts=3, delay=1.0)  # 측정: 마지막 성공적인 호출만
@timer
def sync_with_partner_api(partner_id: int) -> dict:
    ...

# 보통 @timer를 가장 바깥쪽으로 하는 것이 좋습니다 — 작업의 실제 벽시계 비용을 알려줍니다.
# 호출자에게 "이 함수를 호출하는 것"이 무엇을 의미하는지 생각하고 그 순서로 감싸세요.