TIL17. Python : Closure & Decorator

📌 이 포스팅에서는 Python의 closure와 decorator 대해 알아보겠습니다.

🌈 Closure & Decorator

🔥 함수에서 변수의 범위

🔥 closure 란?

🔥 decorator 란?

1. 함수에서 변수의 범위

🤔 스코프에 범위에 대해 알아보겠습니다.

✔️ 아래 함수는 NameError가 발생합니다. b라는 변수가 인수로 들어오지도 않았고, 함수 밖이나 내에서 선언되지 않았기 때문에 참조할 수 없기 떄문입니다.

def my_func1(a):
    print(a)
    print(b)
# my_func1(5) # NameError: name 'b' is not defined

✔️ 아래처럼 b를 함수 밖에 선언한다면 함수는 문제 없이 작동시킬 수 있습니다. 함수는 함수 내부에서 해당 변수를 찾지 못할 경우, 외부에서 값을 참조하기 때문입니다.

b = 10
def my_func2(a):
    print(a)
    print(b)
my_func2(5) # 5 10

✔️ 함수 내부에서는 변수 b를 찾고 있는데, 함수 내부에 b는 선언하기 전에 사용되고있고, 함수 밖에도 b라는 변수가 존재합니다. 이럴 땐 "UnboundLocalError" Error가 발생합니다.
✔️ 즉, 함수 내부에서 해당 변수를 먼저 찾기 때문에 함수가 실행되는 Runtime 시, b라는 변수는 함수 내부에 선언되었다는 것을 인식했지만 변수 b를 선언하기 전에 참조하려 했기 때문에 Error이 발생하는 것입니다.
✔️ 이 때, 함수 밖에 변수 b는 참조되지 않습니다. Runtime 시, 함수 내부에 해당 변수가 존재하기 때문에 함수 스코프 밖을 탐색하지 않습니다.

b = 10 # 👈 참조되지 않습니다.
def my_func3(a):
    print(a)
    print(b) 
    b = 5 # 👈 b 변수 선언
my_func3(5)  # UnboundLocalError: local variable 'b' referenced before assignment

2. closure 란?

🤔 closure란 무엇일까?

✔️ 클로저란 반환되는 내부 함수에 대해서 선언되는 연결 정보를 가지고 참조하는 방식으로 반환 당시 함수 유효범위를 벗어난 변수 또는 매서드에 직접 접근을 가능하게 해주는 방법입니다.
✔️ 반환되는 내부 함수란 함수안에 함수가 있다는 의미로,, closure는 외부함수 , 내부함수인 총 2개 이상으로 함수로 이뤄져있습니다.
✔️ 누적된 값의 평균을 구해주는 Class를 생성해보고, 그 다음 closure 함수를 작성해보겠습니다.

class MyAvg:
    def __init__(self):
        self._series = []
    def __call__(self, v): # callable 사용
        self._series.append(v)
        return sum(self._series) / len(self._series)
avg_cls = MyAvg()
print(avg_cls(15))  # 15.0 👈 15 / 1
print(avg_cls(35))  # 25.0 👈 (15+35) / 2
print(avg_cls(40))  # 30.0 👈 (15+35+40) / 3

✔️ 이제 closure를 이용해 위 기능을 구현해보겠습니다.
✔️ 함수 "closure_avg1"를 호출하여 변수 "avg_closure1"에 할당했기 때문에 "avg_closure1"에는 averager 함수가 담겨 있습니다. 이에 함수 자체가 반환됩니다.
✔️ 즉, "avg_closure1"를 함수처럼 호출하면, 아래처럼 값이 누적되어 평균을 구할 수 있습니다.
✔️ 이는 "closure_avg1"의 호출을 통해 반환된 "avg_closure1"이 Free variable 영역에 series를 계속 참조하고 있기 때문입니다. 이를 클로져라고 합니다.
✔️ Free variable 영역은 외부함수와 내부함수 사이의 영역을 뜻하며, 이 곳이 closure의 영역입니다.
✔️ 이 영역에 어떤 변수나 매서드가 closure되는지 확인하려면, dir함수를 가지고 확인해볼 수 있습니다.

def closure_avg1():
    # Free variable 영역
    series = []
    def averager(v):
        series.append(v)
        return sum(series) / len(series)
    return averager  # 👈 averager 반환
