list comprehension🧐

• 한 줄로 반복문과 조건문을 넣은 상태를 표현할 수 있다.
• 그러나 가독성이 떨어지는 경우는 사용하기 좋은 경우라고 할 수 없다.
• Python이 줄 단위로 코드를 인식하기 때문에 속도가 더 빠른 것으로 생각된다.

iterator🧐

• iterator는 값을 차례로 꺼낼 수 있는 객체이다.
• iter() 메소드로 iterator를 얻는다.(__iter__)
• list, tuple, range, string, dictionary, set 등이 해당한다.
• for문을 굳이 사용하지 않고도 next()메소드(__next__)를 통해 다음에 해당하는 값을 받아 올 수 있다. 다음에 보내줄 값이 없을 때는 에러를 발생시킨다. 때문에 위 코드에서 while문을 빠져 나올 수 있다.

generator🧐

제너레이터는 이터레이터를 생성해주는 함수이다. 제너레이터는 함수 안에서 yield 키워드만 사용하면 된다.

def number_generator():
    yield 0
    yield 1
    yield 2
 
g = number_generator()
print(g.next()) # 0
print(g.next()) # 1
print(g.next()) # 2
print(g.next()) # StopIteration

이번 과제는 다음코드를 실행해보고 분석한 결과를 블로깅하는 과제 입니다. lazy evaluation 이란 무엇인지와 장점 및 리스트 컴프리헨션과의 차이점에 대하여 블로깅 해주세요

import time

L = [ 1,2,3]

def print_iter(iter):
    for element in iter:
        print(element)

def lazy_return(num):
    print("sleep 1s")
    time.sleep(1)
    return num

print("comprehension_list=")
comprehension_list = [ lazy_return(i) for i in L ]
print_iter(comprehension_list)

print("generator_exp=")
generator_exp = ( lazy_return(i) for i in L )
print_iter(generator_exp)

lazy evaluation

lazy evaluation은 계산을 나중으로 미루는 것을 의미하며 이는 메모리에 대해서 장점을 가질 수 있다. 왜냐하면 함수를 실행시킨 후에 return 값을 활용하지 않으면 메모리의 낭비가 발생한다. 그러나 제너레이터 함수가 실행될 때까지 계산을 미루기 때문에 메모리 낭비가 발생하지 않게 된다.

VS list comprehension

차이점을 설명하기 전에 위의 코드 실행 결과 화면은 다음과 같다.

• list comprehension은 lazy_return 함수가 모두 실행된 후에 print_iter 함수가 실행된다. 그러나 generator는 lazy_return 실행 후에 for문의 다음 cycle이 바로 실행되는 것이 아니라 외부로 빠져나와 다른 코드에게 양보한다. 그렇기에 print_iter 함수가 실행되고 그 함수 내부에서 두 번째 generator 함수가 필요하게 되자 다시 lazy_return 함수를 실행하고 다음 작업을 반복하게 된다.
• 즉 generator 함수가 실행되는 순간에 미뤄두었던 계산을 하게 되고 이와 달리 list comprehension은 그와 관계 없이 우선 계산을 시작하고 마치게 된다.

lambda🧐

lambda는 익명 함수이다.

lambda 매개변수들: 식, 인자
lambda 매개변수들: 식1 if 조건식 else 식2
lambda 매개변수들: 식1 if 조건식1 else 식2 if 조건식2 else 식3

1번

다음 코드를 실행해보고 print문으로 출력되는 출력결과를 확인해보고 types 모듈에 LambdaType 외에도 어떤 타입들이 있는지 조사해 보세요.

• 코드
  
• 출력 결과
  

types 모듈에 있는 type

