파이썬은 데코레이터(decorator) 라는 기능을 제공한다. 데코레이터는 장식하는 도구 정도로 설명할 수 있다.

지금까지 클래스를 만들 때 @staticmethod, @classmethod, @abstractmethod 등을 붙였는데, 이렇게 @ 로 시작하는 것들을 데코레이터 라고 한다. 즉, 함수(메서드)를 장식한다고 해서 이와 같은 이름이 붙였다.

class Calc:
    @staticmethod    # 데코레이터
    def add(a, b):
        print(a + b)

이번 단원에서는 데코레이터를 만들고 사용하는 방법에 대해서 알아보자.

참고로 데코레이터는 장식자라고도 불리는데 여기에서는 데코레이터 라고 부르겠다.

1. 데코레이터 만들기

데코레이터는 함수를 장식한다고 했는데 도대체 어디에 사용하는 것일까? 데코레이터는 함수를 수정하지 않은 상태에서 추가 기능을 구현할 때 사용한다. 예를 들어서 함수의 시작과 끝을 출력하고 싶다면 함수의 시작과 끝 부분에 print 를 넣어야 한다.

def hello():
    print('hello 함수 시작')
    print('hello')
    print('hello 함수 끝')
 
def world():
    print('world 함수 시작')
    print('world')
    print('world 함수 끝')
 
hello()
world()

실행 결과

hello 함수 시작
hello
hello 함수 끝
world 함수 시작
world
world 함수 끝

다른 함수들도 위와 같이 함수의 시작과 끝을 출력하고 싶다면 모든 함수의 처음과 마지막에 print 를 넣어서 수정해줘야 한다. 그런데 만약 함수의 개수가 너무 많으면 매우 번거로워진다.

이런 경우에 데코레이터를 활용하면 편리하다. 다음은 함수의 시작과 끝을 출력하는 데코레이터이다.

def trace(func):                             # 호출할 함수를 매개변수로 받음
    def wrapper():                           # 호출할 함수를 감싸는 함수
        print(func.__name__, '함수 시작')    # __name__으로 함수 이름 출력
        func()                               # 매개변수로 받은 함수를 호출
        print(func.__name__, '함수 끝')
    return wrapper                           # wrapper 함수 반환
 
def hello():
    print('hello')
 
def world():
    print('world')
 
trace_hello = trace(hello)    # 데코레이터에 호출할 함수를 넣음
trace_hello()                 # 반환된 함수를 호출
trace_world = trace(world)    # 데코레이터에 호출할 함수를 넣음
trace_world()                 # 반환된 함수를 호출

실행 결과

hello 함수 시작
hello
hello 함수 끝
world 함수 시작
world
world 함수 끝

trace 라는 함수를 구현했는데 이 함수 안에서 wrapper 라는 함수를 구현했다. wrapper 에서 매개 변수로 받은 함수 func 의 __name__ 속성을 통해서 함수 이름을 출력하고 “함수 시작”을 출력해준다. 그리고 func() 와 같이 매개 변수로 받은 함수를 실행해준다. 그리고 마찬가지 방법으로 “함수 끝”을 출력한다.

@로 데코레이터 사용

이제 @ 를 이용하여 좀 더 간단한 데코레이터를 만들어보자. 다음과 같이 호출할 함수 앞에 @데코레이터 형식을 지정한다.

@데코레이터
def 함수이름():
    코드

def trace(func):                             # 호출할 함수를 매개변수로 받음
    def wrapper():
        print(func.__name__, '함수 시작')    # __name__으로 함수 이름 출력
        func()                               # 매개변수로 받은 함수를 호출
        print(func.__name__, '함수 끝')
    return wrapper                           # wrapper 함수 반환
 
@trace    # @데코레이터
def hello():
    print('hello')
 
@trace    # @데코레이터
def world():
    print('world')
 
hello()    # 함수를 그대로 호출
world()    # 함수를 그대로 호출

실행 결과

hello 함수 시작
hello
hello 함수 끝
world 함수 시작
world
world 함수 끝

hello 와 world 함수 앞에 @trace 를 붙인 뒤에 그대로 hello(), world() 와 같이 함수를 호출하면 끝이다.

@trace    # @데코레이터
def hello():
    print('hello')
 
@trace    # @데코레이터
def world():
    print('world')
 
hello()    # 함수를 그대로 호출
world()    # 함수를 그대로 호출

