Python 데코레이터 개념 정리

1️⃣ 데코레이터 기초

데코레이터는 함수나 클래스의 동작을 수정하거나 확장하는 방법이다.

# 기본 데코레이터
def my_decorator(func):
    def wrapper():
        print("함수 실행 전")
        func()
        print("함수 실행 후")
    return wrapper

# 데코레이터 사용
@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# 출력:
# 함수 실행 전
# Hello!
# 함수 실행 후

# 데코레이터 작동 원리 이해하기
# @my_decorator는 다음과 동일하다:
# say_hello = my_decorator(say_hello)

✅ 특징:

함수 수정
코드 재사용
가독성 향상
함수 확장
원본 함수 보존

2️⃣ 매개변수가 있는 데코레이터

함수에 인자가 있을 때 데코레이터를 적용하는 방법이다.

def with_params(func):
    def wrapper(*args, **kwargs):
        print(f"매개변수: {args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

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

print(add(3, 4))  # 매개변수: (3, 4), {}
                  # 7

# 메서드에 적용
class Calculator:
    @with_params
    def multiply(self, a, b):
        return a * b

calc = Calculator()
print(calc.multiply(5, 6))  # 매개변수: (Calculator 객체, 5, 6), {}
                           # 30

✅ 특징:

유연한 매개변수 처리
함수 반환값 처리
디버깅 용이
모든 타입의 인자 지원
클래스 메서드에도 적용 가능

3️⃣ 데코레이터에 인자 전달

데코레이터 자체에 매개변수를 전달하여 동작을 커스터마이징할 수 있다.

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            results = []
            for _ in range(times):
                results.append(func(*args, **kwargs))
            return results
        return wrapper
    return decorator

@repeat(times=3)
def greet(name):
    import random
    greetings = ["Hello", "Hi", "Hey", "Howdy", "Greetings"]
    return f"{random.choice(greetings)} {name}"

print(greet("Alice"))  # 3개의 인사말 목록 출력

# 데코레이터 중첩 매개변수
def log_level(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"[{level}] 함수 '{func.__name__}' 실행")
            return func(*args, **kwargs)
        return wrapper
    return decorator

@log_level(level="INFO")
def process_data(data):
    return data * 2

print(process_data(10))  # [INFO] 함수 'process_data' 실행
                         # 20

✅ 특징:

데코레이터 설정
반복 실행
커스터마이징
설정 매개변수 지원
중첩 데코레이터 구조
런타임 매개변수 지정

4️⃣ 클래스 데코레이터

클래스를 이용한 데코레이터 구현 방법이다.

class Timer:
    def __init__(self, func):
        self.func = func
        self.count = 0
        
    def __call__(self, *args, **kwargs):
        import time
        start = time.time()
        result = self.func(*args, **kwargs)
        end = time.time()
        self.count += 1
        print(f"함수 '{self.func.__name__}'의 {self.count}번째 호출, 실행 시간: {end - start:.4f}초")
        return result

@Timer
def slow_function():
    import time
    time.sleep(1)

slow_function()  # 함수 'slow_function'의 1번째 호출, 실행 시간: 1.0010초
slow_function()  # 함수 'slow_function'의 2번째 호출, 실행 시간: 1.0008초

# 클래스 자체에 데코레이터 적용
def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Database:
    def __init__(self, url):
        print(f"DB에 연결 중: {url}")
        self.url = url

db1 = Database("localhost:5432")  # DB에 연결 중: localhost:5432
db2 = Database("localhost:5432")  # 출력 없음 (같은 인스턴스 반환)
print(db1 is db2)  # True

✅ 특징:

객체지향적 접근
상태 유지
메서드 재사용
호출 횟수 추적
인스턴스 생성 제어
클래스 변형

5️⃣ 여러 데코레이터 사용

여러 데코레이터를 함께 사용하여 기능을 조합할 수 있다.

def bold(func):
    def wrapper(*args, **kwargs):
        return f"<b>{func(*args, **kwargs)}</b>"
    return wrapper

def italic(func):
    def wrapper(*args, **kwargs):
        return f"<i>{func(*args, **kwargs)}</i>"
    return wrapper

@bold
@italic
def hello(name):
    return f"Hello, {name}!"

print(hello("World"))  # <b><i>Hello, World!</i></b>

# 데코레이터 적용 순서 이해하기
# 안쪽에서 바깥쪽 순서로 실행된다
@bold       # 3. bold 적용
@italic     # 2. italic 적용
def goodbye(name):
    return f"Goodbye, {name}!"  # 1. 원래 함수 실행

print(goodbye("Python"))  # <b><i>Goodbye, Python!</i></b>

✅ 특징:

데코레이터 체이닝
순서 중요성
텍스트 변환 예시
중첩 실행 흐름
다중 기능 확장
코드 모듈화

6️⃣ 실용적인 데코레이터 예제

실제 프로젝트에서 유용하게 사용할 수 있는 데코레이터 예제이다.

import functools
import time
import logging

# 함수 메타데이터 보존
def log_execution(func):
    @functools.wraps(func)  # 원본 함수의 메타데이터 유지
    def wrapper(*args, **kwargs):
        logging.info(f"함수 {func.__name__} 실행 시작")
        result = func(*args, **kwargs)
        logging.info(f"함수 {func.__name__} 실행 완료")
        return result
    return wrapper

# 재시도 데코레이터
def retry(max_attempts=3, delay=1):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts:
                        raise
                    logging.warning(f"시도 {attempt}/{max_attempts} 실패: {e}")
                    time.sleep(delay)
        return wrapper
    return decorator

# 캐싱 데코레이터
def memoize(func):
    cache = {}
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # 키워드 인자는 정렬하여 일관된 해시 생성
        key = str(args) + str(sorted(kwargs.items()))
        if key not in cache:
            cache[key] = func(*args, **kwargs)
        return cache[key]
    return wrapper

# 타입 검사 데코레이터
def validate_types(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        sig = func.__annotations__
        # 위치 인자 검사
        for i, (param_name, param_type) in enumerate(
            [(k, v) for k, v in sig.items() if k != 'return'][:len(args)]
        ):
            if not isinstance(args[i], param_type):
                raise TypeError(f"인자 '{param_name}'는 {param_type}이어야 하지만 {type(args[i])}입니다")
        
        # 키워드 인자 검사
        for param_name, arg in kwargs.items():
            if param_name in sig and not isinstance(arg, sig[param_name]):
                raise TypeError(f"인자 '{param_name}'는 {sig[param_name]}이어야 하지만 {type(arg)}입니다")
        
        result = func(*args, **kwargs)
        # 반환값 검사
        if 'return' in sig and not isinstance(result, sig['return']):
            raise TypeError(f"반환값은 {sig['return']}이어야 하지만 {type(result)}입니다")
        
        return result
    return wrapper

# 데코레이터 사용 예시
@log_execution
@retry(max_attempts=3)
@memoize
@validate_types
def fetch_data(url: str, timeout: int = 10) -> dict:
    """외부 API에서 데이터를 가져오는 함수"""
    import random
    if random.random() < 0.3:  # 30% 확률로 실패
        raise ConnectionError("연결 오류 발생")
    return {"data": f"URL {url}에서 가져온 데이터", "timestamp": time.time()}

# 로깅 설정
logging.basicConfig(level=logging.INFO)

try:
    result = fetch_data("https://api.example.com", timeout=5)
    print(result)
    
    # 두 번째 호출 - 캐시에서 가져옴
    result2 = fetch_data("https://api.example.com", timeout=5)
    print("캐시 히트:", result is result2)
    
    # 잘못된 타입 전달
    fetch_data(123)  # TypeError 발생
except Exception as e:
    print(f"오류 발생: {e}")

✅ 특징:

함수 메타데이터 보존
예외 처리와 재시도
메모이제이션(캐싱)
타입 검증
로깅 및 디버깅
실제 유스케이스 지원
함수형 프로그래밍 접근법

7️⃣ 메서드 데코레이터

클래스 내 메서드에 데코레이터를 적용하는 방법이다.

import functools

# 인스턴스 메서드 데코레이터
def require_auth(func):
    @functools.wraps(func)
    def wrapper(self, *args, **kwargs):
        if not self.is_authenticated:
            raise PermissionError("인증이 필요합니다")
        return func(self, *args, **kwargs)
    return wrapper

# 클래스 메서드 데코레이터
def class_method_decorator(func):
    @functools.wraps(func)
    def wrapper(cls, *args, **kwargs):
        print(f"클래스 {cls.__name__}의 메서드 호출")
        return func(cls, *args, **kwargs)
    return wrapper

# 정적 메서드 데코레이터
def static_method_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print("정적 메서드 호출")
        return func(*args, **kwargs)
    return wrapper

class User:
    def __init__(self, username, authenticated=False):
        self.username = username
        self.is_authenticated = authenticated
    
    @require_auth
    def view_profile(self):
        return f"{self.username}의 프로필 정보"
    
    @classmethod
    @class_method_decorator
    def create_admin(cls, username):
        user = cls(username, authenticated=True)
        user.is_admin = True
        return user
    
    @staticmethod
    @static_method_decorator
    def validate_username(username):
        return len(username) >= 3 and username.isalnum()

# 메서드 데코레이터 사용
user = User("guest")
admin = User("admin", authenticated=True)

try:
    print(user.view_profile())  # PermissionError 발생
except PermissionError as e:
    print(f"오류: {e}")

print(admin.view_profile())  # admin의 프로필 정보

print(User.create_admin("superuser").is_admin)  # True

print(User.validate_username("user123"))  # True
print(User.validate_username("a"))  # False

✅ 특징:

인스턴스 메서드 장식
클래스 메서드 장식
정적 메서드 장식
접근 제어 구현
self/cls 매개변수 처리
상속 호환성
메서드 종류별 적용 방법

8️⃣ 데코레이터 디자인 패턴과 고급 기술

데코레이터 활용에 대한 고급 테크닉과 디자인 패턴이다.

import functools
import inspect
from typing import Callable, TypeVar, cast, Any

# 데코레이터 팩토리 패턴
class DecoratorFactory:
    @staticmethod
    def create_logging_decorator(log_level):
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kwargs):
                print(f"[{log_level}] 함수 호출: {func.__name__}")
                return func(*args, **kwargs)
            return wrapper
        return decorator

debug = DecoratorFactory.create_logging_decorator("DEBUG")
info = DecoratorFactory.create_logging_decorator("INFO")
warning = DecoratorFactory.create_logging_decorator("WARNING")

@debug
def test_function():
    return "테스트 완료"

# 데코레이터 합성 (Decorator Composition)
def compose_decorators(*decorators):
    def compose(f):
        for decorator in reversed(decorators):
            f = decorator(f)
        return f
    return compose

# 타입 힌트를 유지하는 데코레이터 (Python 3.10+)
T = TypeVar('T', bound=Callable[..., Any])

def preserves_signature(decorator: Callable[[T], Callable[..., Any]]) -> Callable[[T], T]:
    """데코레이터가 원본 함수의 타입 힌트를 유지하도록 한다"""
    @functools.wraps(decorator)
    def wrapped_decorator(func: T) -> T:
        decorated_func = decorator(func)
        return cast(T, decorated_func)
    return wrapped_decorator

@preserves_signature
def timing(func: T) -> Callable[..., Any]:
    @functools.wraps(func)
    def wrapper(*args: Any, **kwargs: Any) -> Any:
        import time
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"함수 {func.__name__} 실행 시간: {end - start:.4f}초")
        return result
    return wrapper

