Python 데코레이터: 종합 가이드

Python으로 프로그래밍을 시작했을 당시 버전은 3.3이었습니다. 그래서 제가 프로그래밍을 시작했을 때 Python 커뮤니티에는 데코레이터가 오랫동안 존재해 있었습니다.

함수 데코레이터는 Python 버전 2.2에, 클래스 데코레이터는 Python 버전 2.6에 나왔습니다.

개인적으로 Python의 Decorator 기능은 Python의 매우 강력한 기능이라고 생각합니다.

사실 제 목표는 Python에서 가장 이해하기 어려운 주제에 대한 일련의 기사를 만드는 것입니다. 10개가 조금 넘는 주제를 하나씩 다루려고 합니다.

이 글에서는 데코레이터 주제의 모든 부분을 최대한 다루려고 노력하겠습니다.

1. 역사적 맥락

• 초기(Python 2.2 이전): 데코레이터 이전에는 함수나 클래스를 수정하는 데 수동 래핑이나 원숭이 패치가 필요한 경우가 많았는데, 이는 번거롭고 가독성이 낮았습니다.
• 메타클래스(Python 2.2): 메타클래스는 클래스 생성을 제어하는 ​​방법을 제공하여 나중에 데코레이터가 제공할 기능 중 일부를 제공했지만 간단한 수정에는 복잡했습니다.
• PEP 318(Python 2.4): 데코레이터는 PEP 318을 통해 Python 2.4에서 공식적으로 도입되었습니다. 이 제안은 Java의 주석에서 영감을 얻었으며 함수와 메서드를 수정하는 더 깔끔하고 선언적인 방법을 제공하는 것을 목표로 했습니다. .
• 클래스 데코레이터(Python 2.6): Python 2.6은 클래스에 대한 데코레이터 지원을 확장하여 다양성을 더욱 향상시켰습니다.
• 광범위한 채택: 데코레이터는 빠르게 인기 있는 기능이 되었으며 라우팅, 인증 등을 위해 Flask 및 Django와 같은 프레임워크에서 광범위하게 사용되었습니다.

2. 데코레이터란 무엇입니까?

기본적으로 데코레이터는 핵심 구조를 변경하지 않고도 함수나 클래스의 동작을 수정할 수 있는 Python의 디자인 패턴입니다. 데코레이터는 기본적으로 다른 코드를 조작하는 코드를 작성하는 메타프로그래밍의 한 형태입니다.

Python은 아래 순서대로 주어진 범위를 사용하여 이름을 확인합니다.

1. 로컬
2. 동봉
3. 글로벌
4. 내장

데코레이터는 Closure 개념과 밀접한 관련이 있는 Enclosing Scope에 위치합니다.

핵심 아이디어: 데코레이터는 함수를 입력으로 사용하고 여기에 일부 기능을 추가한 후 수정된 함수를 반환합니다.

비유: 데코레이터를 선물 포장지로 생각해보세요. 선물(원래 기능)이 있고 장식용 종이(장식자)로 포장하여 더 멋지게 보이거나 추가 기능(예: 활이나 카드)을 추가합니다. 안에 들어 있는 선물은 동일하게 유지되지만 표시나 관련 동작이 향상됩니다.

A) 데코레이터 변형: 함수 기반 vs. 클래스 기반

Python의 대부분의 데코레이터는 함수를 사용하여 구현되지만 클래스를 사용하여 데코레이터를 만들 수도 있습니다.
함수 기반 데코레이터는 더 일반적이고 단순하지만 클래스 기반 데코레이터는 추가적인 유연성을 제공합니다.

함수 기반 기본 데코레이터 구문

def my_decorator(func):
    def wrapper(*args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

설명:

• my_ decorator는 데코레이터 함수입니다. 입력으로 장식하려면 func 함수가 필요합니다.
• 래퍼는 원래 함수의 호출을 래핑하는 내부 함수입니다. 원래 함수 전후에 코드를 실행할 수 있습니다.
• @my_decator는 데코레이터 구문입니다. say_hello = my_designator(say_hello)와 동일합니다.

클래스 기반 기본 데코레이터 구문

데코레이터를 정의하기 위해 함수 대신 클래스를 사용합니다.

class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = self.func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result

@MyDecorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

설명:

• MyDecorator는 데코레이터 역할을 하는 클래스입니다.
• __init__ 메소드는 장식할 함수를 저장합니다.
• __call__ 메소드는 클래스 인스턴스를 호출 가능하게 만들어 함수처럼 사용할 수 있게 해줍니다.

---

나) 간단한 데코레이터 구현

