[python 심화] 9. 변수 범위, Closure, Decorator

코드 - 패캠 수업 코드 참고 (패캠 수업 정리)

 

<이전 글>

https://silvercoding.tistory.com/25

 

이번 포스트에서는 데코레이터를 알아볼 것이다. 데코레이터는 어렵다고 느끼는 것이 당연하다. 데코레이터에 들어가기 전에는 변수의 범위와 클로저 개념을 알아야 하므로 이 둘을 먼저 살펴보자.

 

- 파이썬 변수 범위 

*** 전역변수 vs 지역변수 참고 

https://wikidocs.net/62

위키독스

여기 이해하기 쉽게 정리가 되어있다! 

 

직접 실습해보자 

# 예제 1
def func_v1(a):
    print(a)
    print(b)


# 오류
# func_v1(5)

 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 19, in <module>
    func_v1(5) 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 15, in func_v1       
    print(b) 
 NameError: name 'b' is not defined 

 

예제1과 같은 함수를 작성하고, 호출하면 당연한 결과로 NameError가 난다. b가 정의되어 있지 않은데 b를 출력하라고 작성하였기 때문이다. 

 

 

# 예제 2 
b = 10

def func_v2(a):
    print(a)
    print(b)

func_v2(5)

그렇다면 이렇게 함수 밖에 b를 선언하고 함수 안에서 b를 출력하면 어떻게 될까? 

 5  
 10  

위와 같이 출력이 되는 것을 볼 수 있다. 이때의 b를 전역변수라고 한다.

 

 

# 예제3 
b = 10

def func_v3(a):
    print(a)
    print(b)
    b = 5
    
func_v3(5)

이렇게 작성한다면 어떻게 될까? 

Traceback (most recent call last):
  File "c:/Users/sooki/Desktop/python_high/chapter04_02.py", line 42, in <module>      
    func_v3(5) 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 39, in func_v3       
    print(b) 
UnboundLocalError: local variable 'b' referenced before assignment

오! UnboundLocalError 가 난다. 할당되기 전에 지역변수 'b'가 참조되었다는 것이다. 

 

함수 내에 b가 있는 건 체크가 되었는데, b에 값을 할당하기 전에 b를 출력했기 때문에 에러가 난다. 

같은 이름의 전역변수와 지역변수가 있으면 함수 내에서는 지역변수가 우선이며, 런타임의 인터프리터가 b가 있는 것을 체크했지만, 할당은 위에서부터 아래로 이루어지기 때문이다.

 

* 증명

from dis import dis

print('EX1-1 - ')
print(dis(func_v3))

EX1-1 -
 38           0 LOAD_GLOBAL              0 (print) 
              2 LOAD_FAST                0 (a) 
              4 CALL_FUNCTION            1 
              6 POP_TOP 

 39           8 LOAD_GLOBAL              0 (print) 
             10 LOAD_FAST                1 (b) 
             12 CALL_FUNCTION            1 
             14 POP_TOP 
 
 40          16 LOAD_CONST               1 (5) 
             18 STORE_FAST               1 (b)  
             20 LOAD_CONST               0 (None) 
             22 RETURN_VALUE 
 None 

 

 

 

- Closure (클로저) 

1. 반환되는 내부 함수에 대해서 선언된 연결 정보를 가지고 참조하는 방식 

2. 반환 당시 함수의 유효범위를 벗어난 변수 또는 메소드에 직접 접근이 가능 

 

글로 읽으면 이해가 어려우니 직접 실습해보기 . 

a = 10 

print('EX2-1 - ', a + 10)
print('EX2-2 - ', a + 100)
print('EX2-3 - ', sum(range(1, 51)))
print('EX2-4 - ', sum(range(51, 101)))

 EX2-1 -  20 
 EX2-2 -  110 
 EX2-3 -  1275 
 EX2-4 -  3775 

a라는 변수를 선언하고 , 따로 따로 10, 100을 더하고 출력하면 당연한 결과로 20, 110이 나온다. 

위의 예제들 처럼 개별적인 계산이 이루어지게 된다. 

 

이와 다르게 결과를 누적할 수는 없을까? 에 대한 답으로 사용할 수 있는 것이 클로저이다. 

 

 

 

Q) 결과를 누적할 수는 없을까 ? 

A1) 클래스 이용 