# 동적 데코레이터 생성
def create_validator(validation_func, error_message):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            if not validation_func(*args, **kwargs):
                raise ValueError(error_message)
            return func(*args, **kwargs)
        return wrapper
    return decorator

# 데코레이터 스택 검사
def get_decorator_stack(func):
    """함수에 적용된 데코레이터 스택을 분석한다"""
    result = []
    current = func
    while hasattr(current, '__wrapped__'):
        result.append(current.__name__)
        current = current.__wrapped__
    result.append(current.__name__)
    return result

# 메서드 체이닝을 위한 데코레이터
def chainable(func):
    @functools.wraps(func)
    def wrapper(self, *args, **kwargs):
        func(self, *args, **kwargs)
        return self
    return wrapper

# 사용 예시
class QueryBuilder:
    def __init__(self):
        self.filters = []
        self.sorts = []
    
    @chainable
    def filter(self, **kwargs):
        self.filters.append(kwargs)
    
    @chainable
    def sort_by(self, field, ascending=True):
        self.sorts.append((field, ascending))
    
    def execute(self):
        return f"Query with filters: {self.filters} and sorts: {self.sorts}"

query = (QueryBuilder()
         .filter(status="active")
         .filter(age__gt=18)
         .sort_by("created_at", ascending=False)
         .execute())