이와 같이 데코레이터는 함수를 감싸는 형태로 되어있다. 따라서 데코레이터는 기존의 함수를 수정하지 않은 상태에서 추가 기능을 구현할 때 사용한다.

% 데코레이터 여러 개 지정

함수에 데코레이터를 여러 개 지정해 줄 수 있다. 다음과 같이 함수 위에 데코레이터를 여러 줄로 지정해준다. 데코레이터가 실행되는 순서는 위에서 아래이다.

@데코레이터1
@데코레이터2
def 함수이름():
    코드

def decorator1(func):
    def wrapper():
        print('decorator1')
        func()
    return wrapper
 
def decorator2(func):
    def wrapper():
        print('decorator2')
        func()
    return wrapper
 
# 데코레이터를 여러 개 지정
@decorator1
@decorator2
def hello():
    print('hello')
 
hello()

실행 결과

decorator1
decorator2
hello

@ 를 사용하지 않았을 때의 코드는 다음과 같다.

decorated_hello = decorator1(decorator2(hello))
decorated_hello()

2. 매개 변수의 반환값을 처리하는 데코레이터

지금까지는 매개 변수와 반환값이 없는 함수의 데코레이터를 만들었다. 이번에는 매개 변수와 반환값이 있는 함수의 데코레이터를 만들어보자.

다음은 함수의 매개 변수와 반환값을 출력하는 데코레이터이다.

def trace(func):          # 호출할 함수를 매개변수로 받음
    def wrapper(a, b):    # 호출할 함수 add(a, b)의 매개변수와 똑같이 지정
        r = func(a, b)    # func에 매개변수 a, b를 넣어서 호출하고 반환값을 변수에 저장
        print('{0}(a={1}, b={2}) -> {3}'.format(func.__name__, a, b, r))  # 매개변수와 반환값 출력
        return r          # func의 반환값을 반환
    return wrapper        # wrapper 함수 반환
 
@trace              # @데코레이터
def add(a, b):      # 매개변수는 두 개
    return a + b    # 매개변수 두 개를 더해서 반환
 
print(add(10, 20))

실행 결과

add(a=10, b=20) -> 30
30

add 함수를 호출했을 때 데코레이터를 통해서 매개변수와 반환값을 출력하였다. 매개변수와 반환값을 처리하는 데코레이터를 만들 때에는 먼저 안쪽 함수 wrapper 함수의 매개변수를 호출할 함수 add(a, b) 의 매개변수와 똑같이 만들어준다.

def trace(func):          # 호출할 함수를 매개변수로 받음
    def wrapper(a, b):    # 호출할 함수 add(a, b)의 매개변수와 똑같이 지정

가변 인수 함수 데코레이터

앞서 봤던 add(a, b) 함수는 매개변수의 개수가 고정되어 있었던 함수이다. 그러면 매개변수(인수)의 개수가 고정되어 있지 않은 함수는 어떻게 처리할까? 이럴 때는 wrapper 함수를 가변 인수 함수로 만들면 된다.

def trace(func):                     # 호출할 함수를 매개변수로 받음
    def wrapper(*args, **kwargs):    # 가변 인수 함수로 만듦
        r = func(*args, **kwargs)    # func에 args, kwargs를 언패킹하여 넣어줌
        print('{0}(args={1}, kwargs={2}) -> {3}'.format(func.__name__, args, kwargs, r))
                                     # 매개변수와 반환값 출력
        return r                     # func의 반환값을 반환
    return wrapper                   # wrapper 함수 반환
 
@trace                   # @데코레이터
def get_max(*args):      # 위치 인수를 사용하는 가변 인수 함수
    return max(args)
 
@trace                   # @데코레이터
def get_min(**kwargs):   # 키워드 인수를 사용하는 가변 인수 함수
    return min(kwargs.values())
 
print(get_max(10, 20))
print(get_min(x=10, y=20, z=30))

실행 결과

get_max(args=(10, 20), kwargs={}) -> 20
20
get_min(args=(), kwargs={'x': 10, 'y': 20, 'z': 30}) -> 10
10

get_max, get_min 함수 둘다 가변 인수 함수이다. 따라서 데코레이터도 가변 인수 함수로 만들어준다 이때, 위치 인수, 키워드 인수 둘 다 받을 수 있도록 *args 와 **kwargs 둘 다 지정해준다.

def trace(func):                     # 호출할 함수를 매개변수로 받음
    def wrapper(*args, **kwargs):    # 가변 인수 함수로 만듦