• types.FunctionType
• types.LambdaType
• types.GeneratorType
• types.CoroutineType
• types.AsyncGeneratorType
• class types.CodeType(**kwargs)
• types.CellType
• types.MethodType
• types.BuiltinFunctionType
• types.BuiltinMethodType
• types.WrapperDescriptorType
• types.MethodWrapperType
• types.MethodDescriptorType
• types.ClassMethodDescriptorType
• class types.ModuleType(name, doc=None)
• class types.TracebackType(tb_next, tb_frame, tb_lasti, tb_lineno)
• types.FrameType
• types.GetSetDescriptorType
• types.MemberDescriptorType
• class types.MappingProxyType(mapping)

2번

• 코드

• 출력 결과

Thread🧐

• 이미지 출처: https://www.python-course.eu/threads.php

1번

쓰레드 공식문서에서 학습한 내용에 대해서 자유롭게 블로깅(실행해본 예제코드를 분석한 내용을 블로깅해도 좋고 이론적인 내용을 블로깅해도 좋습니다.)

import threading	
import time

shared_number = 0	

def thread_1(number):
    global shared_number	
    print("number = ",end=""), print(number)
    
    for i in range(number):
        shared_number += 1

def thread_2(number):
    global shared_number	
    print("number = ",end=""), print(number)
    for i in range(number):
        shared_number += 1

if __name__ == "__main__":	

    threads = [ ]

    start_time = time.time()	
    
    t1 = threading.Thread( target= thread_1, args=(50000000,) )	
    t1.start()
    threads.append(t1)

    t2 = threading.Thread( target= thread_2, args=(50000000,) )
    t2.start()
    threads.append(t2)


    for t in threads:
        t.join()

    print("--- %s seconds ---" % (time.time() - start_time))

    print("shared_number=",end=""), print(shared_number)
    print("end of main")

• thread를 사용하기 위해서는 threading 모듈을 import해야한다.
• if __name__ == "__main__": 메인 파일이 직접 실행 되었을 때 실행할 코드를 적은 구역이다.
• threading 클래스의 Thread 메소드를 이용해서 객체를 받아온다. 이 때 인자로 주는 것은 target이 가르키는 것은 thread가 실행시킬 함수를 뜻하고 args는 함수에 전달할 인자로 기본값은 ()이다. 추가적인 인자는 다음과 같다.

threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)

• group는 None값이 되야만 한다. 후에 ThreadGroup 클래스가 개선될 때를 위해 예약된 것이다.
• name은 thread의 이름이다. 기본적으로 고유 이름은 “Thread-(10진법수)”

• .start()를 이용해 thread를 실행시킨다.
• .join()은 쓰레드가 끝날 때까지 기다려준다.

2번

shared_number 가 천만으로 증가되지 않는 이유를 설명하고( 블로그 또는 멘토에게 설명)

• shared_number가 천만으로 증가되지 않은 이유는 python의 GIL(Global Interpreter Lock) 때문이다. 파이썬에서는 하나의 프로세스 안에 모든 자원의 락(Lock)을 글로벌(Global)하게 관리함으로써 한번에 하나의 쓰레드만 자원을 컨트롤하여 동작하도록 한다. (thread의 첫 번째 이미지 참고.) 천만까지 증가하고 있지 않은 것은 하나의 thread에서 shared_number를 사용하고 있으면 다른 thread는 그것을 사용할 수 없게 된다. 그렇기에 천만까지 증가하지 않게 된 것이다. 시간이 절반까지 줄어들지 않은 이유도 결국 한 번에 하나의 thread만이 자원을 컨트롤함에 있어서 시간이 줄어들지 않은 것이다.

3번

위의 코드 기반으로 두개의 쓰레드에서 각각 50000000씩 증가시켜서 shared_number 를 천만으로 증가시키는 코드를 구현하는 과제 입니다.( hint. 조건변수, 뮤텍스 )

뮤텍스

import threading
import time

shared_number = 0