데코레이터의 기본 개념은 다른 함수를 인수로 취하고 이를 명시적으로 수정하지 않고 해당 동작을 확장하는 함수라는 것입니다.
가장 간단한 형식은 다음과 같습니다.

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

# Using the decorator with @ syntax
@my_decorator
def say_hello():
    print("Hello!")

# When we call say_hello()
say_hello()

# This is equivalent to:
# say_hello = my_decorator(say_hello)

C) 인수를 사용하여 데코레이터 구현

함수 실행 시간을 기록하는 데코레이터를 만들어 보겠습니다.

def decorator_with_args(func):
    def wrapper(*args, **kwargs):    # Accept any number of arguments
        print(f"Arguments received: {args}, {kwargs}")
        return func(*args, **kwargs)  # Pass arguments to the original function
    return wrapper

@decorator_with_args
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice", greeting="Hi")  # Prints arguments then "Hi, Alice!"

D) 매개변수화된 데코레이터 구현

다음은 자체 매개변수를 받을 수 있는 데코레이터입니다.

def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(times=3)
def greet(name):
    print(f"Hello {name}")
    return "Done"

greet("Bob")  # Prints "Hello Bob" three times

E) 클래스 데코레이터 구현

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 DatabaseConnection:
    def __init__(self):
        print("Initializing database connection")

# Creating multiple instances actually returns the same instance
db1 = DatabaseConnection()  # Prints initialization
db2 = DatabaseConnection()  # No initialization printed
print(db1 is db2)  # True

F) 메소드 데코레이터 구현

수업 방법을 위해 특별히 고안된 것입니다.

def debug_method(func):
    def wrapper(self, *args, **kwargs):
        print(f"Calling method {func.__name__} of {self.__class__.__name__}")
        return func(self, *args, **kwargs)
    return wrapper

class MyClass:
    @debug_method
    def my_method(self, x, y):
        return x + y

obj = MyClass()
print(obj.my_method(5, 3))

G) 데코레이터 체이닝 구현

단일 함수에 여러 데코레이터를 적용할 수 있습니다.

def bold(func):
    def wrapper():
        return "<b>" + func() + "</b>"
    return wrapper

def italic(func):
    def wrapper():
        return "<i>" + func() + "</i>"
    return wrapper

@bold
@italic
def greet():
    return "Hello!"

print(greet())  # Outputs: <b><i>Hello!</i></b>

설명:

• 데코레이터는 아래에서 위로 적용됩니다.
• 이는 수학에서 f(g(x))와 더 유사합니다.
• 이탤릭체를 먼저 적용한 다음 볼드체를 적용합니다.

H) @functools.wraps 를 사용하지 않으면 어떻게 되나요?

functools.wraps 데코레이터인 See docs는 데코레이터로 래핑할 때 원래 함수의 메타데이터(예: 이름, 독스트링, 서명)를 보존하는 도우미 함수입니다. 사용하지 않으면 중요한 정보를 잃게 됩니다.

예:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        """Wrapper docstring"""
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def my_function():
    """My function docstring"""
    pass

print(my_function.__name__)
print(my_function.__doc__)

출력:

wrapper
Wrapper docstring

문제:

• 원래 함수의 이름(my_function)과 독스트링("My function docstring")은 손실됩니다.
• 이로 인해 디버깅과 자체 조사가 어려워질 수 있습니다.

해결책: functools.wraps 사용):

def my_decorator(func):
    def wrapper(*args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

출력:

class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = self.func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result

@MyDecorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

functools.wraps의 장점:

• 함수 메타데이터를 보존합니다.
• 코드 가독성과 유지 관리성이 향상됩니다.
• 디버깅이 더 쉬워집니다.
• 자체 검사 도구 및 문서 생성기에 도움이 됩니다.

I) 상태가 있는 데코레이터

데코레이터는 함수 호출 사이에도 상태를 유지할 수 있습니다. 이는 함수 호출 캐싱 또는 계산과 같은 시나리오에 특히 유용합니다.

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

# Using the decorator with @ syntax
@my_decorator
def say_hello():
    print("Hello!")

# When we call say_hello()
say_hello()

# This is equivalent to:
# say_hello = my_decorator(say_hello)

출력:

