§ Meta Programming

https://github.com/imguru-mooc/python_intermediate/tree/master/3.%EB%A9%94%ED%83%80%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D

1. 함수 감싸기 (데코레이터)

• 함수에 추가적인 처리 (로깅, 타이밍 등)을 하는 레퍼 레이어를 넣고 싶은 경우

• meta data : 함수의 부가적인 정보들

  • 함수의 이름, argument, doc 문자열, annotation (인자의 주석) 등
  • 여러 줄 주석 처리는 ''' ''' 을 이용하면 되고 이를 doc 문자열 이라고 한다.

• 단순히 함수에 decorator 를 씌우면 함수의 meta 정보가 사라지게 된다.

  • 이를 막기 위해 @wraps(func) 을 추가해주었다.

# ------------- # 
#   version 1   #
# ------------- #

import time
from functools import wraps

def timethis(func):
    # wrapper = wraps(func, wrapper) 로 넘어간 것과 같다
    # 이 코드에서는 wraps(countdown)(wrapper) 를 넘겨주는 것과 같다. 
    # wraps(countdown) 에서 meta data 를 뽑아서 다시한번 데코레이터를 씌우는 것

    @wraps(func)     # 새로 추가된 부분 (함수형 데코레이터) 

    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(func.__name__, end-start)
        return result
    return wrapper

if __name__ == '__main__':
    # 아래 코드는 사실 이런 의미가 된다. 
    # countdown = timethis(countdown)
    # 따라서 함수에 인자로 들어간 countdown 과 함수 return 으로 값을 갖게 된 countdown 은 전혀 다른 존재

    @timethis               
    def countdown(n:int):
        while n > 0:
            n -= 1

    countdown(100000)
    countdown(10000000)

# ------------- # 
#   version 2   #
# ------------- #

import time
from functools import wraps

def timethis(func):
    '''
    Decorator that reports the execution time.
    '''
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(func.__name__, end-start)
        return result
    return wrapper

if __name__ == '__main__':
    @timethis
    def countdown(n:int):
        '''
        Counts down
        '''
        while n > 0:
            n -= 1

    countdown(100000)
    print('Name:', countdown.__name__)
    print('Docstring:', repr(countdown.__doc__))
    print('Annotations:', countdown.__annotations__)

2. 데코레이터 풀기

• 함수에 데코레이터를 적용했는데, 이를 취소하고 원본 함수에 접근하고 싶다.
  • @wraps 를 사용해서 데코레이터를 올바르게 구현했다고 가정하면, 원본함수에는 wrapped 속성으로 접근할 수 있다.

from functools import wraps

