[Python 중급] 일급함수(First-class)와 클로저, 데코레이터

🔊 해당 포스팅은 인프런의 파이썬 중급 강의를 공부하면서 복습차원으로 정리한 포스팅입니다. 해당 내용은 주로 본인의 복습용이라서 자세한 설명은 없는 점 양해 부탁드리겠습니다. 원본 코드는 여기에 있습니다.

 

이번 포스팅에서는 파이썬의 일급함수(일급객체)의 특징에 대해 간단히 알아보고, 데코레이터를 만들기 위해 필요한 클로저에 대해 실습해보고 클로저 함수를 이용해 데코레이터까지 만들어보는 실습을 해보자.

 

Python

 

1. 일급함수(First-class)의 특징

파이썬 일급함수의 특징으로는 다음의 4가지 특징이 존재

 

• 런타임 초기화 : 실행 시점에 초기화가 됨을 의미
• 함수를 변수에 할당이 가능
• 함수를 또 다른 함수 인자로 전달 가능
• 함수 결과를 다른 함수 결과값에 할당에 반환 가능

먼저 함수를 변수에 할당이 가능한 예시를 간단하게 살펴보자.

 

# 일반 함수 만들어보기
def factorial(n):
    """factorial function -> n : int """
    # 재귀함수 종단 조건
    if n < 2:
        return 1
    else:
        return n + factorial(n-1)

# 일반 Class 만들기
class A:
    pass
    
# 일급객체 특징 : 함수를 변수로 할당 가능
var_func = factorial
print(type(var_func))
print(var_func(5))
# map 함수 이용해보기
print(list(map(var_func, range(1, 12))))

 

결과화면

 

위 화면처럼 함수도 일종의 'function' 이라는 클래스인 것을 알 수 있다.

 

다음은 함수를 또 다른 함수 인자에 전달하는 특징을 보자. 이를 고위(High-order) 함수라고도 한다.

 

# 3. 일급객체 특징 : 함수를 함수 인자에 전달 => 고위(high-order) 함수
# filter에서 익명함수를 정의해 리스트를 필터링한 후 이를 var_func 함수에 map을 이용해 적용!
print(list(map(var_func, filter(lambda x: x % 2, range(1, 11)))))
print([var_func(i) for i in range(1, 11) if i % 2])

 

즉, factorial이라는 함수를 var_func 변수에 할당하고 이를 map 함수인자로 다시 전달한다. 추가로 방금 우리가 직접 정의한 factorial 함수가 아닌 이미 구현되어 있는 함수 add를 import를 한 후 reduce 함수 인자로 전달해보자. 참고로 reduce 함수는 주어진 데이터를 누적하면서 집계시켜주는 함수이다. 

 

# reduce() 메소드 사용방법 -> reduce(함수, 리스트객체)
from functools import reduce
from operator import add

print(reduce(add, range(1, 5)))
print(sum(range(1, 5)))

# 익명함수 : lambda -> 가급적 주석을 사용하되 되도록이면 일반함수 형태로 작성하는게 권장(가독성 위해)
print(reduce(lambda x, t: x + t, range(1, 5)))

 

마지막인 함수를 또 다른 함수의 결과값으로 반환하는 것은 클로저와 데코레이터에서 다루므로 더 하단의 내용에서 다루기로 하자. 한 가지 추가로 소개할 메서드는 partial 메서드다. partial 메서드는 인수를 고정시키는 함수인데, 예시 코드를 살펴보자.

 

# partial 사용법 : 인수를 고정시키기 -> 콜백함수에 사용됨
# partial(함수, 고정시킬 인자)
from operator import mul
from functools import partial

# 인수 하나를 10으로 고정시키기
one_fix = partial(mul, 10)
# 10 인수를 고정시킨 채 2라는 추가 인수만 지정해주고 mul 연산 수행!
print(one_fix(2))
print([one_fix(i) for i in range(1, 11)])
# map 이용해보기
print(list(map(one_fix, range(1, 11))))
# filter는 참, 거짓을 판단해서 요소들을 필터링 하는 역할임!(map과는 다름!!)
print(list(filter(lambda x: x % 2, range(1, 11))))
# filter + map을 결합!!
print(list(map(one_fix, filter(lambda x: x % 2, range(1, 11)))))
print('-'*50)