def thread_1(number,cv):
    global shared_number
    print("number = ",end=""), print(number)
    cv.acquire()	# Lock을 획득하게 되고 다른 객체가 접근할 수 없도록 잠근다.
    for i in range(number):
        shared_number += 1
    cv.release()	# Lock을 풀어준다. 다른 객체가 접근할 수 있도록 한다.

def thread_2(number,cv):
    global shared_number
    print("number = ",end=""), print(number)
    cv.acquire()	# Lock을 획득하게 되고 다른 객체가 접근할 수 없도록 잠근다.
    for i in range(number):
            shared_number += 1
    cv.release()	# Lock을 풀어준다. 다른 객체가 접근할 수 있도록 한다.

if __name__ == "__main__":

    threads = [ ]
    start_time = time.time()
    tc = threading.Lock()	#Lock 객체 생성
    t1 = threading.Thread( target= thread_1, args=(50000000,tc,) )
    t1.start()
    threads.append(t1)

    t2 = threading.Thread( target= thread_2, args=(50000000,tc,) )
    t2.start()
    threads.append(t2)


    for t in threads:
        t.join()	# thread가 끝날 때까지 기다려준다.

    print("--- %s seconds ---" % (time.time() - start_time))
    print("shared_number=",end=""), print(shared_number)
    print("end of main")

• tc = threading.Lock(): Lock 객체 생성
• 생성한 tc를 thread 생성 시에 실행할 함수의 인자로 전달.
• thread가 start하면 for문을 돌면서 lock을 잠갔다가 풀었다를 반복하면서 결국 1억까지 찍히게 된다. 세마포어와의 차이점은 뮤텍스는 무조건 하나의 쓰레드 혹은 프로세스만 접근하게 한다는 점이고 세마포어는 접근 가능 객체 수를 지정할 수 있다는 점이다.

조건 변수 객체

import threading
import time

shared_number = 0

def thread_1(number, cv, que):
    global shared_number

    for _ in range(number):
        cv.acquire()
        while len(que) < 1: 
            cv.wait()       
        que.pop()
        shared_number += 1

def thread_2(number, cv, que):
    global shared_number

    for _ in range(number):
        cv.acquire()
        que.append(shared_number)
        shared_number += 1
        cv.notify()
        cv.release()

if __name__ == "__main__":
    threads = [ ]
    que = []
    start_time = time.time()
    tc = threading.Condition()
    t1 = threading.Thread( target= thread_1, args=(50000000,tc,que) )
    t1.start()
    threads.append(t1)

    t2 = threading.Thread( target= thread_2, args=(50000000,tc,que) )
    t2.start()
    threads.append(t2)

    for t in threads:
        t.join()

    print("--- %s seconds ---" % (time.time() - start_time))
    print("shared_number=",end=""), print(shared_number)
    print("end of main")

• tc = threading.Condition(): condition 객체 생성
• condition 객체가 이용될 곳에 with문으로 작성.
• 이전의 뮤텍스와의 차이점으로는 먼저 wait()과 notify() 메소드가 추가되었다는 것이다. wait()은 접근 가능한 개체가 생길 때까지 기다리게 하는 메소드고 notify()는 그렇게 wait()하고 있는 객체가 있다면 깨우는 메소드이다. 이 때 acquire()를 통해 Lock를 먼저 가지고 있어야 한다. 그렇지 않으면 RuntimeError가 발생한다.
• wait()은 release()의 역할 또한 가능하다.
• que List는 결국 while문 안에서 계속 wait()하고 있는 것을 빠져나올 조건을 만들기 위한 장치이다.
• 생성한 tc를 thread 생성 시에 실행할 함수의 인자로 전달.

process🧐

1번

아래 참고자료인 파이썬 공식문서에서 학습한 내용에 대해서 자유롭게 블로깅( 실행해본 예제코드를 분석한 내용을 블로깅해도 좋고 이론적인 내용을 블로깅해도 좋습니다.)

from multiprocessing import Process, Queue
import time