avg_closure1 = closure_avg1() # 👈 closure_avg1 호출로 반환된 averager를 avg_closure1에 할당
print(avg_closure1)  # <function closure_avg1.<locals>.averager at 0x7fb78e308af0>
print(avg_closure1(15))  # 15.0
print(avg_closure1(35))  # 25.0
print(avg_closure1(40))  # 30.0
print(dir(avg_closure1.__code__.co_freevars)) # ('series', ) 👈 Free variable 영역 확인

✔️ "averager" 함수 내부에 series를 선언하면 어떻게 될까요?
✔️ "averager" 내부의 series를 참조하기 때문에 Free variabl 영역의 series를 인식하지 못합니다. 이에 값을 누적시켜 평균을 구하지 못하고 현재 parameter로 들어온 값에 대해서만 평균을 구합니다. 즉, series 변수는 계속 초기화 됩니다.

def closure_avg1():
    # Free variable 영역
    series = []
    def averager(v):
        series = []
        series.append(v)
        return sum(series) / len(series)
    return averager
avg_closure1 = closure_avg1()
print(avg_closure1)  # <function closure_avg1.<locals>.averager at 0x7fb78e308af0>
print(avg_closure1(15))  # 15.0
print(avg_closure1(35))  # 35.0
print(avg_closure1(40))  # 40.0

🤔 잘못된 closure 사용 예와 nonlocal

✔️ local 변수 'count'를 할당 전 참조하려하다는 "UnboundLocalError" 에러가 발생합니다.
✔️ 내부 함수인 "averager" 내에 "count"는 외부 함수인 "closure_avg"의 "count"와 이름만 같은 다른 함수입니다.
✔️ 이에 할당연산자를 사용 했을 때, "closure_avg"의 함수의 "count"를 참조할 수 없기 때문에 할당전에 참조하고 있다는 에러를 반환합니다.

def closure_avg():
    # Free variable
    count = 0
    total = 0
    # closure 영역
    def averager(v):
        count += 1
        total += v
        return total / count
    return averager
avg_closure = closure_avg()
print(avg_closure(15)) # UnboundLocalError: local variable 'count' referenced before assignment  

✔️ 이를 해결하기 위해서는 외부함수인 "closure_avg"의 "count"와 내부함수인 "averager"의 "count"가 같은 함수란 것을 명시해주어야 합니다.
✔️ 즉, 두 변수가 같은 변수이기 때문에 참조할 수 있도록하려면, nonlocal을 사용합니다.

def closure_avg():
    # Free variable
    count = 0
    total = 0
    # closure 영역
    def averager(v):
        nonlocal count, total # 👈 count와 total이 지역변수가 아님을 명시합니다.
        count += 1
        total += v
        return total / count
    return averager
avg_closure = closure_avg()
print(avg_closure(15)) # 15.0
print(avg_closure(35)) # 25.0
print(avg_closure(40)) # 30.0 

🤔 closure를 왜 쓸까?

✔️ 외부함수에 존재하는 변수나 매서드 등을 내부함수로 물고 들어와 처리하기 위해.
✔️ 데코레이터 쓰기 위해.

3. decorator 란?

🤔 데코레이터를 왜 쓸까?

✔️ 데코레이터는 중복을 제거하고, 코드를 더 간결하게 하기 위해 장식처럼 함수 위에 붙어 사용됩니다.
✔️ Python에서는 클로져보다 데코레이터를 사용하는 것이 문법이 간결하고, 조합해서 사용하기 용이합니다.
✔️ 단, 에러가 발생되면, 발생 지점 추적이 모호하기 때문에 디버깅에 있어서는 다소 어렵다는 단점이 있습니다.

🤔 데코레이터를 사용하지 않을 경우

✔️ 데코레이터를 사용하지 않을 경우, 여러 중복이 발생하고 코드가 간결하지 않게되는데요,, 예시를 통해 확인해보겠습니다.
✔️ 어떤 함수들이 실행될 때마다 해당 함수의 소요시간를 체크하는 함수를 필요하다고 가정하겠습니다.
✔️ 아래 함수는 클로져를 사용했기 때문에 함수 안에 함수가 존재하고, 외부함수를 실행시키면 내부함수를 반환합니다.