wrapper 함수 안에서 func 함수를 호출해주는데 args 는 튜플이고 kwargs 는 딕셔너리이므로 func 함수에 넣을 때 언패킹 하여 넣어준다.

def trace(func):                     # 호출할 함수를 매개변수로 받음
    def wrapper(*args, **kwargs):    # 가변 인수 함수로 만듦
        r = func(*args, **kwargs)    # func에 args, kwargs를 언패킹하여 넣어줌
        print('{0}(args={1}, kwargs={2}) -> {3}'.format(func.__name__, args, kwargs, r))
                                     # 매개변수와 반환값 출력
        return r                     # func의 반환값을 반환
    return wrapper                   # wrapper 함수 반환

이렇게 만든 데코레이터 trace 는 위치 인수와 키워드 인수 모두 처리할 수 있다 따라서 가변 인수 함수 뿐만 아니라 일반 함수에도 사용할 수 있다.

>>> @trace
... def add(a, b):
...    return a + b
...
>>> add(10, 20)
add(args=(10, 20), kwargs={}) -> 30
30

% 클래스에 데코레이터

클래스를 만들면서 메서드에 데코레이터를 사용할 때에는 self 를 주의해야 한다. 인스턴스 메서드는 항상 첫번째 인수로 self 를 받기 때문에 데코레이터를 만들 때에도 wapper 함수의 첫번째 인수로 self 를 지정해야한다(클래스 메서드는 cls). 마찬가지로 func 함수를 호출할 때에도 self 와 매개변수 그대로 넣어야 한다.

def trace(func):
    def wrapper(self, a, b):   # 호출할 함수가 인스턴스 메서드이므로 첫 번째 매개변수는 self로 지정
        r = func(self, a, b)   # self와 매개변수를 그대로 넣어줌
        print('{0}(a={1}, b={2}) -> {3}'.format(func.__name__, a, b, r))   # 매개변수와 반환값 출력
        return r               # func의 반환값을 반환
    return wrapper
 
class Calc:
    @trace
    def add(self, a, b):    # add는 인스턴스 메서드
        return a + b
 
c = Calc()
print(c.add(10, 20))

실행 결과

add(a=10, b=20) -> 30
30

3. 매개변수가 있는 데코레이터

이번에는 매개변수가 있는 데코레이터에 대해서 알아보자 이런 방식의 데코레이터는 값을 지정해서 동작을 바꿀 수 있다. 다음은 특정 수의 배수인지 확인하는 데코레이터이다.

def is_multiple(x):              # 데코레이터가 사용할 매개변수를 지정
    def real_decorator(func):    # 호출할 함수를 매개변수로 받음
        def wrapper(a, b):       # 호출할 함수의 매개변수와 똑같이 지정
            r = func(a, b)       # func를 호출하고 반환값을 변수에 저장
            if r % x == 0:       # func의 반환값이 x의 배수인지 확인
                print('{0}의 반환값은 {1}의 배수입니다.'.format(func.__name__, x))
            else:
                print('{0}의 반환값은 {1}의 배수가 아닙니다.'.format(func.__name__, x))
            return r             # func의 반환값을 반환
        return wrapper           # wrapper 함수 반환
    return real_decorator        # real_decorator 함수 반환
 
@is_multiple(3)     # @데코레이터(인수)
def add(a, b):
    return a + b
 
print(add(10, 20))
print(add(2, 5))

실행 결과

add의 반환값은 3의 배수입니다.
30
add의 반환값은 3의 배수가 아닙니다.
7

지금까지 데코레이터를 만들 때 함수 하나 만 만들었다. 그러나 매개변수가 있는 데코레이터를 만들기 위해서는 함수를 하나 더 만들어야 한다. 먼저 is_multiple 이라는 함수를 만들고 데코레이터가 사용될 매개변수 x 를 지정한다. 그리고 is_multiple 함수 안에서 실제 데코레이터 역할을 하는 real_decorator 를 만든다. 즉, 이 함수에서 호출될 함수를 매개변수로 받는다. 그 다음 real_decorator 안에 wrapper 함수를 만든다.

4. 클래스로 데코레이터 만들기

이번에는 클래스로 데코레이터를 만드는 방법에 대해서 알아보자. 특히 클래스에서 데코레이터를 활용할 때에는 인스턴스를 함수처럼 호출하게 해주는 __call__ 메서드를 구현해야한다.

다음은 함수의 시작과 끝을 알려주는 데코레이터이다.