def decorator_with_args(func):
    def wrapper(*args, **kwargs):    # Accept any number of arguments
        print(f"Arguments received: {args}, {kwargs}")
        return func(*args, **kwargs)  # Pass arguments to the original function
    return wrapper

@decorator_with_args
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice", greeting="Hi")  # Prints arguments then "Hi, Alice!"

설명:

래퍼 함수는 장식된 함수가 호출될 때마다 증가하는 카운터(호출)를 유지합니다.
이는 데코레이터를 사용하여 상태를 유지하는 방법에 대한 간단한 예입니다.

J) Python 데코레이터 모범 사례

• functools.wraps 사용: 원래 함수의 메타데이터를 보존하려면 데코레이터에서 항상 @functools.wraps를 사용하세요.
• 데코레이터를 단순하게 유지하세요: 데코레이터는 이상적으로 한 가지 특정 작업을 잘 수행해야 합니다. 이렇게 하면 재사용이 가능하고 이해하기 쉬워집니다.
• 데코레이터 문서화: 데코레이터가 수행하는 작업, 인수, 반환 내용을 설명하세요.
• 데코레이터 테스트: 데코레이터가 다양한 시나리오에서 예상대로 작동하는지 확인하기 위한 단위 테스트를 작성하세요.
• 연결 순서 고려: 여러 데코레이터를 연결하는 경우 실행 흐름에 영향을 미치므로 순서에 주의하세요.

K) 잘못된 구현(안티패턴)

• 과도하게 복잡한 데코레이터: 너무 복잡하거나 너무 많은 작업을 수행하는 데코레이터를 만들지 마세요. 이로 인해 이해, 유지 관리 및 디버깅이 어려워집니다.
• functools.wraps 무시: @functools.wraps 사용을 잊어버리면 함수 메타데이터가 손실되어 자체 검사 및 디버깅에 문제가 발생할 수 있습니다.
• 부작용: 데코레이터는 데코레이트된 기능을 수정하는 것 외에는 의도하지 않은 부작용이 없어야 합니다.
• 값 하드코딩: 데코레이터 내에서 값을 하드코딩하지 마세요. 대신 데코레이터 팩토리를 사용하여 구성 가능하게 만드세요.
• 인수를 제대로 처리하지 않음: 데코레이터를 다양한 기능과 함께 사용하려는 경우 래퍼 함수가 *args 및 **kwargs를 사용하여 원하는 수의 위치 및 키워드 인수를 처리할 수 있는지 확인하세요.

L) 10. 실제 사용 사례

• 로깅: 디버깅 또는 감사를 위해 함수 호출, 인수 및 반환 값을 기록합니다.
• 타이밍: 성능 분석을 위한 함수 실행 시간을 측정합니다.
• 캐싱: 중복 계산(메모이제이션)을 피하기 위해 비용이 많이 드는 함수 호출의 결과를 저장합니다.
• 인증 및 승인: 기능을 실행하기 전에 사용자 자격 증명이나 권한을 확인합니다.
• 입력 유효성 검사: 함수에 전달된 인수가 특정 기준을 충족하는지 확인합니다.
• 속도 제한: 특정 기간 내에 함수를 호출할 수 있는 횟수를 제어합니다.
• 재시도 논리: 일시적 오류로 인해 함수 호출이 실패한 경우 자동으로 함수 호출을 재시도합니다.
• 프레임워크별 작업: Flask 및 Django와 같은 프레임워크는 라우팅(URL을 함수에 매핑), 플러그인 등록 등을 위해 데코레이터를 사용합니다.

M) 선별된 Python 데코레이터 목록

아래에서 선별된 Python 데코레이터 목록을 찾을 수 있습니다.

• 멋진 Python 데코레이터
• 파이썬 데코레이터 라이브러리

엔) 11. 결론

데코레이터는 깔끔하고 선언적인 방식으로 함수와 클래스를 향상시킬 수 있는 Python의 강력하고 우아한 기능입니다.
원칙, 모범 사례 및 잠재적인 함정을 이해함으로써 데코레이터를 효과적으로 활용하여 보다 모듈화되고 유지 관리 가능하며 표현력이 풍부한 코드를 작성할 수 있습니다.
특히 프레임워크를 사용하거나 재사용 가능한 구성 요소를 구축할 때 Python 프로그래머의 무기고에 있는 귀중한 도구입니다.

위 내용은 Python 데코레이터: 종합 가이드의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!