import time
def perf_clock(func):
    def perf_clocked(*args):
        # 시작 시간
        st = time.perf_counter()
        result = func(*args)
        # 종료시간
        et = time.perf_counter() - st
        # 함수명
        name = func.__name__  # 👈 함수이름
        # 매개변수
        arg_str = ",".join(repr(arg) for arg in args)  # 👈 매개변수 이름
        print(
            "Result : [%0.5fs] %s(%s) => %r" % (et, name, arg_str, result)
        )  # 👈 소요시간, 함수이름, 매개변수, 호출결과
        return result
    return perf_clocked

✔️ 아래는 TEST할 간단한 함수입니다.

# sleep 함수
def time_func(seconds):
    time.sleep(seconds)
# sum 함수
def sum_func(*numbers):
    return sum(numbers)
# factorial 함수
def fact_func(n):
    return 1 if n < 2 else n * fact_func(n - 1)

✔️ 데코레이터를 사용하지 않고 함수를 호출해보겠습니다.
✔️ Free Variable에서 외부 함수("perf_clock")로 들어온 "func"를 물고있기 때문에 내부 함수("perf_clocked")에서 이를 snapshot을 해두고 접근이 가능합니다.

non_deco1 = perf_clock(time_func)
non_deco2 = perf_clock(sum_func)
non_deco3 = perf_clock(fact_func)
print(non_deco1, non_deco1.__code__.co_freevars)  # <function perf_clock.<locals>.perf_clocked at 0x7fd29bd08c10> ('func',)
print(non_deco2, non_deco2.__code__.co_freevars)  # <function perf_clock.<locals>.perf_clocked at 0x7fd29bd08ca0> ('func',)
print(non_deco3, non_deco3.__code__.co_freevars)  # <function perf_clock.<locals>.perf_clocked at 0x7fd29bd08d30> ('func',)
non_deco1(2)  # Result : [2.00056s] time_func(2) => None
non_deco2(100, 200, 300)  # Result : [0.00000s] sum_func(100,200,300) => 600
non_deco3(10)  # Result : [0.00002s] fact_func(10) => 3628800

🤔 데코레이터는 어떻게 사용할까?

✔️ 데코레이터를 사용하면 보다 간결합니다. 데코레이터를 사용할 함수 위에 데코레이터를 선언합니다. 데코레이터를 선언하면, 바로 아래있는 함수에 데코레이터가 적용됩니다.
✔️ 데코레이터를 선언하였다면, 이제 실행시킬 함수를 간단히 호출만해주면됩니다. 해당 함수가 호출될 때 자동으로 데코레이터를 발견하여 클로져 기능을 적용시켜줍니다.

def perf_clock(func):
    def perf_clocked(*args):
        # 시작 시간
        st = time.perf_counter()
        result = func(*args)
        # 종료시간
        et = time.perf_counter() - st
        # 함수명
        name = func.__name__  # 👈 함수이름
        # 매개변수
        arg_str = ",".join(repr(arg) for arg in args)  # 👈 매개변수 이름
        print(
            "Result : [%0.5fs] %s(%s) => %r" % (et, name, arg_str, result)
        )  # 👈 소요시간, 함수이름, 매개변수, 호출결과
        return result
    return perf_clocked
# sleep 함수
@perf_clock # 👈 데코레이터 선언
def time_func(seconds):
    time.sleep(seconds)
# sum 함수
@perf_clock # 👈 데코레이터 선언
def sum_func(*numbers):
    return sum(numbers)
# factorial 함수
@perf_clock # 👈 데코레이터 선언
def fact_func(n):
    return 1 if n < 2 else n * fact_func(n - 1)
time_func(2) # Result : [2.00031s] time_func(2) => None
sum_func(100, 200, 300) # Result : [0.00000s] sum_func(100,200,300) => 600

🤔 재귀함수와 데코레이터

✔️ "fac_func" 함수는 재귀함수이기 때문에 재귀하는 깊이만큼 데코레이터가 실행되는 신기한 모습을 볼 수 있습니다.

fact_func(10)  
"""
Result : [0.00000s] fact_func(1) => 1
Result : [0.00002s] fact_func(2) => 2
Result : [0.00002s] fact_func(3) => 6
Result : [0.00003s] fact_func(4) => 24
Result : [0.00004s] fact_func(5) => 120
Result : [0.00005s] fact_func(6) => 720
Result : [0.00005s] fact_func(7) => 5040
Result : [0.00006s] fact_func(8) => 40320
Result : [0.00007s] fact_func(9) => 362880
Result : [0.00009s] fact_func(10) => 3628800  
"""