class Trace:
    def __init__(self, func):    # 호출할 함수를 인스턴스의 초깃값으로 받음
        self.func = func         # 호출할 함수를 속성 func에 저장
 
    def __call__(self):
        print(self.func.__name__, '함수 시작')    # __name__으로 함수 이름 출력
        self.func()                               # 속성 func에 저장된 함수를 호출
        print(self.func.__name__, '함수 끝')
 
@Trace    # @데코레이터
def hello():
    print('hello')
 
hello()    # 함수를 그대로 호출

실행 결과

hello 함수 시작
hello
hello 함수 끝

클래스로 데코레이터를 만들 때에는 먼저 __init__ 메서드를 만들고 호출할 함수를 인자로 만든다. 그리고 매개변수로 받은 함수를 함수의 속성으로 저장한다.

class Trace:
    def __init__(self, func):    # 호출할 함수를 인스턴스의 초깃값으로 받음
        self.func = func         # 호출할 함수를 속성 func에 저장

이제 인스턴스를 호출할 수 있도록 __call__ 메서드를 만든다. 그리고 함수의 시작과 끝에 문자열이 출력되도록 하고 그 중간에 속성 func 에 저장된 함수도 호출한다.

def __call__(self):
        print(self.func.__name__, '함수 시작')    # __name__으로 함수 이름 출력
        self.func()                               # 속성 func에 저장된 함수를 호출
        print(self.func.__name__, '함수 끝')

데코레이터를 사용하는 방식은 클로저 형태의 데코레이터와 같다. 호출할 함수 위에 @ 를 붙이고 데코레이터를 지정하면 된다.

@데코레이터
def 함수이름():
    코드

@Trace    # @데코레이터
def hello():
    print('hello')

@ 로 데코레이터를 지정했으므로 함수는 그대로 호출해주면 된다.

hello()    # 함수를 그대로 호출

참고로 클래스로 만든 데코레이터는 @ 을 지정하지 않고 데코레이터의 반환값을 호출하는 방식으로도 사용할 수 있다. 다음과 같이 데코레이터로 호출할 함수를 넣어서 인스턴스를 생성한 뒤에 인스턴스를 호출해주면 된다. 즉, 클래스에 __call__ 메서드를 정의했으므로 함수처럼 ()괄호를 붙여서 호출할 수 있습니다.

def hello():    # @데코레이터를 지정하지 않음
    print('hello')
 
trace_hello = Trace(hello)    # 데코레이터에 호출할 함수를 넣어서 인스턴스 생성
trace_hello()                 # 인스턴스를 호출. __call__ 메서드가 호출됨

5. 클래스로 매개변수, 반환값 처리 데코레이터 만들

지금까지 클래스로 데코레이터를 만들었다. 클래스로 만든 데코레이터도 매개변수와 반환값을 처리할 수 있다. 다음은 매개변수와 반환값을 출력하는 데코레이터이다(여기서 위치 인수와 키워드 인수를 모두 처리하는 가변 인수로 만들었다).

class Trace:
    def __init__(self, func):    # 호출할 함수를 인스턴스의 초깃값으로 받음
        self.func = func         # 호출할 함수를 속성 func에 저장
 
    def __call__(self, *args, **kwargs):    # 호출할 함수의 매개변수를 처리
        r = self.func(*args, **kwargs) # self.func에 매개변수를 넣어서 호출하고 반환값을 변수에 저장
        print('{0}(args={1}, kwargs={2}) -> {3}'.format(self.func.__name__, args, kwargs, r))
                                            # 매개변수와 반환값 출력
        return r                            # self.func의 반환값을 반환
 
@Trace    # @데코레이터
def add(a, b):
    return a + b
 
print(add(10, 20))
print(add(a=10, b=20))

실행 결과

add(args=(10, 20), kwargs={}) -> 30
30
add(args=(), kwargs={'a': 10, 'b': 20}) -> 30
30

클래스로 매개변수와 반환값을 처리하는 데코레이터를 만들 때에는 __call__ 메서드에 매개변수를 지정하고, self.func 에 매개변수를 넣어서 호출한 뒤에 반환값을 반환해주면 된다. 여기서 매개변수로 *args, **kwargs 를 지정했으므로 언패킹해서 넣어주면 된다.

def __call__(self, *args, **kwargs):    # 호출할 함수의 매개변수를 처리
        r = self.func(*args, **kwargs) # self.func에 매개변수를 넣어서 호출하고 반환값을 변수에 저장
        print('{0}(args={1}, kwargs={2}) -> {3}'.format(self.func.__name__, args, kwargs, r))
                                            # 매개변수와 반환값 출력
        return r                            # self.func의 반환값을 반환

