Python 데코레이터 완전 정복: @property부터 커스텀 데코레이터까지 실전 활용 가이드

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("함수 실행 전")
        result = func(*args, **kwargs)
        print("함수 실행 후")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"안녕하세요, {name}님!")

say_hello("김철수")
# 출력:
# 함수 실행 전
# 안녕하세요, 김철수님!
# 함수 실행 후

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("반지름은 양수여야 합니다")
        self._radius = value

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

c = Circle(5)
print(c.radius)  # 5 (메서드지만 속성처럼 접근)
print(c.area)    # 78.53975
c.radius = 10    # setter 호출

class DateParser:
    default_format = "%Y-%m-%d"

    @staticmethod
    def is_valid_date(date_string):
        # 단순 유틸리티 함수
        return len(date_string) == 10 and date_string[4] == '-'

    @classmethod
    def from_timestamp(cls, timestamp):
        # 클래스 생성자 역할 (팩토리 메서드)
        from datetime import datetime
        return cls(datetime.fromtimestamp(timestamp))

from functools import wraps

def retry(max_attempts=3):
    def decorator(func):
        @wraps(func)  # 원본 함수의 __name__, __doc__ 보존
        def wrapper(*args, **kwargs):
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise
                    print(f"재시도 {attempt + 1}/{max_attempts}")
        return wrapper
    return decorator

import time
from functools import wraps

def measure_time(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} 실행 시간: {elapsed:.4f}초")
        return result
    return wrapper

@measure_time
def slow_function():
    time.sleep(2)
    return "완료"

def require_auth(permission):
    def decorator(func):
        @wraps(func)
        def wrapper(user, *args, **kwargs):
            if not hasattr(user, 'permissions'):
                raise PermissionError("권한 정보가 없습니다")
            if permission not in user.permissions:
                raise PermissionError(f"{permission} 권한이 필요합니다")
            return func(user, *args, **kwargs)
        return wrapper
    return decorator

@require_auth('admin')
def delete_user(user, target_id):
    print(f"사용자 {target_id} 삭제")

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 fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(100))  # 즉시 계산 (캐시 덕분)

def singleton(cls):
    instances = {}
    @wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class DatabaseConnection:
    def __init__(self):
        print("DB 연결 생성")

db1 = DatabaseConnection()  # "DB 연결 생성" 출력
db2 = DatabaseConnection()  # 출력 없음 (같은 인스턴스)
print(db1 is db2)  # True

@retry(max_attempts=3)
@measure_time
@require_auth('user')
def api_call(user, endpoint):
    # 실제 실행 순서:
    # 1. require_auth 검사
    # 2. measure_time으로 시간 측정 시작
    # 3. retry로 최대 3번 재시도
    pass