def worker(id, number, q):
    increased_number = 0
    
    for i in range(number):
        increased_number += 1
    
    q.put(increased_number)	# put()을 통해 Queue 객체에 값을 넣는다.

    return


if __name__ == "__main__":

    start_time = time.time()
    q = Queue()	# Queue

    th1 = Process(target=worker, args=(1, 50000000, q))
    th2 = Process(target=worker, args=(2, 50000000, q))

    th1.start()
    th2.start()
    th1.join()
    th2.join()


    print("--- %s seconds ---" % (time.time() - start_time))
    q.put('exit')

    total = 0
    while True:
        tmp = q.get()
        if tmp == 'exit':
            break
        else:
            total += tmp

    print("total_number=",end=""), print(total)
    print("end of main")

Process

threading을 사용할 때와 거의 동일하다.

Pool()

Pool 클래스는 작업자 프로세스 풀을 나타낸다.

from multiprocessing import Pool

def f(x):
	return x*x
    
if __name__ = '__main__':
	with Pool(processes = 4) as pool:
    
    	print(pool.map(f,range(10)))

위의 코드는 다음 코드와 같은 코드이다.

def f(x):
	return x*x
    
if __name__ = '__main__':
	pool = Pool(processes = 4)
    print(pool.map(f,range(10)))

• pool을 이용해 4개의 프로세스가 병렬처리로 돌아가도록 하는 것이다. 위의 코드에서는 같은 작업을 4번을 동시에 돌아가게 하는 것이다. 숫자가 작을 때는 속도에 별 차이가 없을 수 있으나 데이터 양이 방대해지면 그 차이는 어마어마하다고 한다.

프로세스 사이에 의사소통할 수 있는 두 가지 타입이 존재한다. Queue와 Pipe가 해당된다.

Queue()

Queue는 q.put()을 통해 값을 넣고 q.get()을 통해 값을 얻는다. 위의 코드를 살펴보면 q에 각각의 증가된 숫자를 입력하고 마지막 부분의 while문을 통해 tmp에 값을 담고 total에 더해서, 즉 각각 50000000의 숫자를 더해 100000000이라는 total갑을 얻게 된다.

Pipe()

Pipe는 한 쌍의 객체를 생성하는데 아래 코드를 먼저 살펴보자.

from multiprocessing import Process, Pipe

def f(conn):
    conn.send([42, None, 'hello'])
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"
    p.join()

parent_conn과 child_conn이 한 쌍의 연결된 객체이다. 즉 child_conn에서 send()를 통해 값을 입력하고 parent_conn을 통해 값을 얻는다. 즉 각각 연결된 객체이다. 하지만 같은 쪽에서 읽고 쓰는 작업을 동시에 진행하려고 한다면 데이터의 손상을 발생시킬 수 있다.

2번

위의 코드 기반으로 아래 파이썬 공식 문서를 학습한후, IPC방식중 공유 메모리 방식으로 두개의 프로세스로 50000000씩 증가시키고 공유 메모리를 사용해서 세마포어로 동기화 시켜 최종 값으로 1억을 만드는 코드를 구현해 보세요.

from multiprocessing import Process, Semaphore, shared_memory
import time
import numpy as np

def worker(id, number, a, s, shm):
    increased_number = 0
    for i in range(number):
        increased_number += 1

    s.acquire()
    ex_shm = shared_memory.SharedMemory(name=shm)
    c = np.ndarray(a.shape, dtype=a.dtype, buffer=ex_shm.buf)
    c[0] += increased_number
    s.release()

    return

if __name__ == "__main__":

    start_time = time.time()
    a = np.array([0])
    shm = shared_memory.SharedMemory(create = True, size = a.nbytes)
    b = np.ndarray(a.shape, dtype=a.dtype, buffer=shm.buf)
    s = Semaphore()
    th1 = Process(target=worker, args=(0, 50000000, a, s, shm.name))
    th2 = Process(target=worker, args=(1, 50000000, a, s, shm.name))

    th1.start()
    th2.start()
    th1.join()
    th2.join()

    print("--- %s seconds ---" % (time.time() - start_time))
    print('exit')


    print("total_number=",end=""), print(b[0])
    print("end of main")
    
    shm.close()
    shm.unlink()