print(query)

✅ 특징:

데코레이터 팩토리 패턴
데코레이터 합성
타입 힌트 보존
동적 데코레이터 생성
데코레이터 스택 분석
메서드 체이닝 구현
고급 설계 기법

주요 팁

✅ 모범 사례:

functools.wraps 항상 사용하여 메타데이터(docstring, 이름, 서명) 보존
문서화 유지 및 데코레이터 자체에 docstring 추가
에러 처리 구현하여 명확한 오류 메시지 제공
성능 고려 (불필요한 오버헤드 피하기)
가독성 유지 (복잡한 데코레이터는 작은 단위로 분해)
테스트 작성 (데코레이터와 장식된 함수 모두 테스트)
재사용성 고려 (범용적 기능으로 설계)
타입 힌트와 호환성 유지
인자 없는 데코레이터와 인자 있는 데코레이터 구분 이해
데코레이터 단계별 디버깅 방법 숙지
클래스 기반과 함수 기반 데코레이터의 적절한 사용 상황 이해
과도한 데코레이터 중첩 피하기 (3-4개 이상 중첩 시 복잡도 증가)
필요한 경우 inspection 모듈로 함수 서명 분석

KR_Decorator - somaz94/python-study GitHub Wiki

Python 데코레이터 개념 정리

1️⃣ 데코레이터 기초

2️⃣ 매개변수가 있는 데코레이터

3️⃣ 데코레이터에 인자 전달

4️⃣ 클래스 데코레이터

5️⃣ 여러 데코레이터 사용

6️⃣ 실용적인 데코레이터 예제

7️⃣ 메서드 데코레이터

8️⃣ 데코레이터 디자인 패턴과 고급 기술

주요 팁

⚠️ GitHub.com Fallback ⚠️

KR_Decorator - somaz94/python-study GitHub Wiki

Python 데코레이터 개념 정리

1️⃣ 데코레이터 기초

2️⃣ 매개변수가 있는 데코레이터

3️⃣ 데코레이터에 인자 전달

4️⃣ 클래스 데코레이터

5️⃣ 여러 데코레이터 사용

6️⃣ 실용적인 데코레이터 예제

7️⃣ 메서드 데코레이터

8️⃣ 데코레이터 디자인 패턴과 고급 기술

주요 팁

⚠️ **GitHub.com Fallback** ⚠️

⚠️ GitHub.com Fallback ⚠️