Python Decorator💅 - 1

---

최근에 예전에 짠 회사 코드를 정리하면서 중복되는 코드를 데코레이터로 정리해 보았습니다.
나쁘지 않은 방법인듯 하여 데코레이터를 주제로 글을 쓰게 되었습니당
괜히 쓰면 있어보이는(저는 그랬습니다🤪) 데코레이터를 알아보아요

만약 제 글이 안 읽히거나 부족하거나 별로임! 아무튼 별로임! 이라면 아래 좋은 글들로 눈 정화를 부탁드립니다 😭
<제가 Decorator를 공부할 때 참고했었던 글 목록입니다! 읽고 이해 되셨다면 이 글로 다시 돌아오지 않으셔도 됩니다 :)>

• SchoolOfWeb
• 아브의 꿀오분 / Python, Decorator 써본 이야기
• Real Python
• Python Wiki
• PEP 318

데코레이터는 필요에 따라 다양하게 작성하고 활용할 수 있어서 아래 주제로 나누어 다뤄보고자 합니다

1. 데코레이터를 이해하기 위한 사전 지식과, 함수로 만든 데코레이터와 그 사용 방법
2. 클래스로 만든 데코레이터, 인자를 받을 수 있는 데코레이터, 중첩된 데코레이터의 실행 순서

이번에는 데코레이터를 이해하기 위한 사전 지식과, 함수로 만든 데코레이터와 그 사용 방법 에 대해 알아보겠습니다

Prerequisite

---

데코레이터라는 주제를 넘어가는 개념에 대한 설명은 어느정도는 생략하도록 하겠습니다
근데, 이런 개념들을 몰라도 그냥 써보고 고치고 하면서 배우는거 아닐까요…?
(저는 멍청해서 작년부터 열심히 삽질하고 올해가 되어서야 어느 정도 이해했습니다!)

알고 계시면 이해에 더욱 도움되는 것들

