[python 심화] 13. 코루틴 (coroutine) , yield from

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

 

 

<이전 글>

https://silvercoding.tistory.com/29

[python 심화] 12. 내부 iter 함수, 제너레이터(Generator)

 

 

* yield : 메인 루틴 (순차진행 - 하나의 흐름) <-> 서브루틴 (함수가 호출되면 함수가 있는 곳으로) 이 루틴 두개를 동시에 할 수 있게 해주는 게 yield이다. 

* 코루틴 제어 , 코루틴  상태, 양방향 값 전송 (양방향 통신) 

* 서브 루틴 : 메인루틴에서 리턴에 의해 호출 부분으로 돌아와 다시 프로세스 

* 코루틴 : 루틴 실행 중 멈춤 가능 -> 특정 위치로 돌아갔다가 -> 다시 원래 위치로 돌아와 수행 가능 -> 동시성 프로그래밍 가능하게 해줌 

*쓰레드 : 싱글쓰레드 -> 멀티쓰레드 -> 복잡하다! (공유되는 자원에 대한 교착상태 발생 가능성이 있으므로 주의깊게 코딩해야 함) / 컨텍스트 스위칭 비용 발생, 자원 소비 가능성 증가 

 

 

- 코루틴 예제1 

def coroutine1():
    print('>>> coroutine started.')
    i = yield 
    print('>>> coroutine received : {}'.format(i))

저번 글에서는 yield i <-- 이런 식으로 사용했는데 , 이번에는 i = yield 의 형태로 사용하여 메인 루틴에서 값을 전달 받을 수 있다. 

 

 

* 제너레이터 선언

c1 = coroutine1()

print('EX1-1 - ', c1, type(c1))

 EX1-1 -  <generator object coroutine1 at 0x000001430D3574F8> <class 'generator'> 

제너레이터 객체를 생성하였다. 

 

next(c1)
next(c1)

 >>> coroutine started. 
 >>> coroutine received : None 
 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter06_02.py", line 35, in <module>  
    next(c1) 
 StopIteration 

위와같이 값을 전송하지 않으면 기본적으로 None을 전송한다. 

 

* 값 전송 

next(c1)
c1.send(100)

 >>> coroutine started. 
 >>> coroutine received : 100 
 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter06_02.py", line 41, in <module>  
    c1.send(100) 
 StopIteration 

이렇게 next() 대신 send()로 값을 전달할 수 있다. 

 

 

* 잘못된 사용 

c2 = coroutine1()
c2.send(100) # 예외 발생

 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter06_02.py", line 45, in <module>  
    c2.send(100) # 예외 발생 
 TypeError: can't send non-None value to a just-started generator 

next()를 호출하지 않고 , 처음부터 send를 사용하면 예외가 발생하게 된다! ( 뒤에서 next를 호출하지 않아도 되는 방법을 배울 것이다. )

 

 

 

 

 

 

 

 

 

- 코루틴 예제 2 

* GEN_CREATED : 처음 대기 상태 

* GEN_RUNNING : 실행 상태 

* GEN_SUSPENDED : yield 대기 상태 

* GEN_CLOSED : 실행 완료 상태 

 

def coroutine2(x):
    print('>>> coroutine started : {}'.format(x))
    y = yield x 
    print('>>> coroutine received : {}'.format(y))
    z = yield x + y 
    print('>>> coroutine received : {}'.format(z))

 

c3 = coroutine2(10)

coroutine2 함수를 생성하고 객체를 할당해 준다. x는 10으로 넣어준다. 

from inspect import getgeneratorstate
from typing_extensions import Literal

print('EX1-2 - ', getgeneratorstate(c3))

print(next(c3))

print('EX1-3 - ', getgeneratorstate(c3))

print(c3.send(15))
print(c3.send(20)) # 예외

 EX1-2 -  GEN_CREATED 

getgeneratorstate를 이용하여 제너레이터의 상태를 가져와서 확인할 수 있다. 우선 객체만 생성했을 때 처음 대기 상태임을 확인할 수 있다. 
 >>> coroutine started : 10 
 10 

x값이 반환되고, 이 상태에서 대기한다. 
 EX1-3 -  GEN_SUSPENDED 

yield 대기 상태 임을 확인할 수 있다. 
 >>> coroutine received : 15 
 25 