• main 안에서 공유 메모리 블록을 생성하고 그 안에 numpy배열을 사전에 만들어서 값을 넣어둔 a와 동일한 형식으로 생성한 후 각각의 프로세스의 numpy 배열의 환경과 공유 메모리 블록의 이름을 넘겨주어 연결된 환경을 생성할 수 있도록 한다.
• 그 이유는 프로세스는 각기 다른 작업 공간을 가지고 있기에 메모리 할당 또한 각각 다른 영역에 할당된다. 그렇기에 각각의 프로세스에 하나의 공유 메모리와 연결될 수 있도록 공유 메모리 블록을 연결하고 그 안에 같은 형식의 배열을 만들어 그 배열의 값을 통해 연산을 하고 동기화가 이루어질 수 있도록 한다.
• 세마포어는 뮤텍스와 유사한 개념으로 세마포어 생성 시 프로세스의 접근 가능 갯수를 1로 설정하면 뮤텍스와 동일하다. 2로 설정하면 2개의 프로세스가 같은 데이터에 접근 가능하다. 즉 접근 가능한 개수를 설정할 수 있다.
• ndarray는 기존 파이썬과는 다르게 오직 같은 종류의 데이터만을 리스트에 담을 수 있다.

shared_memory

이 모듈은 멀티 코어나 대칭 멀티 프로세서 (SMP) 기계에서 하나 이상의 프로세스가 접근할 공유 메모리의 할당과 관리를 위한 클래스 SharedMemory를 제공합니다.

class multiprocessing.shared_memory.SharedMemory(name=None, create=False, size=0)

• name이 None으로 객체를 생성하면 새로운 공유 메모리 블록을 생성한다. 하지만 name에 기존에 생성되어 있는 공유 메모리 블록의 이름을 넣으면 기존의 공유 메모리 블록과 연결된 객체를 생성하게 된다.
• create는 True일 경우 새로운 공유 메모리 블록을 만드는 것이고 False일 경우 기존 공유 메모리 블록을 연결한다는 것이다.
• size는 새 공유 메모리 블록을 만들 때 요청된 바이트 수를 지정한다. 기본 메모리 블록과 연결할 때는 size 매개변수가 무시된다.
• close()를 통해 공유 메모리에 대한 액세스를 닫아야 한다. 자원을 적절히 정리하기 위해서 더는 필요하지 않으면 모든 인스턴스가 close()를 해야한다.
• unlink()는 모든 프로세스 전체에서 단 한 번만 호출해야한다. unlink()가 호출된 후에는 공유 메모리 블록이 즉시 파괴된다. 마지막 프로세스는 unlink()와 close()를 어느 순서로든 호출할 수 있다.
• buf: 공유 메모리 블록의 내용에 대한 메모리 뷰
• name: 공유 메모리 블록의 고유한 이름에 대한 읽기 전용 액세스
• size: 공유 메모리 블록의 크기(바이트)에 대한 읽기 전용 액세스

NumPy란?

Numerical Python의 줄임 말로써 고성능의 수치 계산을 하기 위해 만들어진 C언어로 구현된 python package이다. 파이썬을 이용한 데이터 분석을 하기 위해서는 pandas 뿐만 아니라 numpy를 익혀야만 보다 호율적인 데이터 분석이 가능하다. ndarray는 성능향상을 위해 같은 데이터타입만을 요소로 가질 수 있고, 크기 역시 고정되어 있다. 만약 크기를 변경하면 새로 메모리에 할당되고 이전 값은 삭제된다.