# 인수 하나를 추가로 또 고정 시키기
double_fix = partial(one_fix, 2000)
print(double_fix()) # mul연산에 2개의 인수가 필요한데 이미 2개 인수 모두 고정시켰으므로 그냥 호출하면 됨!
# print(double_fix(4)) # 추가 인수를 넣어주면 에러 발생!

2. 클로저 개념에 대한 이해

클로저 개념에 대한 이해를 하기전에 우선 파이썬 볌수 범위(scope)에 대해 살펴보는 것도 좋은데, 이에 대한 자세한 설명 블로그가 있어 소개한다. 클로저는 일명 '상태를 계속 저장하고 유지'하기 위한다고 볼 수 있다. 즉, 메모리를 공유하지 않고 메세지 전달로 처리하기 위함이다. 결과적으로 클로저는  추후에 배울 멀티 쓰레드(코루틴) 프로그래밍에 강하다고 한다. 보통 클로저는 공유를 하되 변경되지 않는(immutable) 것들을 위해 적극적으로 사용된다.

 

우선, 일반적으로 누적합을 구하는 방법과 class를 이용해 누적합을 구하는 실습 코드이다.

 

# 일반적인 누적합 구하기
print(sum(range(1,11)))
print()

# 누적 평균 구하는 Class 정의해보기
# 클래스의 매직 메서드 __call__은 클래스를 마치 함수(메소드)처럼 callable할 수 있음!!
class Averager:
    def __init__(self):
        self._series = []

    def __call__(self, value):
        self._series.append(value)
        print(f"Series:{self._series}, Length:{len(self._series)}")
        # 누적 평균값 return
        return sum(self._series) / len(self._series)
# 클래스를 이용해 누적된 값 save
cls_averager = Averager()
result = cls_averager(10)
print("1번째:", result)

# 위에 save된 상태에서 누적시키고 평균구하기
result = cls_averager(20)
print("2번째:", result)
result = cls_averager(154)
print("3번째:", result)
result = cls_averager(256)
print("4번째:", result)

 

다음은 클로저를 이용해서 누적합을 구해보자. 우선 클로저를 구현하기 위해 외부(outer) 함수와 내부(inner 이것을 nested function이라고도 함)함수가 존재하고 이를 활용한다는 것을 염두에 두자.

 

def outer_func():
     series = [] # Free variable(자유 변수) => list, dict, set같은 경우 mutable하기 때문에 nonlocal 따로 선언하지 않아도 가능!
     def inner_func(value):
         series.append(value)
         print(f"Series:{series}, Length:{len(series)}")
         return sum(series) / len(series)
     # inner_func을 return 함으로써 상태를 계속 save!
     return inner_func

avg_closure1 = outer_func()
print(type(avg_closure1))
print("1번째 호출:", avg_closure1(10))
print("2번째 호출:", avg_closure1(20))
print("3번째 호출:", avg_closure1(55))

 

결과화면

 

결과화면에서 클로저함수의 type을 살펴보면 function이라는 일종의 클래스인 것을 볼 수 있다. 또 한가지 염두에 둘 점은 outer_func과 inner_fun(중첩함수) 사이를 보통 Free variable(자유 변수) 구역이라고 칭하는데, 여기서 정의되는 변수나 함수들은 중첩함수 내부에서 사용될 수 있다. 그러나 Free variable 구역 내에서 정의되는 자료구조가 만약 immutable한 자료구조(int, float, string, tuple, bool, frozenset)라면 중첩함수 내부에서 nonlocal로 변수를 정의해주어야 한다.

 

# 잘못된 Closure 사용법
def outer_func2():
    # Free variable 선언
    cnt = 0
    total = 0
    def inner_func2(value):
        cnt += 1 # inner_func2 외부에 있는 cnt, total 변수를 참조하지 못함! => cnt, total이 immtuable한 자료구조이기 때문에 불가!
        total += value
        return total / cnt
    return inner_func2
    
# 에러발생
wrong_closure = outer_func2() 
wrong_closure(10) 

 