class Averager():
    def __init__(self):
        self._series = []

    def __call__(self, v):
        self._series.append(v)
        print('class >>> {} / {}'.format(self._series, len(self._series)))
        return sum(self._series) / len(self._series)

우선 Averager 클래스는 숫자를 넣으면 리스트에 추가하여 평균을 구해주는 클래스이다. 

객체를 생성하면 _series 에 빈 리스트를 생성한다. 

저번 글에서 배운 __call__ 메소드는 객체를 메소드 형태로 호출할 수 있도록 해 주는 것이었다. 

 

# 인스턴스 생성 
avg_cls = Averager()

print('EX3-1 - ', avg_cls(15))
print('EX3-2 - ', avg_cls(35))
print('EX3-2 - ', avg_cls(40))

 class >>> [15] / 1 
 EX3-1 -  15.0 
 class >>> [15, 35] / 2 
 EX3-2 -  25.0 
 class >>> [15, 35, 40] / 3 
 EX3-2 -  30.0 

이렇게 누적으로 저장해두었다가 평균을 구해준다. 

 

 

 

A2) 클로저 이용 

이번엔 클로저를 사용한다. 클로저를 사용하면 

1. 전역변수 사용 감소 

2. 디자인 패턴 적용 

def closure_avg1():
    # Free Variable
    # 클로저 영역
    series = []
    def averager(v):
        # 여기에 series가 없는데 계속 참조하고 있음 
        # series = [] 여기에 쓴다면 계속 초기화된 후 append됨 
        series.append(v)
        print('def1 >>> {} / {}'.format(series, len(series)))
        return sum(series) / len(series)
    return averager # 함수 자체를 리턴 averager() 이게 아님

 

클로저 영역에서 series를 선언한 것 빼고는 다른 게 없어보인다. 원래 함수안에서 선언한 변수는 함수 리턴과 동시에 초기화된다. 하지만 클로저 영역에서 선언한 변수는 초기화 되지 않아 이러한 누적으로 추가되는 코드를 짤 때 사용할 수 있다. 

avg_closuer1 = closure_avg1()

print('EX4-1 - ', avg_closuer1(15))
print('EX4-1 - ', avg_closuer1(35))
print('EX4-1 - ', avg_closuer1(40))

지금보니 오타가 났다 closuer 이라고 되어있다! 

def1 >>> [15] / 1
EX4-1 -  15.0
def1 >>> [15, 35] / 2
EX4-1 -  25.0
def1 >>> [15, 35, 40] / 3
EX4-1 -  30.0

결과가 잘 나오는 것을 볼 수 있다. 

print('EX5-1 - ', dir(avg_closuer1))
print()
print('EX5-2 - ', dir(avg_closuer1.__code__))
print()
print('EX5-3- ', avg_closuer1.__code__.co_freevars)  # 클로저에 접근
print()
print('EX5-4 - ', dir(avg_closuer1.__closure__[0]))  
print()
print('EX5-5 - ', dir(avg_closuer1.__closure__[0].cell_contents[1]))

EX5-1 -  ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

__code__ 에 접근
EX5-2 -  ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_kwonlyargcount', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_stacksize', 'co_varnames']
co_vars 에 접근 ---> 클로저에 접근 
EX5-3-  ('series',)
series가 나오는 것을 볼 수 있다.
EX5-4 -  ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'cell_contents']

EX5-5 -  ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', 
'__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

 

 

 

*** 잘못된 클로저 사용 예 

def closure_avg2():
    # Free variable
    # 클로저 영역 
    cnt = 0 
    total = 0 
    
    def averager(v):
        cnt += 1
        total += v 
        print('def2 >>> {} / {}'.format(total, cnt))
        return total / cnt 
    return averager

 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 155, in <module>     
    print('EX5-5 - ', avg_closure2(15)) 
  File "c:/Users/./Desktop/python_high/chapter04_02.py", line 147, in averager     
    cnt += 1 
 UnboundLocalError: local variable 'cnt' referenced before assignment 

이렇게 사용하는 경우에는 UnboundLocalError가 실행된다. 

 

 

 

---> 해결방법 

def closure_avg2():
    # Free variable
    # 클로저 영역 
    cnt = 0 
    total = 0 
    def averager(v):
        nonlocal cnt, total  
        cnt += 1
        total += v 
        print('def2 >>> {} / {}'.format(total, cnt))
        return total / cnt 
    return averager