• numpy shape(arr.shape): numpy에서는 해당 array의 크기를 알 수 있다. shape 을 확인함으로써 몇개의 데이터가 있는지, 몇 차원으로 존재하는지 등을 확인할 수 있다.

• numpy 자료형(arr.dtype)
  부호가 있는 정수 int(8, 16, 32, 64)
  부호가 없는 정수 uint(8 ,16, 32, 54)
  실수 float(16, 32, 64, 128)
  복소수 complex(64, 128, 256)
  불리언 bool
  문자열 string
  파이썬 오프젝트 object
  유니코드 unicode

coroutine🧐

1번

1. 첫번째 예제 코드는 greeting에 문자열이 send 보낼때 마다 계속 더해지는 문제가 있습니다. 다음과 같이 send 호출시마다 good morning, good afternoon, good evening 이 출력되도록 코드를 수정해보세요

print(cr.send("morning")) → good morning
print(cr.send("afternoon")) → good afternoon
print(cr.send("evening")) → good evening

import time

def coroutine_test():
    greeting = "good "
    while True:
        text = (yield greeting)
        print("text = ",end=""), print(text)
        greeting = "good "	# 이 코드를 추가함
        greeting += text


if __name__ == "__main__":
    cr = coroutine_test()
    print("cr=",end=""), print(cr)

    next(cr)
    time.sleep(2)

    print("send 1")
    print(cr.send("morning"))
    time.sleep(2)

    print("send 2")
    print(cr.send("afternoon"))
    time.sleep(2)

    print("send 3")
    print(cr.send("evening"))
    time.sleep(2)

• 수정 전 후의 출력 화면

2번

asyncio 에 대해서 학습한 후 두번째 코드를 coroutine 과 asyncio 를 활용하여 구현해 보세요.

import time
import asyncio

async def coroutine_test(num, a):
    greeting = "good "
    await asyncio.sleep(2)
    print(f"send {num}")
    print("text = ",end=""), print(a)
    greeting += a
    print(greeting)

if __name__ == "__main__":
    L = ["morning","afternoon","evening"]
    loop = asyncio.get_event_loop()
    loop.run_until_complete(coroutine_test(1, L[0]))
    loop.run_until_complete(coroutine_test(2, L[1]))
    loop.run_until_complete(coroutine_test(3, L[2]))
    loop.close()

• 제너레이터 기반의 코루틴과 asyncio 기반의 코루틴 출력 결과

3번

제너레이터 기반의 코루틴

제너레이터 기반 코루틴에 대한 지원은 폐지되었고 파이썬 3.10에서 삭제될 예정입니다.(공식 문서)

코루틴은 함수가 종료되지 않은 상태에서 메인 루틴의 코드를 실행한 뒤 다시 돌아와서 코루틴의 코드를 실행합니다. 따라서 코루틴이 종료되지 않았으므로 코루틴의 내용도 계속 유지됩니다.

1번에 해당하는 코드로 생각하는 것이 편하다. while문 속에서 무한히 반복하면서 yield부분에서 값이 들어오기를 대기하고 있는 상황이다.

1번 코드에서 next(cr) 부분이 그림의 최초 호출에 해당하고 yield에 도달했을 때 값이 들어오길 기다렸다가 메인 루틴에서 send를 통해 값을 전달받으면 다음 코드를 진행하고 다시 yield를 통해 값을 내보내면서 다시 대기 상태로 들어간다.

close()를 통해 코루틴을 종료할 수 있고 throw로 에러를 발생시켜 종료시킬 수도 있다.

yield from에 코루틴를 지정하면 해당 코루틴에서 return으로 반환한 값을 가져온다. 또한 코루틴에서 yield from을 사용하면 코루틴 바깥에서 send로 하위 코루틴까지 값을 보낼 수 있다. (아래 코드 참고)(출처:파이썬 코딩 도장)