그다음 send로 15를 보내면 멈춰있던 yield 상태에서 y에 값 15가 전달된다. print문으로 15가 잘 전달된 것을 볼 수 있고, 그 다음 yield의 x + y 가 반환되고 이상태에서 멈춘다. 

 >>> coroutine received : 20 

또 다시 send로 20을 보내면 yield 대기 상태에서 멈추어 있던 z에 값이 전달된 것을 볼 수 있다. 

 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter06_02.py", line 78, in <module>  
    print(c3.send(20)) # 예외 
 StopIteration 

그다음 yield가 없으므로 오류가 나게 된다. 

 

 

 

 

 

 

 

 

 

 

- 데코레이터 패턴

: next를 호출하지 않아도 된다! 

<데코레이터 포스팅>

https://silvercoding.tistory.com/26

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

내부적으로 돌아가는 게 항상 헷갈려서 보고오기

from functools import wraps

def coroutine(func):
    '''Decorator run until yield'''
    @wraps(func)
    def primer(*args, **kwargs):
        gen = func(*args, **kwargs)
        next(gen)
        return gen
    return primer

제너레이터를 사용할 때 처음에 next를 호출하지 않고 바로 send로 값을 보내면 오류가 났다. 이번에는 위 데코레이터를 사용하여 바로 값을 전송하도록 만든다. 

@coroutine
def sumer():
    total = 0 
    term = 0 
    while True:
        term = yield total
        total += term

su = sumer()

데코레이터 @coroutine을 작성해 주고, 객체 su를 생성하였다. 

print('EX2-1 - ', su.send(100))
print('EX2-2 - ', su.send(40))
print('EX2-3 - ', su.send(60))

 EX2-1 -  100 
 EX2-2 -  140 
 EX2-3 -  200 

데코레이터로 인해 next가 호출되었고, yield에서 멈추어 있는 상태이다. 이 상태에서 send로 100을 전송하면 term에 100이 들어가고, total은 0+100=100이 되고, 다시 yield에서 total이 반환되고 멈춘다. 그다음 send로 40을 전송하면 term에 40이 들어가고, total=100+40=140이 되어 다시 yield를 만날때까지 while문이 돌아 total을 반환하고, 멈춘다. 60도 마찬가지로 돌아가서 200이 반환되는 것을 볼 수 있다. 

 

 

 

 

 

 

 

 

- 코루틴 예제 3 (예외 처리) 

class SampleException(Exception):
    '''설명에 사용할 예외 유형'''

def coroutine_except():
    print('>> coroutine started')
    try: 
        while True:
            try:
                x = yield
            except SampleException:
                print('-> SampleException handled. Continuing..') 
            else:
                print('-> coroutine received : {}'.format(x))
    finally:
        print('-> coroutine ending')

위에서 만들어 놓은 SampleException을 이용하여 예외처리를 해준다. 

exe_co = coroutine_except()

객체 생성

print('EX3-1 - ', next(exe_co))
print('EX3-2 - ', exe_co.send(10))
print('EX3-3 - ', exe_co.send(100))
print('EX3-4 - ', exe_co.throw(SampleException))
print('EX3-5 - ', exe_co.send(1000))
print('EX3-6 - ', exe_co.close()) # GEN_CLOSED 
print('EX3-7 - ', exe_co.send(10)) # 에러

 >> coroutine started 
 EX3-1 -  None 
 -> coroutine received : 10 
 EX3-2 -  None 
 -> coroutine received : 100 
 EX3-3 -  None 
 -> SampleException handled. Continuing.. 
 EX3-4 -  None 
 -> coroutine received : 1000 
 EX3-5 -  None 
 -> coroutine ending 
 EX3-6 -  None 
 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter06_02.py", line 146, in <module>  
    print('EX3-7 - ', exe_co.send(10)) # 에러 
 StopIteration 

EX3-4 에서 throw()를 사용하여 예외처리를 할 수 있다. 예외를 잡고 다시 yield로 가서 None을 반환하고 멈추어 있는 것을 볼 수 있다. 그래서 다시 send로 값을 전송해도 동작을 하고, 제너레이트를 아예 끝내고 싶다면 close()를 사용하면 된다. close()를 호출 한 후 , send로 값을 전송하려고 하면 오류가 나는 것을 알 수 있다. 

 

 

 

 

 

 

 

 

 

 

 

- 코루틴 예제 4 (return) 