물론 가변인수를 사용하지 않고 고정된 매개변수를 사용할 때에는 def __call__(self, a, b): 처럼 만들면 된다.

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

이번에는 매개변수가 있는 데코레이터를 만들어보자. 다음은 함수의 반환값이 특정 수의 배수인지를 확인하는 데코레이터이다.

class IsMultiple:
    def __init__(self, x):         # 데코레이터가 사용할 매개변수를 초깃값으로 받음
        self.x = x                 # 매개변수를 속성 x에 저장
 
    def __call__(self, func):      # 호출할 함수를 매개변수로 받음
        def wrapper(a, b):         # 호출할 함수의 매개변수와 똑같이 지정(가변 인수로 작성해도 됨)
            r = func(a, b)         # func를 호출하고 반환값을 변수에 저장
            if r % self.x == 0:    # func의 반환값이 self.x의 배수인지 확인
                print('{0}의 반환값은 {1}의 배수입니다.'.format(func.__name__, self.x))
            else:
                print('{0}의 반환값은 {1}의 배수가 아닙니다.'.format(func.__name__, self.x))
            return r               # func의 반환값을 반환
        return wrapper             # wrapper 함수 반환
 
@IsMultiple(3)    # 데코레이터(인수)
def add(a, b):
    return a + b
 
print(add(10, 20))
print(add(2, 5))

실행 결과

add의 반환값은 3의 배수입니다.
30
add의 반환값은 3의 배수가 아닙니다.
7

먼저 __init__ 메서드에서 데코레이터가 사용할 매개변수를 초기값으로 받는다. 그리고 매개변수를 call 메서드에서 사용할 수 있게 속성으로 지정한다.

def __init__(self, x):         # 데코레이터가 사용할 매개변수를 초깃값으로 받음
        self.x = x                 # 매개변수를 속성 x에 저장

지금까지 호출할 함수를 __init__ 에서 매개변수로 받았는데 여기에서는 데코레이터가 사용할 매개변수를 받는 점을 기억하자.

이제 __call__ 메서드에서 매개변수로 호출할 함수를 받는다. 그리고 __call__ 메서드 안에서 wrapper 함수를 만들어준다. 이때 이 함수의 매개변수는 호출할 함수의 매개변수와 동일하게 만든다(가변 인수로 만들어도 된다).

def __call__(self, func):      # 호출할 함수를 매개변수로 받음
        def wrapper(a, b):         # 호출할 함수의 매개변수와 똑같이 지정(가변 인수로 작성해도 됨)

그리고 wrapper 함수 안에서 func 함수의 반환값이 데코레이터의 매개변수로 받은 x 의 배수인지를 확인한다. 이때 대코레이터의 매개변수로 받은 x 는 속성에 저장되어 있으므로 self.x 와 같이 사용된다. 마지막으로 함수를 다 만들었으면 wapper 함수를 반환한다.

def __call__(self, func):      # 호출할 함수를 매개변수로 받음
        def wrapper(a, b):         # 호출할 함수의 매개변수와 똑같이 지정(가변 인수로 작성해도 됨)
            r = func(a, b)         # func를 호출하고 반환값을 변수에 저장
            if r % self.x == 0:    # func의 반환값이 self.x의 배수인지 확인
                print('{0}의 반환값은 {1}의 배수입니다.'.format(func.__name__, self.x))
            else:
                print('{0}의 반환값은 {1}의 배수가 아닙니다.'.format(func.__name__, self.x))
            return r               # func의 반환값을 반환
        return wrapper             # wrapper 함수 반환

💡 지금까지 데코레이터를 사용하는 방법을 배웠는데 문법이 조금 복잡했습니다. 여기서는 데코레이터가 기존 함수를 수정하지 않으면서 추가 기능을 구현할 때 사용한다는 점만 기억하면 됩니다. 보통 데코레이터는 프로그램의 버그를 찾는 디버깅, 함수의 성능 측정, 함수 실행 전에 데이터 확인 등에 활용합니다(앞에서 만든 함수의 시작과 끝을 출력하는 데코레이터, 매개변수와 반환값을 출력하는 데코레이터는 디버깅에 활용할 수 있습니다. 그리고 함수 실행 전에 데이터를 확인하는 예제는 연습문제에서 소개하겠습니다).