def accumulate():
    total = 0
    while True:
        x = (yield)         # 코루틴 바깥에서 값을 받아옴
        if x is None:       # 받아온 값이 None이면
            return total    # 합계 total을 반환
        total += x
 
def sum_coroutine():
    while True:
        total = yield from accumulate()    # accumulate의 반환값을 가져옴
        print(total)
 
co = sum_coroutine()
next(co)
 
for i in range(1, 11):    # 1부터 10까지 반복
    co.send(i)            # 코루틴 accumulate에 숫자를 보냄
co.send(None)             # 코루틴 accumulate에 None을 보내서 숫자 누적을 끝냄
 
for i in range(1, 101):   # 1부터 100까지 반복
    co.send(i)            # 코루틴 accumulate에 숫자를 보냄
co.send(None)             # 코루틴 accumulate에 None을 보내서 숫자 누적을 끝냄

asyncio 기반의 코루틴

async/await 문법으로 선언된 코루틴은 asyncio 응용 프로그램을 작성하는 기본 방법입니다. asyncio 기반으로 만들어진 코루틴을 네이티브 코루틴이라고 한다.

먼저 asyncio는 async/await 구문을 사용하여 동시성 코드를 작성하는 라이브러리입니다. asyncio는 고성능 네트워크 및 웹 서버, 데이터베이스 연결 라이브러리, 분산 작업 큐 등을 제공하는 여러 파이썬 비동기 프레임워크의 기반으로 사용됩니다. asyncio는 종종 IO 병목이면서 고수준의 구조화된 네트워크 코드에 가장 적합합니다.

• 동기 처리 vs 비동기 처리(출처: 코딩도장)

네이티브 코루틴 만들기

async def 함수이름():
	코드

어웨이터블

await 표현식에서 사용될 수 있을 때 어웨이터블 객체라고 말합니다. 코루틴, 태스크, 퓨처

코루틴

파이썬 코루틴은 어웨이터블로 다른 코루틴에서 기다릴 수 있다.

import asyncio

async def nested():
    return 42

async def main():
    nested()	# 그냥 호출만 한 상태로 실행되지는 않는다.
    print(await nested())	# nested()가 끝날 때까지 기다렸다가 끝나면 42가 프린트 될 예정
    
asyncio.run(main())	# 메인을 실행시켜서 nested()를 실행시키고 42를 프린트 함

• 코루틴 함수: async def 함수;
• 코루틴 객체: 코루틴 함수를 호출하여 반환된 객체.

태스크

태스크는 코루틴을 동시에 예약하는데 사용된다. 코루틴이 asyncio.create_task()와 같은 함수를 사용하여 태스크로 싸일 때 코루틴은 곧 실행되도록 자동으로 예약된다.

import asyncio

async def nested():
    return 42

async def main():
	# asyncio.create_task() 태스크 만들기 함수
    task = asyncio.create_task(nested())	# 예약
    await task	task가 끝날 때까지 기다림

asyncio.run(main())

• 태스크(asyncio.Task)는 asyncio.Future의 파생 클래스이며 asyncio.Future의 기능과 실행할 코루틴의 객체를 포함하고 있습니다. 태스크는 코루틴의 실행을 취소하거나 상태 확인, 완료 및 결과 설정에 사용합니다.

퓨처

Future는 비동기 연산의 최종 결과를 나타내는 특별한 저수준 어웨이터블 객체입니다. Future 객체를 기다릴 때, 그것은 코루틴이 Future가 다른 곳에서 해결될 때까지 기다릴 것을 뜻합니다. 콜백 기반 코드를 async/await와 함께 사용하려면 asyncio의 Future 객체가 필요합니다. 일반적으로 응용 프로그램 수준 코드에서 Future 객체를 만들 필요는 없습니다. 때때로 라이브러리와 일부 asyncio API에 의해 노출되는 Future 객체를 기다릴 수 있습니다. Future 객체를 반환하는 저수준 함수의 예는 loop.run_in_executor()이다.