def averager_re():
    total = 0.0
    cnt = 0 
    avg = None
    while True:
        term = yield
        if term is None:
            break
        total += term
        cnt += 1
        avg = total / cnt 
    return 'Average : {}'.format(avg)

avger2 = averager_re()

값으로 None을 보낼 때까지 while문이 실행되도록 하고 , 보내는 값을 모두 더해서 평균을 내주는 함수이다. 

next(avger2)

avger2.send(10)
avger2.send(30)
avger2.send(50)

위와 같이 값을 전달해준다. 

try:
    avger2.send(None)
except StopIteration as e:
    print('EX4-1 - ', e.value)

 EX4-1 -  Average : 30.0 

None을 전송하여 while문에서 탈출하고 , 예외처리로 함수의 리턴 값을 받을 수 있다. 

 

 

 

 

 

 

 

 

 

 

 

 

- 코루틴 예제 4 (yield from) (3.7 -> await) 

: 중첩 코루틴 처리 

 

(1) yield from 미사용 

def gen1():
    for x in 'AB':
        yield x 
    for y in range(1, 4):
        yield y

제너레이터 함수를 생성해 준다.

t1 = gen1()
print('EX5-1 - ', next(t1))
print('EX5-2 - ', next(t1))
print('EX5-3 - ', next(t1))
print('EX5-4 - ', next(t1))
print('EX5-5 - ', next(t1))
print('EX5-6 - ', next(t1)) # StopIteration

 EX5-1 -  A 
 EX5-2 -  B 
 EX5-3 -  1 
 EX5-4 -  2 
 EX5-5 -  3 
 Traceback (most recent call last): 
  File "c:/Users/./Desktop/python_high/chapter06_02.py", line 198, in <module> 
    print('EX5-6 - ', next(t1)) # StopIteration 
 StopIteration 

앞에서 해왔던 것 처럼 next를 호출했을 때 더 이상 만날 yield가 존재하지 않는다면 Stopiteration 예외가 나게 된다. 

t2 = gen1()
print('EX5-7 - ', list(t2))

 EX5-7 -  ['A', 'B', 1, 2, 3] 

이렇게 리스트 객체로 받아줄 수도 있다. 

 

 

 

 

(2) yield from 사용 

def gen2():
    yield from 'AB'
    yield from range(1, 4)

이와 같이 yield from을 사용하면 위의 예시 처럼 for문을 사용하지 않아도 되고 , 간단하게 두 줄로 작성할 수 있다. 

t3 = gen2()
print('EX6-1 - ', next(t3))
print('EX6-2 - ', next(t3))
print('EX6-3 - ', next(t3))
print('EX6-4 - ', next(t3))
print('EX6-5 - ', next(t3))
print('EX5-6 - ', next(t3)) # StopIteration

 EX6-1 -  A 
 EX6-2 -  B 
 EX6-3 -  1 
 EX6-4 -  2 
 EX6-5 -  3 
 Traceback (most recent call last): 
  File "c:/Users/sooki/Desktop/python_high/chapter06_02.py", line 217, in <module> 
    print('EX5-6 - ', next(t3)) # StopIteration 
 StopIteration 

(1)번 예제와 똑같이 나오는 것을 볼 수 있다. 

t4 = gen2()
print('EX6-7 - ', list(t4))

 EX6-7 -  ['A', 'B', 1, 2, 3] 

list도 마찬가지로 동일하게 나온다. 

 

 

 

 

 

* yield from 예제 +1 

def gen3_sub():
    print('Sub coroutine')
    x = yield 10 
    print('Recv: ', str(x))
    x = yield 100
    print('Recv: ', str(x))
    
def gen4_main():
    yield from gen3_sub()

위와 같이 sub coroutine으로 함수를 선언해 놓고 , main coroutine에서 yield from 으로 작업을 해줄 수 있다. 

t5 = gen4_main()

print('EX7-1 - ', next(t5))
print('EX7-2 - ', t5.send(7))
print('EX7-3 - ', t5.send(77)) # 오류

 Sub coroutine 
 EX7-1 -  10 
 Recv:  7 
 EX7-2 -  100 
 Recv:  77 
 Traceback (most recent call last): 
  File "c:/Users/sooki/Desktop/python_high/chapter06_02.py", line 247, in <module> 
    print('EX7-2 - ', t5.send(77)) 
 StopIteration