• [Closure](https://en.wikipedia.org/wiki/Closure_(computer_programming)
  • 혹시 자바스크립트를 좋아하시면 (자바스크립트는 좋은 블로그가 참 많은거 같아요)
    • fun fun functions - closure
    • zerocho님 블로그 - 실행 컨텍스트와 클로저
    • hyunseob - daily engineering - Javascript 클로저
    • poiemaweb - closure
• First class citizen
• *args와 **kwargs
• functools.wraps
• __call__()
• callable()
• partial function application
• LEGB Scope

Decorator 기본 개념

---

헤드 퍼스트 디자인 패턴 책의 Decorator Pattern 예제로
카페의 음료 기본 단위인 에스프레소와, 우유, 물에 첨가물을 늘려가며
새로운 객체(라떼, 카푸치노 카라멜 마키아또 등)를 생성해내는(책임을 확장하는) 비유가 있습니다.

데코레이터를 이용해, 반복을 줄이고 메소드나 함수의 책임을 확장한다는 면에서는 어느정도 비슷하다고 생각이 듭니다.
(자바의 Annotation 과 생김새는 유사하지만 하는 일은 다릅니당)

아무튼 요약하자면
파이썬의 데코레이터를 한 단어로 정리하자면, 클로저 입니다
좀 더 풀어서 이야기 하면, 클로저의 축약문법 입니다.

Closure

---

데코레이터의 본질은 클로저입니다. 이미 알고 계시다면 과감하게 더 이상 읽지 않으셔도 됩니다!
클로저가 뭐냐 하면 함수에 함수인거임ㅋㅋㅋ엌ㅋㅋㅋㅋ
죄송합니다… 아래 코드를 보시져

# 하스스톤의 안녕로봇
def annoy_o_tron(message):
    # 안녕로봇이 인사할 수 있도록 해주는 내부 구현
    def greeting(name):
      print(f'{message} - {name}!')
    return greeting

    # annoy_o_tron 함수의 반환값은 def greeting(name): print(...) 입니다
    # print(f'Hello - {name}') 함수를 값처럼 가지고 있는 상태라고 할 수 있겠네요
    hello_o_tron = annoy_o_tron('Hello')

    # print('Hello - Doondoony!') 함수를 호출합니다
    hello_o_tron('Doondoony') # Hello - Doondoony!
    hello_o_tron('velog') # Hello - velog!

annoy_o_tron 함수는 message 를 인자로 받은 뒤
다음에 이름을 받을 수 있는 함수인 greeting 함수를 반환합니다.

근데 greeting 함수의 print(f'{message} - {name}!') 문에서
message 변수는 greeting 안에 없는데 어떻게 'Hello'를 출력할 수 있을까요?

그건 greeting 함수가 선언되는 시점에 message 라는 변수를 찾을때
LEGB 순서 (Local, Enclosing, Global, Built-in) 에 따라 탐색하기 때문입니다!
(자바스크립트에서는 { } 가 각각의 스코프를 갖지만, 파이썬에서는 LEGB만 네임스페이스를 가질 수 있습니다)

위 코드에서 def가 몇 번 중첩되어 있더라도 계속해서 부모의 부모의 부모의… 함수가 가지는 scope(enclosing)를 탐색할 수 있기 때문에
message 변수가 LEGB안에 존재한다면 찾아 냅니다 (코드 내에 message 변수가 없으면 에러가 발생하겠죠!)

이처럼 **message의 값을 기억하고 호출할 때 항상 같은 message 값으로 실행되는 환경을 기억하는 함수를
클로저라고 할 수 있습니당

데코레이터의 종류 - 누가 데코레이터가 될 수 있나요?

---

본질적으로는 callable한 객체는 데코레이터로써 사용 가능합니다
다만 각각의 세부 구현은 다릅니당
(함수라면 클로저 형태로 짜여 있어야 하겠죠!)

callable 한 객체라고 하면 막막하니까 조금 정리해보자면
1. 함수 데코레이터
2. 클래스 데코레이터

그리고 1번 2번 모두 미리 정의된 인자를 받을 수 있는 데코레이터가 될 수도 있습니다! (이건 다음번에)

데코레이터의 종류 - 예시

---

함수가 실행될 때 마다 그 결과를 출력해주는 logger라는 데코레이터를 작성한다고 가정하겠습니다
아직 이해가 되지 않으신다면, 그냥 데코레이터 역할을 할 함수는 대충 이렇게 생겼겠구나 하시면 되겠습니다 😘

• 함수를 데코레이터로 사용할 경우

  def logger(func):
      def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        print(f'Result: {result}')
        return result
    return wrapper

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

  result = add(20, 22) # Result: 42
  print(result) # 42

• 클래스를 데코레이터로 사용할 경우

  class Logger(object):
      def __init__(self, func):
          self.func = func

      def __call__(self, *args, **kwargs):
          result = self.func(*args, **kwargs)
          print(f'Result: {result}')
          return result

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

  result = add(20, 22) # Result: 42
  print(result) # 42

• 람다 표현식 활용해 데코레이터로 사용할 경우
  람다 표현식은 값으로 평가 되기 때문에, print문을 사용한다면, 반환 되는 값을 지정하기가 조금 지저분해 집니다

  logger = lambda fn: lambda *args, **kwargs: print(f'Result: {fn(*args, **kwargs)}')
        
  @logger
  def add(a, b):
      return a + b
        
  result = add(20, 22) # Result: 42
  print(result) # None...

굳이 값을 반환하고 싶으시다면... 아래와 같이 할 수 있을거 같아요 (더 좋은 방법이 있다면 알려주세요!)

  logger = lambda fn: lambda *args, **kwargs: (print(f'Result: {fn(*args, **kwargs)}'), fn(*args, **kwargs))[1] # 함수 실행 결과만 반환, print는 그대로 실행
        
  @logger
  def add(a, b):
      return a + b
        
  result = add(20, 22) # Result: 42
  print(result) # 42

데코레이터 문법

---

위의 예제에서도 알 수 있지만 함수 또는 클래스, 메서드 등 callable한 객체의 선언부 상단에
@로 시작하는 함수명을 적어주는 형태를 띄어야 합니다!
(Pycharm 에서 데코레이터 뒤에 함수나 다른 데코레이터가 오지 않을 경우 Syntax Error: @ or def expected 에러를 표시합니다)

@timer # 함수의 정의부 상단에 적용할 데코레이터를 작성합니다
def foo():
    pass

@timer # 클래스 정의부 상단에 적용할 데코레이터를 작성해도 됩니다
class Bar(object):
    pass

class Baz(object):
    @timer # 클래스의 메서드 당연하게도 됩니다
    def qux(self):
      pass

@timer
doondoon = 'Doondoony' # [X] 이런건 안됩니다...

# callable 한 객체에는 모두 사용 가능합니다
callable(foo) # True
callable(Bar) # True
callable(Baz().qux) # True
callable(doondoon) # False

데코레이터는 클로저의 축약문법?

---

데코레이터는 클로저의 축약 문법이라고 했는데 실제로 어떻게 축약 되는지 알아야겠져
PEP-318 에 있는 예제를 (거의)그대로 인용하겠습니다!
synchronized, classmethod 는 callable한 객체로 어떤 일을 수행하는 함수 정도로만 생각 해주세요!

def synchronized(lock):
    # codes below...
    pass

def classmethod(arg):
    # codes below...
    pass

def foo(cls):
    # codes below...
    pass

foo = synchronized(lock)(foo)
foo = classmethod(foo)

# 위의 코드와 완전히 동일합니다
# 그렇다면 실행순서는 데코레이터가 쌓여있는 아래에서 위로 실행되는걸 알 수 있습니당
@classmethod
@synchronized(lock)
def foo(cls):
    pass

이렇게 보니까 별 거 아니죠?

데코레이터의 실행 순서

---

가장 중요한 건 함수 위에 @decorator 를 적용할 때 greeting 함수가 decorator 함수 안으로 들어간다는 점입니다
중첩된 데코레이터는 바로 위에서 설명드렸다시피 아래에서 위로 실행됩니다.

저는 데코레이터가 아래 함수를 감싼다고 이미지화 하고 있어요

def decorator(func):
    print('in decorator function') #1
    # 2번과 3번의 실행 순서는 비즈니스 로직에 달려있습니다 (데코레이터와는 순서 무관)
    def wrapper(*args, **kwargs):
      print('in wrapper function') #2
      func(*args, **kwargs) #3

      return wrapper


@decorator
def greeting():
    print('in greeting')


if __name__ == '__main__':
    greeting()

그래서 데코레이터를 언제 어떻게 쓰는뒈

---

언제, 어떻게 써야 좋은지는 당연한 이야기지만 단정적으로 얘기하기 어렵습니다 😅
다만, 개인적으로는 위에 작성한 것 처럼
데코레이터를 이용해, 반복을 줄이고 메소드나 함수의 책임을 확장한다는 역할에 걸맞도록 사용하려고 노력 중입니다.
(아래 장, 단점에서도 이야기 하겠지만 무분별한 데코레이터 사용은 코드 가독성을 떨어뜨립니다)

아래 코드들은 그러한 역할에 맞게 작성한 몇 가지 예제입니다.
실행 가능한 코드는 Gist에도 올려 두었습니당!

실행되는 함수의 실행 시간을 측정하기 위한 타이머 기능

• 데코레이터를 사용하지 않는다면 😭
• 아래 코드와 같이 계속 시작 시점에 시간을 만들고, 프린트 함수를 입력해야 합니다 (물론 이 또한 잘 묶어서 추상화 할 수 있지만...)
  

  import functools
  import time
  
  
  # 시작, 종료 시간을 체크해서 프린트 하는 코드를 함수안에 반영합니다.
  def huge_add(a, b):
      start = time.time()
      result = a + b
      time.sleep(1)
      print(f'add Elapsed time: {round((time.time() - start), 4)} seconds')
      return result
  
  
  # huge_add 와 같은 일을 하는 코드가 반복됩니당
  def huge_subtract(a, b):
      start = time.time()
      result = a + b
      time.sleep(1)
      print(f'subtract Elapsed time: {round((time.time() - start), 4)} seconds')
      return result
  
  
  # 같은 일을 하는 코드가 반복됩니당
  def huge_multiply(a, b):
      start = time.time()
      result = a * b
      time.sleep(1)
      print(f'multiply Elapsed time: {round((time.time() - start), 4)} seconds')
      return result
  
  
  if __name__ == '__main__':
      huge_number = 10e8
      huge_add(huge_number, huge_number)
      huge_subtract(huge_number, huge_number)
      huge_multiply(huge_number, huge_number)
  
  # 출력
  # add Elapsed time: 1.0039 seconds
  # subtract Elapsed time: 1.0048 seconds
  # multiply Elapsed time: 1.0048 seconds

• 데코레이터를 사용한다면 😎
• 아래와 같이 timer 함수의 정의 한번으로 @timer를 적용하기만 하면, 바로 실행 시간을 확인할 수 있습니다!
  

import functools
import time


def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        print(f'{func.__name__} took {round((time.time() - start), 4)} seconds')
        return result

    return wrapper


# timer 데코레이터 적용
@timer
def huge_add(a, b):
    result = a + b
    time.sleep(1)
    return result


@timer
def huge_subtract(a, b):
    result = a + b
    time.sleep(1)
    return result


@timer
def huge_multiply(a, b):
    result = a * b
    time.sleep(1)
    return result


if __name__ == '__main__':
    huge_number = 10e8
    huge_add(huge_number, huge_number)
    huge_subtract(huge_number, huge_number)
    huge_multiply(huge_number, huge_number)


# 출력, 이제는 간편하게 호출된 함수 이름도 확인할 수 있습니다
# huge_add took 1.0037 seconds
# huge_subtract took 1.0044 seconds
# huge_multiply took 1.0028 seconds

http request의 status code 유효성 검증

• 정상적인 요청이 수행되었는지 validation을 매번 하기 보다는 아래와 같이 처리할 수 있습니다

from urllib.parse import urljoin

import urllib3
from urllib3.exceptions import HTTPError


def response_ok(func):
    def validate(*args, **kwargs):
        result = func(*args, **kwargs)
        if result.status != 200:
            raise HTTPError(f'Request Failed with status code {result.status}')
            return result
    
        return validate


@response_ok
def fetch(path):
    with urllib3.PoolManager() as http:
        return http.request('GET', path)


if __name__ == '__main__':
    api = 'http://httpbin.org'
    url = urljoin(api, 'ip')  # 존재하는 URL 입니다. 200 응답을 기대합니다
    wrong_url = urljoin(api, 'pi')  # 존재하지 않는 URL 입니다. 404 응답을 기대합니다
    fetch(url).data.decode()  
    fetch(wrong_url).data.decode()  # urllib3.exceptions.HTTPError: Request Failed with status code 404


# 출력
# 올바른 URL로 접속 시도시
# '{\n  "origin": "1.2.3.4"\n}\n'

# 잘못된 URL로 접속 시도시
# urllib3.exceptions.HTTPError: Request Failed with status code 404

위의 예제를 보니 조금은 사용해야겠다는 생각이 드시나요?
데코레이터는 사실 중복되는 코드의 하나의 추상화 방법이라고 생각합니다.
그리고 추상화는 언제나 다른 비용을 수반합니다

데코레이터 사용의 장, 단점

---

장점

1. 중복을 제거하고, 코드가 간결해진다
2. 클로저를 직접 작성하는것 보다 문법적으로 간결하다
3. 부수 효과 없는 함수로 작성된 데코레이터의 경우, 조합해서 사용하기 용이하다

단점

1. 당연하지만, 이해도에 따라 코드 가독성이 떨어질 수 있다
2. 특정 메서드 / 함수 한정적인 데코레이터는 재 사용성이 떨어진다
   • 그런 경우에는 그냥 함수 내부에 로직으로 반영하는게 더 나은듯 합니다
3. 디버깅이 어렵다
   • 데코레이터가 중첩된 경우, 에러가 발생한 지점을 추적하기 조금 곤란한 경우가 있습니다
   • 데코레이터 함수에서 함수 이름을 func나 fn 등으로 받아서 실행하기 때문에, 어떤 함수가 에러인지 모호함

끝

---

긴 글 읽어주셔서 감사합니다!🐶

언제나 잘못된 부분이나 실행 안되는 코드는 지적해 주시면 감사하겠습니다
중요한 여러 개념을 다루는 내용이다보니, 개념이나 잘못된 정의가 있다면 꼭 알려주세요! 바로 수정하겠습니다.

개인적인 생각으로는 Best Practice를 찾아 그대로 하려는 생각때문에
저도 대부분의 개념들이 101 수준에 머물러 있었는데
그냥 그런 생각없이 일단 적용하고 천천히 수정해 나가면서 많이 이해도가 높아졌던것 같습니다

좋아보인다는 이유로 오,남용하는것도 문제일 수 잇지만 그러면서 많이 배워나갈 수 있다고 생각하니
익힌 개념을 마구마구 적용해보면 좋을 듯 해요!

다음에는 클래스 데코레이터와, 인자를 받을 수 있는 데코레이터, 중첩된 데코레이터의 사용 등에 대해 적어보겠습니당 😘