async def main():
    await function_that_returns_a_future_object()

    # this is also valid:
    await asyncio.gather(
        function_that_returns_a_future_object(),
        some_python_coroutine()
    )

• 퓨처(asyncio.Future)는 미래에 할 일을 표현하는 클래스인데 할 일을 취소하거나 상태 확인, 완료 및 결과 설정에 사용합니다.

asyncio 프로그램 실행하기

asyncio.run(coro, *, debug=False)

• 코루틴 coro를 실행하고 결과를 반환합니다. 이 함수는 전달된 코루틴을 실행하고, asyncio 이벤트 루프와 비동기 제너레이터의 파이널리제이션을 관리합니다. 다른 asyncio 이벤트 루프가 같은 스레드에서 실행 중일 때, 이 함수를 호출할 수 없습니다.
• debug이 True면, 이벤트 루프가 디버그 모드로 실행됩니다.
• 이 함수는 항상 새 이벤트 루프를 만들고 끝에 이벤트 루프를 닫습니다. asyncio 프로그램의 메인 진입 지점으로 사용해야 하고, 이상적으로는 한 번만 호출해야 합니다.

sleep

asyncio.sleep(delay, result=None, *, loop=None)

• delay 초 동안 블록합니다.
• result가 제공되면, 코루틴이 완료될 때 호출자에게 반환됩니다.
• sleep()은 항상 현재 태스크를 일시 중단해서 다른 태스크를 실행할 수 있도록 합니다.

동시에 태스크 실행하기

asyncio.gather(*aws, loop=None, return_exceptions=False)

• aws 시퀀스에 있는 어웨이터블 객체를 동시에 실행합니다. aws에 있는 어웨이터블이 코루틴이면 자동으로 태스크로 예약됩니다. 모든 어웨이터블이 성공적으로 완료되면, 결과는 반환된 값들이 합쳐진 리스트입니다. 결괏값의 순서는 aws에 있는 어웨이터블의 순서와 일치합니다.
• return_exceptions가 False(기본값)면, 첫 번째 발생한 예외가 gather()를 기다리는 태스크로 즉시 전파됩니다. aws 시퀀스의 다른 어웨이터블은 취소되지 않고 계속 실행됩니다. return_exceptions가 True면, 예외는 성공적인 결과처럼 처리되고, 결과 리스트에 집계됩니다.
• gather()가 취소되면, 모든 제출된 (아직 완료되지 않은) 어웨이터블도 취소됩니다. aws 시퀀스의 Task나 Future가 취소되면, 그것이 CancelledError를 일으킨 것처럼 처리됩니다 – 이때 gather() 호출은 취소되지 않습니다. 이것은 제출된 태스크/퓨처 하나를 취소하는 것이 다른 태스크/퓨처를 취소하게 되는 것을 막기 위한 것입니다.

이벤트 루프

이벤트 루프 얻기

asyncio.get_running_loop()

• 현재 OS 스레드에서 실행 중인 이벤트 루프를 반환합니다.

asyncio.get_event_loop()

• 현재의 이벤트 루프를 가져옵니다.

asyncio.set_event_loop(loop)

• loop를 현재 OS 스레드의 현재 이벤트 루프로 설정합니다.

asyncio.new_event_loop()

• 새 이벤트 루프 객체를 만듭니다.

루프 실행 및 중지

loop.run_until_complete(future)

• future(Future의 인스턴스)가 완료할 때까지 실행합니다. 인자가 코루틴 객체 면, asyncio.Task로 실행되도록 묵시적으로 예약 됩니다.

loop.close()

• 이벤트 루프를 닫습니다. 이 함수를 호출할 때 루프는 반드시 실행 중이지 않아야 합니다. 계류 중인 모든 콜백을 버립니다. 이 메서드는 모든 큐를 비우고 실행기를 종료하지만, 실행기가 완료할 때까지 기다리지 않습니다.