<nonlocal 변수명> 을 붙여주면 클로저 영역을 사용하여 변수를 선언해줄 수 있다. 

avg_closure2 = closure_avg2()

print('EX5-5 - ', avg_closure2(15))
print('EX5-5 - ', avg_closure2(35))
print('EX5-5 - ', avg_closure2(40))

 def2 >>> 15 / 1 
 EX5-5 -  15.0 
 def2 >>> 50 / 2 
 EX5-5 -  25.0 
 def2 >>> 90 / 3 
 EX5-5 -  30.0 

그럼 결과 값이 잘 나오는 것을 볼 수 있다. 

 

 

- 데코레이터 , Decorator 

장점

1. 중복제거, 코드 간결 

2. 클로저보다 문법 간결 

3. 조합해서 사용할 때 용이 

 

단점 

1. 디버깅이 어려움 

2. 에러의 모호함 

 

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

우선 perf_clock 이라는 함수를 생성한다. 함수를 입력하면 그 함수가 실행되는 데 걸리는 시간과 그 함수의 반환 결과를 반환해 주는 함수이다. 

 

 

* 데코레이터 미사용 

def time_func(seconds):
    time.sleep(seconds)


def sum_func(*numbers):
    return sum(numbers)


def fact_func(n):
    return 1 if n < 2 else n * fact_func(n-1)

총 3가지의 함수로 실험을 해본다. time_func : 2초 sleep , sum_fun : 숫자 합하기, fact_func : 팩토리얼 계산 

non_deco1 = perf_clock(time_func)
non_deco2 = perf_clock(sum_func)
non_deco3 = perf_clock(fact_func)

print('EX7-1 - ', non_deco1, non_deco1.__code__.co_freevars)
print('EX7-2 - ', non_deco2, non_deco2.__code__.co_freevars)
print('EX7-3 - ', non_deco3, non_deco3.__code__.co_freevars)

print('*' * 40, 'Called Non Deco -> time_func')
print('EX7-4 - ')
non_deco1(2)
print('EX7-5 - ')
non_deco2(100, 200, 300, 500)
print('EX7-6 - ')
non_deco3(100)

EX7-1 -  <function perf_clock.<locals>.perf_clocked at 0x0000029029B70EA0> ('func',)   
EX7-2 -  <function perf_clock.<locals>.perf_clocked at 0x0000029029B70F28> ('func',)   
EX7-3 -  <function perf_clock.<locals>.perf_clocked at 0x0000029029B74048> ('func',)   
**************************************** Called Non Deco -> time_func

 EX7-4 - Result : [2.00830s] time_func(2) -> None 
 EX7-5 -  Result : [0.00001s] sum_func(100,200,300,500) -> 1100 
 EX7-6 - Result : [0.00017s] fact_func(100) ->   93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 

perf_clock의 인자로 각 함수를 넣어 변수를 선언해준다. 그 다음 함수를 사용하면 , 원하던 결과가 잘 나온다! 

 

 

 

 

* 데코레이터 사용 

@perf_clock
def time_func(seconds):
    time.sleep(seconds)


@perf_clock
def sum_func(*numbers):
    return sum(numbers)


@perf_clock
def fact_func(n):
    return 1 if n < 2 else n * fact_func(n-1)

데코레이터를 사용하기 위해 함수 위에 @perf_clock 을 작성한다. 

print('*' * 40, 'Called Deco -> time_func')
print('EX7-7 - ')
time_func(2)

print('*' * 40, 'Called Deco -> sum_func')
print('EX7-7 - ')
sum_func(10, 20, 30, 40, 50)

print('*' * 40, 'Called Deco -> fact_func')
print('EX7-7 - ')
fact_func(5)

**************************************** Called Deco -> time_func 
EX7-7 -
Result : [2.01093s] time_func(2) -> None 
**************************************** Called Deco -> sum_func 
EX7-7 -
Result : [0.00002s] sum_func(10,20,30,40,50) -> 150 
**************************************** Called Deco -> fact_func 
EX7-7 -
Result : [0.00000s] fact_func(1) -> 1 
Result : [0.00026s] fact_func(2) -> 2 
Result : [0.00058s] fact_func(3) -> 6 
Result : [0.00087s] fact_func(4) -> 24 
Result : [0.00110s] fact_func(5) -> 120 

그럼 이렇게 변수를 생성해주지 않아도 간단하게 결과를 얻을 수 있다.