def decorator1(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print('Decorator 1')
        return func(*args, **kwargs)
    return wrapper

def decorator2(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print('Decorator 2')
        return func(*args, **kwargs)
    return wrapper

@decorator1
@decorator2
def add(x, y):
    return x + y

# add = decorator2(add)
# add = decorator1(add)
# 하지만 decorator1 부터 호출됨 

print(add(2,3))

print(add.__wrapped__(2,3))

# print(add.__wrapped__.__wrapped__(2,3))
# 두 번 decorator 를 벗겨내서 원본 함수를 접근할 수 있을까? YES ! 

• wrapped 는 decorator 를 씌우면 생기며 한번 푸는 것과 같다.

  • 따라서 decorator1 이 풀려서 그 안에 decorator2 부터 수행되게 된다.
  • 단 wrapped 도 원본 함수의 함수 객체를 저장하기 위해서 wraps(func) 이 필요하다.

• log level 에 따라서 모드에 따라 log를 남길 수 있도록

  • @logged(logging.DEBUG) 의미는, add = logged(logging.DEBUG)(add) 와 동일하다
  • log level, module name, 함수명 으로 남길 수 있는 코드
  • 함수 별로 단계를 다르게 할 수 있음

from functools import wraps
import logging

def logged(level, name=None, message=None):
    def decorate(func):
        logname = name if name else func.__module__
        log = logging.getLogger(logname)
        logmsg = message if message else func.__name__

        @wraps(func)
        def wrapper(*args, **kwargs):
            log.log(level, logmsg)
            return func(*args, **kwargs)
        return wrapper
    return decorate

@logged(logging.DEBUG)
def add(x, y):
    return x + y

@logged(logging.CRITICAL, 'example')
def spam():
    print('Spam!')

if __name__ == '__main__':
    import logging
    logging.basicConfig(level=logging.DEBUG)
    print(add(2,3))
    spam()

3. 사용자가 조절 가능한 속성을 가진 데코레이터

• 함수를 감싸는 데코레이터 함수를 작성하는데, 사용자가 실행 시간에 동작성을 변경할 수 있도록 속성을 조절하고 싶은 경우

  • 즉, log level 이 DEBUG level 로 정해진 것을 동적으로 바꿀 수 있는가.
  • 함수 이름 이나 모듈 이름 등을 동적으로 바꾸기

• nonlocal level 이라고 설정해주면 한번 지정된 level 을 변경 할 수 있음.

  • @attach_wrapper 에서 set_level 을 wrapper 해주는데, set_level = attach_Wrapper(wrapper)(set_level)

• partial ? 이 뭘까

  • 함수 인자 중에 특정 하나를 어떤 값으로 고정하고 싶을때 사용한다.
  • 인자가 여러개이여도 유저가 사용할 때에는 특정 인자만 사용할 수 있는 기능
  • attach_wrapper 에서의 첫번째 인자는 wrapper 이라고 고정시킨 것.

5. 데코레이터를 사용해서 함수에서 타입 확인

• 함수의 매개변수 타입을 강제적으로 확인하는 기능

• 모든 매개변수에 대해 타입을 명시하거나 혹은 부분만 지정할 수 있어 데코레이터가 어느 정도 유연함

• signature : 함수에서 넘긴 실제 인자를 뽑아오는 것. 그 타입에 대해서는 뽑아오지 않음.

  • sig = signature(func) 한 후 sig.bind_partial(...) 을 하게 되면 type과 value를 list로 서로 묶어준다.
  • closure 에 의해서 원래 넘어와야 할 type 이 저장되어 있으면 type 을 체크할 수 있음

6. 데코레이터를 클래스의 일부로 정의

• 클래스 내부 method는 2종류.

  • instance method : 객체의 주소가 넘어감
  • class method : class method 라는 데코레이터
  • wraps (원본 함수의 데이터 저장을 위해서 가장 먼저 씌워준다.)

• class Person : first_name = property() 로 사용 가능

  • 내장 데코레이터 @property 는 실제로 getter() setter() delete() 메소드를 가진 클래스이고 데코레이터처럼 동작된다.

• 클래스를 전체 데코레이터로 사용 가능. 함수를 데코레이터로 감싸고 싶지만 그 결과는 호출 가능 인스턴스가 되도록 하고 싶은 경우. 그리고 데코레이터를 클래스 정의 내부/외부에서 모두 사용하고 싶다.

  • call 과 get 을 재정의 해주어야 함.

• 아래와 같은 예시에서 객체 add 에 괄호를 넣어 값을 넣어주면, 객체에 값을 넣기 때문에 에러가 발생한다. 사실 이 것은 add.call() 와 동일하기 때문에 __call__을 정의해주면 문제가 없음

@Profiled
def add(x, y):
   return x + y
# add = Profiled(Add)
# add(2, 3) -> add.__call__(2, 3)

• 또한 클래스의 멤버에 데코레이터를 씌워주는 상황에서는 get 이 필요하다.
  • 클래스 객체 안의 값을 가져와야 하기 때문에

def __get__(self, instance, cls):
   if instance is None:
      return self
   else:
      return types.MethodType(self, instance)

# instance 가 넘어오는 경우와 넘어오지 않는 경우가 있음. 
# 넘어오지 않는 경우는 데코레이터의 셀프를 넘기기 때문에, instance가 넘어가지 않음. 
...

class Spam:
   @Profiled
   def bar(self, x):
      print (self, x)

if __name__ = '__main__':
   s = Spam()
   s.bar(1) 
   s.bar(2)
   s.bar(3) 
   # s 클래스의 인스턴스 멤버 내부 함수를 가져오기 위해 get 도 필요하고 call 도 필요하다. 
   print ('ncalls:', Spam.bar.ncalls) 
   # 이 경우가 instance 가 None 인 경우에 해당. 데코레이터 @Profiled 의 ncallss 에 접근. 

7. 클래스와 static method 에 데코레이터 적용

• 클래스나 static method 에 데코레이터를 적용하고 싶은 경우
  • 데코레이터를 @classmethod 또는 @staticmethod 앞 (즉 아래)에 적용하도록 주의하자

8. 인스턴스 생성 조절에 메타클래스 사용

• meta-class : 어떤 클래스가 type을 상속받으면, 그것을 meta-class 라고 한다.
  • class 를 만드는 class
  • 일반적인 class 에서 call 을 재정의 할 때와 meta-class 에서 재정의 할 때는 전혀 다르다.
  • class 를 만들 때 모든 규칙이 meta-class 안에 들어간다.
  • meta-class 의 call 은 class 가 새로운 객체를 만들 때 동작 (s = Class())
  • 따라서 후킹이 가능하기 때문에, 싱글톤, 캐싱 등 기능 구현을 위해 인스턴스가 생성되는 방법을 변경하고 싶을 때
  • 싱글톤 : 객체를 하나만 존재하도록 !

class NoInstances(type):
    # 아래는 클래스를 못만들게 하고
    # 객체 없이 class method 와 static method 만 사용하게 하기 위한 코드
    # class 가 객체를 생성하려고 하는 시점에 호출 
    def __call__(self, *args, **kwargs):
        raise TypeError("Can't instantiate directly")

class Spam(metaclass=NoInstances):
    @staticmethod
    def grok(x):
        print('Spam.grok')

if __name__ == '__main__':
    try:
        s = Spam()
    except TypeError as e:
        print(e)

    Spam.grok(42)

• meta-class 의 init 은 class 자체가 생성될 때 호출되고 class 내부의 init 은 객체가 생성되고 초기화 할 때 호출된다.
  • 순서상으로 보면, class 자체가 생성될 때 meta-class 의 init
  • → 클래스가 () 를 만났을 때 meta-class 의 call
  • → 인스턴스가 다 만들어지고 초기화 될 때 class 내부의 init
  • meta-class 는 class 생성과 관련되어 있고, class 내부는 인스턴스 생성과 관련이 있음

class Singleton(type):
    # class 가 생성될 때 호출
    def __init__(self, *args, **kwargs):
        self.__instance = None
        super().__init__(*args, **kwargs)

    def __call__(self, *args, **kwargs):
        # class 가 인스턴스를 생성하려고 할 () 가 있을 때 호출 
        if self.__instance is None:
            self.__instance = super().__call__(*args, **kwargs)
            return self.__instance
        else:
            return self.__instance

class Spam(metaclass=Singleton):
    # class 의 객체가 다 만들어지고 그 인스턴스가 초기화 되는 시점에 호출 
    def __init__(self):
        print('Creating Spam')

if __name__ == '__main__':
    a = Spam()
    b = Spam()
    print(a is b)

10. 클래스 속성 정의 순서 수집

• meta class 를 상속받은 얘도 meta class 가 된다.
  • meta class 의 init 은 class 가 생성될 때 생성. *__call__은 calling 을 할 때 생성
  • init 은 초기화, __new__는 객체 (클래스) 가 메모리에 생성될 때.
  • 즉, new → init
  • prepare : class 에 대한 정보, 상속 정보에 대한 것들. 이게 __new__를 호출
  • 즉, prepare → new → init (10. 03:41 부터 듣기)

참고

• 제너레이터 (generator) : iterator 를 생성해주는 함수
  • iterator 는 class 에 iter, next 또는 getitem 메서드를 구현해야 하지만, generator 는 함수 안에 yield 키워드만 사용하면 됨.
  • iterator 는 next method 안에 직접 return 반환해야 하지만 generator 은 yield 지정한 값이 next 반환값으로 나옴
  • iterator 는 StopIteration 예외를 직접 발생시키지만 generator 는 함수 끝까지 도달하면 StopIteration 예외가 자동으로 발생.
  • 동작은 iterator 와 동일
  • 참고로 제너레이터 객체에서 __iter__를 호출하면 self를 반환하므로 같은 객체가 나옴
    • (제너레이터 함수 호출 > 제너레이터 객체 > __iter__는 self 반환 > 제너레이터 객체).
  • 그런데 generate라는 키워드를 사용하면 되지 왜 yield라고 이름을 지었을까?
    • yield는 생산하다라는 뜻과 함께 양보하다라는 뜻도 가지고 있어, yield를 사용하면 값을 함수 바깥으로 전달하면서 코드 실행을 함수 바깥에 양보.
    • 따라서 yield는 현재 함수를 잠시 중단하고 함수 바깥의 코드가 실행되도록 만듭니다.
  • 메서드 목록은 dir(함수이름) 으로 확인할 수 있음.
  • generator 안에서 return 함수를 사용하면 StopIteration 예외 메시지로 return 반환값이 지정됨