# 위 잘못된 방법 해결 방안
def outer_func3():
    cnt = 0 # Free variable 선언
    total = 0
    def inner_func3(value):
        # cnt, total이 inner_func3 함수 외부의 지역변수를 참조할 것을 선언!
        nonlocal cnt, total
        cnt += 1
        total += value
        return total / cnt
    return inner_func3

right_closure = outer_func3()
print("1번째 호출:", right_closure(10))
print("2번째 호출:", right_closure(20))
print("3번째 호출:", right_closure(55))

결과화면을 보면 올바르게 누적 평균값이 잘 출력되는 것을 볼 수 있다.

 

결과화면

3. 데코레이터

이전에 배웠던 클로저 함수를 활용해 데코레이터를 만들어보자. 데코레이터를 만들기 위해서 클로저 함수의 외부함수에 인자로 특정한 함수를 인자로 전달하자.(이 때 함수를 인자로 전달하는 것은 일급 객체의 특징!)

 

먼저 데코레이터의 장,단점에 대해서 간단히 알아보자.

 

• 장점
  1. 중복 제거, 코드의 간결, 공통 함수 작성(공통 함수란, 로깅, 프레임워크를 만들 수 있고, 유효성 체크 가능. 그래서 우리가 자주 사용하는 텐서플로우 소스코드를 살펴보면 많은 데코레이터가 사용됨)
• 단점
  1. 너무 남발하면 가독성 감소.. 그래서 디버깅이 어려움
  2. 특정 기능에 한정된 함수는 굳이 데코레이터보다 일반 단일 함수로 정의하는 것이 나은 경우도 존재

이제 데코레이터 실습코드를 살펴보자. 특정 함수가 동작되고 종료되는 동안의 시간인 런타임을 측정해보는 데코레이터를 만들어보자

 

# 데코레이터 실습 - 특정 함수가 동작되고 종료되는 동안의 시간을 측정해보자
import time
# 우선, 클로저 함수 만들기
def perf_clock(func): # 함수를 인자로 전달 - 일급 객체의 특징
    # Free variable 구역
    def inner_func(*args): # 유동적인 인자를 위한 packing
        # 시작 time 측정
        st = time.perf_counter()
        result = func(*args)
        et = time.perf_counter()
        runtime = et - st
        name = func.__name__
        arg_str = ', '.join(repr(arg) for arg in args)
        print(f"{runtime :.5f} {name}({arg_str}) -> {result}")
        return result
    return inner_func
    
# 1. 데코레이터 사용해보기
@perf_clock
def sleep_func(seconds):
    time.sleep(seconds)
    pass

@perf_clock
def sum_func(*numbers):
    return sum(numbers)
print("## Decorator로 sleep_func 함수 동작 시간 출력 ##")
result1 = sleep_func(2)
print("## Decorator로 sum_func 함수 동작 시간 출력 ##")
result2 = sum_func(1,2,3,4,5,6,7,8,9,)
print(result2)

 

번외로 만약 데코레이터를 사용하지 않고 호출한다면 다음과 같이 사용할 수 있다. 클로저 함수를 정의하는 부분은 동일하다.

 

import time
# 우선, 클로저 함수 만들기
def perf_clock(func): # 함수를 인자로 전달 - 일급 객체의 특징
    # Free variable 구역
    def inner_func(*args): # 유동적인 인자를 위한 packing
        # 시작 time 측정
        st = time.perf_counter()
        result = func(*args)
        et = time.perf_counter()
        runtime = et - st
        name = func.__name__
        arg_str = ', '.join(repr(arg) for arg in args)
        print(f"{runtime :.5f} {name}({arg_str}) -> {result}")
        return result
    return inner_func

# 동작 시간을 측정할 함수 2가지 정의해주기
def sleep_func(seconds):
    time.sleep(seconds)
    return

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

# 2. 데코레이터를 사용하지 않고 호출하기
no_deco1 = perf_clock(sleep_func)
print("## None Decorator로 sleep_func 함수 동작 시간 출력 ##")
result1 = no_deco1(2)

no_deco2 = perf_clock(sum_func)
print("## None Decorator로 sum_func 함수 동작 시간 출력 ##")
result2 = no_deco2(1,2,3,4,5,6,7,8,9,10)
print("sum_func 함수 결과 :", result2)