🤍

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

<이전 글>

https://silvercoding.tistory.com/31

< Asyncio 참고문서 >

https://docs.python.org/ko/3/library/asyncio.html

- Asyncio 

: 비동기 I/O Coroutine 작업 ( *동기: 기다려야 하는 것 , 비동기: 기다리지 않고 바로 실행되는 것) 

: Generator : 반복적인 객체 Return (yield) , 즉, 실행하고 stop -> 다른 작업으로의 위임 -> stop 지점부터 재 실행하는 원리이다. 

: Non-Blocking 비동기 처리에 적합하다. 

* 본 포스팅에서 실습할 방법들 

1. 순차실행 

2. 쓰레드만 사용 

3. 코루틴에서 쓰레드 우회 사용 

- 1. BlockIO 예제  : 순차실행 

import timeit
from urllib.request import urlopen

필요한 라이브러리 import 하기 

urls = ['http://daum.net', 'https://google.com', 'https://apple.com', 'https://tistory.com', 'https://github.com', 'https://naver.com']

예제에서 url을 open해 보는 실습을 할 것이기 때문에 url 리스트를 만들어 준다. 총 6 개의 url을 넣어 주었다. 

start = timeit.default_timer()

순차 실행을 하기 전 시간을 기록해 둔다. 이번에는 timeit.default_timer()를 이용하여 시간을 측정한다. 

* 순차 실행부 

for url in urls:
    print('Start', url)
    # 실제 요청 
    text = urlopen(url)
    # 실제 내용
    # print('Contents', text.read())
    print('Done', url)

위와 같이 urlopen을 사용하여 url에 실제 요청을 한다. 

* 시간 측정 : 완료시간 - 시작시간 / 결과 출력

duration = timeit.default_timer() - start

# 총 실행시간 
print('Total Time', duration)

 Start http://daum.net 
 Done http://daum.net 
 Start https://google.com 
 Done https://google.com 
 Start https://apple.com 
 Done https://apple.com 
 Start https://tistory.com 
 Done https://tistory.com 
 Start https://github.com 
 Done https://github.com 
 Start https://naver.com 
 Done https://naver.com 
 Total Time 12.8696096 

순차적으로 url리스트에 적었던 순서대로 url요청이 된 것을 볼 수 있다. 시간은 총 13초 정도가 걸렸다. 

*** BlockIO : Thread 사용 

: 쓰레드 개수 및 GIL 문제 염두, 공유 메모리 문제 해결 (뮤텍스)

- 2. Thread만 사용 

* 필요한 라이브러리 import 

import timeit
from urllib.request import urlopen
from concurrent.futures import ThreadPoolExecutor
import threading

* url 리스트 생성 및 시간 기록 

urls = ['http://daum.net', 'https://google.com', 'https://apple.com', 'https://tistory.com', 'https://github.com', 'https://naver.com']

start = timeit.default_timer()

* fetch 함수 선언

def fetch(url):
    print('Thread Name : ', threading.current_thread().getName(), 'Start', url)  # 현재 쓰래드가 무엇인지 알려줌
    urlopen(url)
    print('Thread Name : ', threading.current_thread().getName(), 'Done', url)

현재 쓰레드의 이름과 , 시작(start) 과 완료(Done)의 과정을 출력하도록 하는 fetch 함수를 생성한다. 

* main 함수 선언 - fetch함수 사용 

def main():
    with ThreadPoolExecutor(max_workers=10) as executor: 
        for url in urls:
            executor.submit(fetch, url)

ThreadPoolExecutor를 사용하고, max_workers는 10으로 받아준다. 이제 for문을 이용하여 url을 한개씩 넣어서 submit으로 fetch함수에 적용해 준다. 

* 실행 

if __name__ == '__main__':
    # 함수 실행 
    main()
    
    # 완료시간 - 시작시간
    duration = timeit.default_timer() - start

    # 총 실행시간   
    print('Total Time', duration)

 Thread Name :  ThreadPoolExecutor-0_0 Start http://daum.net 
 Thread Name :  ThreadPoolExecutor-0_1 Start https://google.com 
 Thread Name :  ThreadPoolExecutor-0_2 Start https://apple.com 
 Thread Name :  ThreadPoolExecutor-0_3 Start https://tistory.com 
 Thread Name :  ThreadPoolExecutor-0_4 Start https://github.com 
 Thread Name :  ThreadPoolExecutor-0_5 Start https://naver.com 
 Thread Name :  ThreadPoolExecutor-0_4 Done https://github.com 
 Thread Name :  ThreadPoolExecutor-0_2 Done https://apple.com 
 Thread Name :  ThreadPoolExecutor-0_5 Done https://naver.com 
 Thread Name :  ThreadPoolExecutor-0_3 Done https://tistory.com 
 Thread Name :  ThreadPoolExecutor-0_0 Done http://daum.net 
 Thread Name :  ThreadPoolExecutor-0_1 Done https://google.com 
 Total Time 0.9581279 

start는 for문에 들어간 순서대로 출력이 되었는데, Done은 순서가 일정하지 않은 것을 볼 수 있다. submit 함수는 먼저 일이 끝나는 순서대로 오는 것일 뿐, 순서에 대한 신경을 쓰지 않기 때문이다.  시간은 1초도 되지 않는다! 굉장히 줄어 든 것을 볼 수 있다. 

- 3. 코루틴에서 쓰레드 우회 사용 

<참고>

https://docs.python.org/ko/3/library/asyncio-task.html

*** 코루틴은 단일 쓰레드라는 것이 핵심이다. 함수 여러개를 생성하여 멀티 쓰레드를 사용하는 듯 보이게 해준다. 단일 쓰레드에서 최적의 성능을 이끌어내기 위해 제어를 양보하여 사용하며, 빠르게 동시성 기법을 활용하는 패턴이다. 

* 필요한 라이브러리 import 

# aiohttp 사용 가능 (Asyncio 지원)
from concurrent import futures
import timeit
from urllib.request import urlopen
from concurrent.futures import ThreadPoolExecutor
import threading
import asyncio

* url 리스트 생성 및 시간 기록 

urls = ['http://daum.net', 'https://google.com', 'https://apple.com', 'https://tistory.com', 'https://github.com', 'https://naver.com']
start = timeit.default_timer()

* fetch 함수 선언 

async def fetch(url, executor):
    print('Thread Name : ', threading.current_thread().getName(), 'Start', url)  # 현재 쓰래드가 무엇인지 알려줌
    res = await loop.run_in_executor(executor, urlopen, url) # (일꾼, 일꾼이 처리할 함수, 해야될 일 (사이트)) / loop 안에는 futures가 들어가 있음 . 
    print('Thread Name : ', threading.current_thread().getName(), 'Done', url)
    return res.read()[0:5]

https://silvercoding.tistory.com/30

위의 포스팅에서 yield from을 공부하였다. 버전 3.7? 이상 부터 await 으로 바뀌었고 , 본 포스팅에서는 await을 사용한다. 

<loop 참고 문서>

https://docs.python.org/ko/3/library/asyncio-eventloop.html

* main 함수 선언 

async def main():
    # 쓰레드 풀 생성 
    executor = ThreadPoolExecutor(max_workers=10)
    # asyncio.ensure_future 
    futures = [asyncio.ensure_future(fetch(url, executor)) for url in urls]
    # await = yield from 
    rst = await asyncio.gather(*futures)  # unpacking

    print()
    print('Result : ', rst)

지능형 리스트인 futures를 선언한다. asyncio.ensure_future에 fetch함수를 적용한다. 

* 결과 실행 

if __name__ == '__main__':
    # 루프 생성 
    loop = asyncio.get_event_loop()
    # 루프 대기 
    loop.run_until_complete(main())
    # 함수 실행 
    main()   

    # 완료시간 - 시작시간
    duration = timeit.default_timer() - start

    # 총 실행시간   
    print('Total Time', duration)

 Thread Name :  MainThread Start http://daum.net 
 Thread Name :  MainThread Start https://google.com 
 Thread Name :  MainThread Start https://apple.com 
 Thread Name :  MainThread Start https://tistory.com 
 Thread Name :  MainThread Start https://github.com 
 Thread Name :  MainThread Start https://naver.com 
 Thread Name :  MainThread Done https://github.com 
 Thread Name :  MainThread Done https://apple.com 
 Thread Name :  MainThread Done https://naver.com 
 Thread Name :  MainThread Done https://tistory.com 
 Thread Name :  MainThread Done http://daum.net 
 Thread Name :  MainThread Done https://google.com 

 Result :  [b'<!DOC', b'<!doc', b'\n\t\n\n\n', b'\n\t<!d', b'\n\n\n\n\n', b'\n<!do'] 
 c:/Users/./Desktop/python_high/chapter06_04_03.py:57: RuntimeWarning: coroutine 'main' was never awaited 
  main() 
 RuntimeWarning: Enable tracemalloc to get the object allocation traceback       
 Total Time 1.3151724 

마찬가지로 순서에 상관 없이 일을 하며, 시간은 2번방법보다는 오래 걸리지만 그래도 1.3초로 빠르게 실행된 것을 볼 수 있다. 

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

<이전 글>

https://silvercoding.tistory.com/30

* Future 동시성 / 비동기 작업 실행 

: 지연시간 (Block) CPU 및 리소스 낭비 방지 -> (FILE) Network I/O관련 작업 동시성 활용 권장 

: 적합한 작업일 경우 순차 진행보다 압도적으로 성능 향상 

* 이번 포스팅에서 실습할 3가지 

1. 순차 실행 

2. concurrent.futures 방법1 

3. concurrent.futures 방법 2 

import os 
import time # 성능측정 
import sys
import csv

# 국가 정보 
NATION_LS = ('Singapore Germany Israel Norway Italy Canada France Spain Maxico').split()
# 초기 CSV 위치 
TARGET_CSV = './resources/nations.csv'
# 저장 폴더 위치 
DEST_DIR = './csvs'
# CSV 헤더 기초 정보 
HEADER = ['Region','Country','Item Type','Sales Channel','Order Priority','Order Date','Order ID','Ship Date','Units Sold','Unit Price','Unit Cost','Total Revenue','Total Cost','Total Profit']

<csv 파일 : 패스트 캠퍼스 제공>

NATION_LS : 사용할 국가 이름 리스트 

TARGET_CSV : csv파일이 있는 위치 경로 

DEST_DIR : 최종적으로 csv파일이 저장될 폴더 위치 경로 

HEADER : csv의 헤더를 추출 해놓은 리스트 

- 1. 순차실행 예제 

포스팅에서는 차례대로 함수를 작성하지만 공부할 때는 뒤에서부터( (6) 부터 ) 거슬러오며 공부하기

(1) 국가별 CSV 파일 저장 

def save_csv(data, filename):
    # 최종 경로 생성 
    path = os.path.join(DEST_DIR, filename)

    with open(path, 'w', newline="") as fp:
        writer = csv.DictWriter(fp, fieldnames=HEADER)
        # Header Write
        writer.writeheader()
        # Dict to CSV write
        for row in data: 
            writer.writerow(row)

최종 csv파일을 저장하는 함수이다. 국가별로 만들어진 데이터(data)와 생성할 파일이름(filename)을 인자로 받는다. 

(2) 국가별 분리 

def get_sales_data(nt):
    with open(TARGET_CSV, 'r') as f:
        reader = csv.DictReader(f)
        # Dict를 리스트로 적재 
        data = []
        # Header 확인 
        # print(reader.fieldnames)
        for r in reader:
            # OrderedDict 확인 
            # print(r)
            # 조건에 맞는 국가만 삽입 
            if r['Country'] == nt:
                data.append(r)
    return data

국가의 이름(nt)을 인자로 받는다. csv파일을 열어서 DictReader로 reader에 받아준다. Country가 nt국가일 때 data리스트에 r을 넣어준다.  이렇게 국가별로 데이터를 분리해 주는 함수이다. 

(3) 중간 상황 출력

def show(text):
    print(text, end=' ')
    # 중간 출력 (버퍼 비우기)
    sys.stdout.flush()

국가의 이름을 받아서 터미널에 출력해 주어 진행상황을 알려주는 함수이다. 

(4) 국가 별 분리 함수 실행 - (1) , (2) , (3) 함수 사용

def separate_many(nt_list):
    for nt in sorted(nt_list):
        # 분리 데이터 
        data = get_sales_data(nt)
        # 상황 출력 
        show(nt)
        # 파일 저장 
        save_csv(data, nt.lower() + '.csv')

    return len(nt_list)

여기서 for문으로 각 국가별 이름을 앞에서 보았던 get_sales_data에 넣어주어 분리된 데이터를 csv파일로 저장해주는 함수를 만든다. show함수로 진행상황을 출력하고, save_csv함수로 각 국가별 csv파일 데이터를 저장한다. 

(5) 시간 측정 및 메인함수 - (4) 함수 사용

def main(separate_many):
    # 시작 시간 
    start_tm = time.time()
    # 결과 건수 
    result_cnt = separate_many(NATION_LS)
    # 종료 시간 
    end_tm = time.time() - start_tm 

    msg = '\n{} csv separated in {:.2f}s'

    # 최종 결과 출력 
    print(msg.format(result_cnt, end_tm))

드디어 main함수에서는 separate_many함수를 사용하여 국가별 csv파일을 생성하도록 하고 , 이에 대한 시간을 측정하여 출력해준다. 

(6) 실행 - (5) 함수 사용

if __name__ == '__main__':
    main(separate_many)

Canada France Germany Israel Italy Maxico Norway Singapore Spain
9 csv separated in 21.09s

이렇게 main함수를 사용해 주면 앞에서 만들어 놓았던 함수들이 모두 실행되며 

국가별 csv 파일이 모두 만들어 진다. 

*** Google Python GIL (Global Interpreter Lock) 

: GIL은 한 번에 하나의 스레드만 수행할 수 있게 인터프리터 자체에서 락을 거는 것이다. 

<python GIL 관련문서>

https://wiki.python.org/moin/GlobalInterpreterLock

- 2. concurrent.futures 방법1 (ThreadPoolExecutor, ProcessPoolExecutor)

<concurent.futures 참고문서>

https://docs.python.org/ko/3.7/library/concurrent.futures.html

: map() 사용

: 서로 다른 스레드 또는 프로세스에서 실행 가능 

: 내부 과정을 알 필요가 없으며 , 고수준으로 인터페이스를 제공함 . 

...
from concurrent import futures

concurrent의 futres 를 추가로 import 해준다. 

* (1) - (3) 의 함수는 앞과 동일하다. 

(1) 국가별 CSV 파일 저장 

def save_csv(data, filename):
    # 최종 경로 생성 
    path = os.path.join(DEST_DIR, filename)

    with open(path, 'w', newline="") as fp:
        writer = csv.DictWriter(fp, fieldnames=HEADER)
        # Header Write
        writer.writeheader()
        # Dict to CSV write
        for row in data: 
            writer.writerow(row)

(2) 국가별 분리

def get_sales_data(nt):
    with open(TARGET_CSV, 'r') as f:
        reader = csv.DictReader(f)
        # Dict를 리스트로 적재 
        data = []
        # Header 확인 
        # print(reader.fieldnames)
        for r in reader:
            # OrderedDict 확인 
            # print(r)
            # 조건에 맞는 국가만 삽입 
            if r['Country'] == nt:
                data.append(r)
    return data

(3) 중간 상황 출력

def show(text):
    print(text, end=' ')
    # 중간 출력 (버퍼 비우기)
    sys.stdout.flush()

(4) 국가 별 분리 함수 실행 - (1) , (2) , (3) 함수 사용

def separate_many(nt):
    # 분리 데이터 
    data = get_sales_data(nt)
    # 상황 출력 
    show(nt)
    # 파일 저장 
    save_csv(data, nt.lower() + '.csv')

    return nt

1번 방법인 순차실행에서는 for문을 이용하여 국가별 csv파일을 만들어냈다. 2번 방법에서는 map함수를 사용하여 국가 이름 리스트를 받지 않고 , 국가이름 하나씩을 받아 csv파일로 저장한다.  최종적으로 국가이름 하나(nt)를 리턴하도록 만든다.

(5) 시간 측정 및 메인 함수

futures.ThreadPoolExecutor() / futures.ProcessPoolExecutor 

 - ThreadPoolExecutor : GIL 종속 

def main(separate_many):
    # worker 개수
    worker = min(20, len(NATION_LS))
    # 시작 시간
    start_tm = time.time()
    # 결과 건수
    with futures.ThreadPoolExecutor(worker) as excutor:
        # map -> 작업 순서 유지, 즉시 실행
        result = excutor.map(separate_many, sorted(NATION_LS))
    # 종료 시간
    end_tm = time.time() - start_tm

    msg = '\n{} csv separated in {:.2f}s'
    # 최종 결과 출력
    print(msg.format(len(list(result)), end_tm))
    
    
# 실행
if __name__ == '__main__':
    main(separate_many)

 France Norway Spain Germany Maxico Canada Singapore Israel Italy 
 9 csv separated in 21.61s 

worker 라는 일꾼 변수를 만들어 주고, ThreadPoolExecutor()의 인자에 넣어준다. 여기서 result는 제너레이터 객체로 저장된다. 따라서 최종결과 출력에서 리스트의 길이를 알기 위해 result를 list 타입으로 바꿔주어야 한다. 

만약 그냥 len(result)로 작성한다면 !

 File "c:/Users/./Desktop/python_high/chapter06_03_02.py", line 100, in main  
    result_cnt = len(excutor.map(separate_many, sorted(NATION_LS))) 
 TypeError: object of type 'generator' has no len() 

제너레이터는 len() 를 갖지 않는다는 예외가 발생한다. 

- ProcessPoolExecutor : GIL 우회, 변경 후 -> 내부적으로 os.cpu_count() 메소드 호출 (운영체제 자체에서 우회에서 감 -> 속도가 빠름 )

def main(separate_many):
    # worker 개수
    worker = min(20, len(NATION_LS))
    # 시작 시간
    start_tm = time.time()
    # 결과 건수
    with futures.ProcessPoolExecutor() as excutor:
        # map -> 작업 순서 유지, 즉시 실행
        result = excutor.map(separate_many, sorted(NATION_LS))
    # 종료 시간
    end_tm = time.time() - start_tm

    msg = '\n{} csv separated in {:.2f}s'
    # 최종 결과 출력
    print(msg.format(len(list(result)), end_tm))
    
  
# 실행
if __name__ == '__main__':
    main(separate_many)

 Norway Canada Germany France Spain Singapore Italy Maxico Israel 
 9 csv separated in 8.11s 

같은 방법으로 ProcessPoolExecutor를 해본다. 시간이 훨씬 단축된 것을 볼 수 있다. 

언제 ProcessPoolExecutor쓰고, ThreadPoolExecutor쓰고, 코루틴을 쓰는지를 생각해야 한다. ProcessPoolExecutor쓰면 cpu 사용량이 급격히 증가하고 빠른 결과가 나온다. 그래서 이러한 멀티 프로세싱은 단기간의 딥러닝 고속 연산에 사용하는 것이 좋다. ThreadPoolExecutor사용하면 속도는 더 걸리지만 cpu 사용량은 잔잔하게 증가한다. 이 두가지의 차이를 구분하고 , 적절히 사용해야 한다. 

- 3. concurrent.futures 방법2 (map()함수 대신 for문을 이용하여 세부적인 과정 찍어보기) 

* (1) - (3) 의 함수는 앞과 동일하다. 

(4) 국가 별 분리 함수 실행 - (1) , (2) , (3) 함수 사용

def main(separate_many):
    # worker 개수
    worker = min(20, len(NATION_LS))
    # 시작 시간
    start_tm = time.time()
    # futures 
    futures_list = []
    # 결과 건수
    # ProcessPoolExecutor : GIL 우회, 변경 후 -> 내부적으로 os.cpu_count() 메소드 호출 (운영체제 자체에서 우회에서 감)
    # ThreadPoolExecutor : GIL 종속 
    # with futures.ThreadPoolExecutor(worker) as excutor:
    with futures.ProcessPoolExecutor() as excutor:
        # submit -> callable 객체 스케쥴링(실행 예약) -> future 
        # Future -> as_complete(), result(), done(), cancelled() 주로 사용 
        for nt in sorted(NATION_LS):
            # future 반환
            future = excutor.submit(separate_many, nt)
            # 스케쥴링
            futures_list.append(future)
            # 출력 
            # print('Scheduled for {} : {}'.format(nt, future))
            # print()

        for future in futures.as_completed(futures_list):
            result = future.result()
            done = future.done()
            cancelled = future.cancelled()
            # furue 결과 확인 
            print('Future Result : {}, Done : {}'.format(result, done))
            print('Future Cancelled : {}'.format(cancelled))

    # 종료 시간
    end_tm = time.time() - start_tm

    msg = '\n{} csv separated in {:.2f}s'
    # 최종 결과 출력
    print(msg.format(len(futures_list), end_tm))

for문으로 작업을 일일이 하고, 세부적으로 진행상황과 어떻게 마무리 되었는지를 알고 싶을 때 이 방법을 쓴다. 

2번 방법에서는 map()함수를 이용하여 separate_many 함수로 국가별 csv파일을 저장해 주었다. 3번 방법에서는 submit()함수를 이용하여 futre변수에 할당해주고 , 이 future를 futures_list에 append 해준다. 

futures.as_complted()의 인자에 futures_list를 넣어주고, 각각의 future에 대한 result, done, cancelled 값을 얻을 수 있다. 

* 실행 

if __name__ == '__main__':
    main(separate_many)

 Germany Canada Future Result : Germany, Done : True 
 Future Cancelled : False 
 Norway Israel Future Result : Norway, Done : True 
 Italy Future Cancelled : False 
 Future Result : Canada, Done : True 
 Future Cancelled : False 
 Future Result : Israel, Done : True 
 Future Cancelled : False 
 Future Result : Italy, Done : True 
 Future Cancelled : False 
 Singapore France Future Result : Singapore, Done : True 
 Future Cancelled : False 
 Future Result : France, Done : True 
 Future Cancelled : False 
 Maxico Future Result : Maxico, Done : True 
 Future Cancelled : False 
 Spain Future Result : Spain, Done : True 
 Future Cancelled : False 

 9 csv separated in 8.60s 

실행을 해보면 , result는 각 국가의 이름(nt : separate_many의 리턴값), Done은 모두 True, Cancelled는 모두 False가 나와 정상적으로 작동한 것을 볼 수 있다. 이와 같이 for문과 submit함수를 사용하여 세부적인 내용을 확인할 수도 있다. 

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

<이전 글>

https://silvercoding.tistory.com/29

* 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

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

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 

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

<이전 글>

https://silvercoding.tistory.com/28

* 이번 포스팅 부터 공부할 것 : 1. 반복형 객체의 내부적으로 iter 함수 실행 내용, 2. 제너레이터 동작 원리, 3. yield from

이 중에서도 오늘은 1~2 를 포스팅 한다.  

- 파이썬 반복형 종류 

: for, collections, text file, List, Dict, Set, Tuple, unpacking, *args

 ---> 반복이 가능한 이유? -> iter(x) 함수가 호출되기 때문 

- 반복문 간단한 예제 

t = 'ABCDEF'

* for 사용 

for c in t: # 시퀀스형이기 때문에 반복이 가능하다. 
    print('EX1-1 - ', c)

 EX1-1 -  A 
 EX1-1 -  B 
 EX1-1 -  C 
 EX1-1 -  D 
 EX1-1 -  E 
 EX1-1 -  F 

* while 사용 

w = iter(t)
print(type(w))

<class 'str_iterator'>

while True:
    try:
        print('EX1-2 - ', next(w))

    except StopIteration: # 문자가 더이상 없는데 호출하면 에러가 발생하므로 
        break

 EX1-2 -  A 
 EX1-2 -  B 
 EX1-2 -  C 
 EX1-2 -  D 
 EX1-2 -  E 
 EX1-2 -  F 

iterator type으로 변경하고 , next를 호출하여 while문으로 반복을 사용하였다. 

from collections import abc

# 반복형 확인 
print('EX1-3 - ', hasattr(t, '__iter__'))  # ---> t가 __iter__ 의 속성을 갖고 있니 ? 
print('EX1-4 - ', isinstance(t, abc.Iterable)) # t가 abc의 Iterable클래스와 같은 인스턴스냐 ? ---> True --> 순회가 가능하다. 
# dir() 로도 확인 가능

 EX1-3 -  True 
 EX1-4 -  True 

반복형 타입인지 알고 싶다면 위와 같은 방법을 사용하면 된다. (hasattr(), isinstance(), dir())

- next 메소드 직접 구현 예제 

class WordSplitIter: 
    def __init__(self, text):
        self._idx = 0 
        self._text = text.split(' ')

    def __next__(self):
        # print('Called __next__')
        try:
            word = self._text[self._idx]
        except IndexError:
            raise StopIteration('stop !')
        self._idx += 1
        return word

    def __iter__(self):
        print('Called __iter__')
        return self 

    def __repr__(self):
        return 'WordSplit(%s)' % (self._text)

문장을 입력하면 띄어쓰기를 기준으로 split해서 리스트에 넣어준 _text를 생성한다. __next__메소드를 호출하면 한 단어씩 나오도록 구현한다. 

* 객체 생성 

wi = WordSplitIter('who says the nights are for sleeping')

* 사용

print('EX2-1 - ', wi)
print('EX2-2 - ', next(wi))
print('EX2-3 - ', next(wi))
print('EX2-4 - ', next(wi))
print('EX2-5 - ', next(wi))
print('EX2-6 - ', next(wi))
print('EX2-7 - ', next(wi))
print('EX2-8 - ', next(wi))
# print('EX2-9 - ', next(wi))

 EX2-1 -  WordSplit(['who', 'says', 'the', 'nights', 'are', 'for', 'sleeping']) 
 EX2-2 -  who 
 EX2-3 -  says 
 EX2-4 -  the 
 EX2-5 -  nights 
 EX2-6 -  are 
 EX2-7 -  for 
 EX2-8 -  sleeping 

주석을 제거하고 실행하면 다음과 같은 에러가 난다. 

 Traceback (most recent call last): 
  File "c:/Users/sooki/Desktop/python_high/chapter06_01.py", line 55, in __next__       
    word = self._text[self._idx] 
 IndexError: list index out of range 

 During handling of the above exception, another exception occurred: 

 Traceback (most recent call last): 
  File "c:/Users/sooki/Desktop/python_high/chapter06_01.py", line 78, in <module>       
    print('EX2-9 - ', next(wi)) 
  File "c:/Users/sooki/Desktop/python_high/chapter06_01.py", line 57, in __next__       
    raise StopIteration('stop !') 
 StopIteration: stop ! 

구현해 놓았던 에러가 나는 것을 볼 수 있다. 이와 같이 에러를 제어할 수 있다. 

- Generator 패턴 

1. 지능형 리스트, 딕셔너리, 집합 -> 데이터 셋이 증가 할 경우 메모리의 사용량이 증가한다. -> 이 점을 제너레이터가 완화해줄 수 있다. 

2. 단위 실행이 가능한 코루틴 (Coroutine) 구현에 아주 중요하다. 

3. 제너레이터를 이용하여 딕셔너리 , 리스트를 한 번 호출할 때마다 하나의 값만 리턴한다. <- 따라서 아주 작은 메모리 양을 필요로 하게 된다. (모든 자료구조를 다 저장하고 있는 것이 아니라, next가 호출될 때 값을 반환하는 것이기 때문에 메모리 차지량이 적은 것)

class WordSplitGenerator: 
    def __init__(self, text):
        self._text = text.split(' ')

    def __iter__(self):
        for word in self._text:
            yield word # 제너레이터 
        return

    def __repr__(self):
        return 'WordSplit(%s)' % (self._text)

위에서 했던 WordSplitIter클래스와 같은 기능을 하면서 제너레이터를 이용하는 클래스를 구현한다. 이 경우에는 idx변수도 필요가 없어진다. 제너레이터 패턴을 사용하기 위하여 yield 를 작성하는 것이 중요하다. next가 호출되면서 yield가 실행된 후 멈춘다. 또 다시 next가 호출되면 기억해 놓은 부분부터 실행되도록 해준다. 

*객체 생성

wg = WordSplitGenerator('who says the nights are for sleeping')
wt = iter(wg)

객체를 생성해주고, iter()함수에 객체를 넣어주어야 한다. 

print('EX3-1 - ', wt)

EX3-1 -  <generator object WordSplitGenerator.__iter__ at 0x00000218C0E87570>

이렇게 반복이 가능한 제너레이터 타입인 것을 알 수 있다. 

print('EX3-2 - ', next(wt))
print('EX3-3 - ', next(wt))
print('EX3-4 - ', next(wt))
print('EX3-5 - ', next(wt))
print('EX3-6 - ', next(wt))
print('EX3-7 - ', next(wt))
print('EX3-8 - ', next(wt))
# print('EX3-9 - ', next(wt))  # 예외 처리 자동

 EX3-2 -  who 
 EX3-3 -  says 
 EX3-4 -  the 
 EX3-5 -  nights 
 EX3-6 -  are 
 EX3-7 -  for 
 EX3-8 -  sleeping 

위에서는 예외 처리를 직접 구현하였는데, 이렇게 제너레이터를 활용하면 예외처리는 자동으로 된다. 

- Generator 예제1 

* Generator : yield를 만나면 멈춰있다가 next를 호출하면 그 다음을 실행함 

def generator_ex1():
    print('start!')
    yield 'AAA'
    print('continue')
    yield 'BBB'
    print('end')

yield로 Generator를 구현한 함수이다. 

temp = iter(generator_ex1())

print('EX4-1 - ', next(temp))
print('EX4-2 - ', next(temp))
print('EX4-3 - ', next(temp))

 start! 
 EX4-1 -  AAA 
 continue 
 EX4-2 -  BBB 
 end 
 Traceback (most recent call last): 
  File "c:/Users/sooki/Desktop/python_high/chapter06_01.py", line 136, in <module>      
    print('EX4-3 - ', next(temp)) 
 StopIteration 

yield를 만나면 멈추어 있다가 next가 호출되면 실행되는 형태이다. 4-3처럼 next를 또 하면 yield가 더이상 없기 때문에 에러가 난다. 

* for, while과 같은 반복문에서 사용이 적절함 

for v in generator_ex1():
    print('EX4-3 - ', v)  # next를 내부적으로 호출, StopIteration에러는 내부적으로 잡아줌

 start! 
 EX4-3 -  AAA 
 continue 
 EX4-3 -  BBB 
 end 

for문을 이용하여 제너레이터를 실행하면 next가 내부적으로 호출되며, 에러도 내부적으로 잡아지므로 짧은 코드로 깔끔한 결과가 나오는 것을 볼 수 있다. 

- Generator 예제2 

temp2 = [x * 3 for x in generator_ex1()]
temp3 = (x * 3 for x in generator_ex1())

지능형 리스트와 튜플을 생성한다. 이 경우에 튜플은 제너레이터가 된다. 

print('EX5-1 - ', temp2) # 이미 메모리에 만들어서 올린 것 
print('EX5-2 - ', temp3) # 제너레이터 생성. 아직 메모리에 올라가 있지 않음. next가 호출되어야만 만들어짐

 EX5-1 -  ['AAAAAAAAA', 'BBBBBBBBB'] 
 EX5-2 -  <generator object <genexpr> at 0x000001B3528D66D8> 

5-1의 list comprehension은 메모리에 이미 할당되어 올라가 있는 것을 반환한 것이고, 제너레이터인 5-2 는 아직 메모리에 올라가 있는 것이 아니고 , next가 호출될 때 만들어진다. (메모리 사용량이 적은 이유) 

for i in temp2:
    print('EX5-3 - ', i)

 EX5-3 -  AAAAAAAAA 
 EX5-3 -  BBBBBBBBB 

리스트 형이므로 for문으로 반복할 수 있다. 

for i in temp3:  # 빅데이터를 이용할 때는 제너레이터로 반복문 돌리는 것을 권장 
    print('EX5-4 - ', i)

 start! 
 EX5-4 -  AAAAAAAAA 
 continue 
 EX5-4 -  BBBBBBBBB 
 end 

결과는 비슷해보이지만 과정과 메모리 차지량은 다르기 때문에 적합한 방법을 쓰도록 하자! 

- Generator 예제3 (자주 사용하는 함수) 

Generator 예제 3 에서는 itertools를 이용한 Generator 사용을 해본다! 

import itertools

우선 itertools 를 import 한다.

* 무한 (미리 만들어 놓지 않는 다는 것 ! ) - itertools.count

gen1 = itertools.count(1, 2.5)

itertools.count(기본값, 증가값)을 작성한다. 

print('EX6-1 - ', next(gen1))
print('EX6-2 - ', next(gen1))
print('EX6-3 - ', next(gen1))
print('EX6-4 - ', next(gen1))

 EX6-1 -  1 
 EX6-2 -  3.5 
 EX6-3 -  6.0 
 EX6-4 -  8.5 

위와 같이 1부터 시작하여 next를 호출하면 2.5씩 증가시킬 수 있다. 무한으로 증가시킬 수 있으며, 미리 만들어 놓지 않고 next가 호출되기 전까지는 메모리에 할당되어 있지 않다. 

# for v in gen1:
#     print(v)

for문으로 출력하면 무한으로 2.5씩 증가하게 된다. 

* 조건 - itertools.takewhile

gen2 = itertools.takewhile(lambda n: n < 10, itertools.count(1, 2.5))

조건을 걸 수 있는 함수이다. 이 경우에는 값이 10 이하일 때만 2.5씩 증가시킨다. 

for v in gen2:
    print('EX6-5 - ', v)

EX6-5 -  1
EX6-5 -  3.5
EX6-5 -  6.0
EX6-5 -  8.5

* 필터 반대 - itertools.filterfalse

gen3 = itertools.filterfalse(lambda n: n < 3, [1, 2, 3, 4, 5])

filterfalse함수는 조건을 걸어놓고 조건과 반대되는 값을 반환하도록 한다. 

for v in gen3:
    print('EX6-6 - ', v)

 EX6-6 -  3 
 EX6-6 -  4 
 EX6-6 -  5 

3미만인 수로 조건을 걸어놓았으므로 반대되는 3, 4, 5 가 출력되었다. 

* 누적 합계 - itertools.accumulate

gen4 = itertools.accumulate([x for x in range(1, 11)])

accumulate는 누적해서 더해주는 함수이다. 

for v in gen4:
    print('EX6-7 - ', v)

 EX6-7 -  1 
 EX6-7 -  3 
 EX6-7 -  6 
 EX6-7 -  10 
 EX6-7 -  15 
 EX6-7 -  21 
 EX6-7 -  28 
 EX6-7 -  36 
 EX6-7 -  45 
 EX6-7 -  55 

1부터 10까지 누적으로 더해졌다. 

* 연결1 - itertools.chain

gen5 = itertools.chain('ABCDE', range(1, 11, 2))

chain은 인자값들을 연결해준다. 

print('EX5-8 - ', list(gen5))

 EX5-8 -  ['A', 'B', 'C', 'D', 'E', 1, 3, 5, 7, 9] 

* 연결2 - itertools.chain

gen6 = itertools.chain(enumerate('ABCDE'))

enumerate를 이용하여 인덱스와 묶어줄 수도 있다. 

print('EX6-9 - ', list(gen6))

 EX6-9 -  [(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E')] 

튜플로 묶인 것을 볼 수 있다. 

* 개별 - itertools.product

gen7 = itertools.product('ABCDE')

개별을 튜플 안에 넣어줄 수도 있다. 

print('EX6-10 - ', list(gen7))

 EX6-10 -  [('A',), ('B',), ('C',), ('D',), ('E',)] 

* 연산 - itertools.product

gen8 = itertools.product('ABCDE', repeat=2) # 모든 경우의 수를 묶어준다.

repeat=2를 넣어주면 모든 가능한 경우의 수로  2개씩 묶어준다. 

print('EX6-11 - ', list(gen8))

 EX6-11 -  [('A', 'A'), ('A', 'B'), ('A', 'C'), ('A', 'D'), ('A', 'E'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('B', 'D'), ('B', 'E'), ('C', 'A'), ('C', 'B'), ('C', 'C'), ('C', 'D'), ('C', 'E'), ('D', 'A'), ('D', 'B'), ('D', 'C'), ('D', 'D'), ('D', 'E'), ('E', 'A'), ('E', 'B'), ('E', 'C'), ('E', 'D'), ('E', 'E')]  

* 그룹화 - itertools.groupby

gen9 = itertools.groupby('AAABBCCCCDDEEE')

groupby함수는 같은 종류끼리 묶어준다. 

# print('EX6-12 - ', list(gen9))

 EX6-12 -  [('A', <itertools._grouper object at 0x000001F2EE3E40B8>), ('B', <itertools._grouper object at 0x000001F2EE3E4160>), ('C', <itertools._grouper object at 0x000001F2EE3E4198>), ('D', <itertools._grouper object at 0x000001F2EE3E41D0>), ('E', <itertools._grouper object at 0x000001F2EE3E4208>)] 

for chr, group in gen9:
    print('EX6-12 - ', chr, ' : ', list(group))

 EX6-12 -  A  :  ['A', 'A', 'A'] 
 EX6-12 -  B  :  ['B', 'B'] 
 EX6-12 -  C  :  ['C', 'C', 'C', 'C'] 
 EX6-12 -  D  :  ['D', 'D'] 
 EX6-12 -  E  :  ['E', 'E', 'E'] 

 for문으로 돌려주고, group을 list에 넣어 그룹별로 확인해볼 수 있다. 

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

<이전 글>

https://silvercoding.tistory.com/27

- Class  Getter & Setter 

* 클래스 선언 

class VectorP(object):
    def __init__(self, x, y):
        self.__x = float(x)
        self.__y = float(y)

    def __iter__(self):
        return (i for i in (self.__x, self.__y)) # Generator

* 객체 선언 

v = VectorP(20, 40)

* 오류

print('EX1-1 - ', v.__x, v.__y)  # ---> 직접 접근 불가

 AttributeError: 'VectorP' object has no attribute '__x' 

 언더바 2개로 선언한 인스턴스 변수는 객체를 통한 직접 접근이 불가능 하다. 

- Getter & Setter 

: 더 안전한 프로그래밍을 할 수 있다. 

class VectorP(object):
    def __init__(self, x, y):
        self.__x = float(x)
        self.__y = float(y)

    def __iter__(self):
        return (i for i in (self.__x, self.__y)) # Generator

    @property
    def x(self):
        print('Called Property X')
        return self.__x

    @x.setter
    def x(self, v):
        print('Called Property X setter')
        self.__x = float(v)
    
    @property
    def y(self):
        print('Called Property Y')
        return self.__y

    @y.setter
    def y(self, v):
        print('Called Property Y setter')        
        if v < 30: 
            raise ValueError('30 Below is not possible')
        self.__y = float(v)

데코레이터를 사용하여 @property, @x.setter @y.setter 밑에 x와 y를 정의해 준다. 

print('EX1-2 - ', dir(v), v.__dict__)
v.x = 10
print('EX1-3 - ', v.x, v.y)

 EX1-2 -  ['_VectorP__x', '_VectorP__y', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'x', 'y'] {'_VectorP__x': 20.0, '_VectorP__y': 40.0} 
 Called Property X 
 Called Property Y 
 EX1-3 -  10.0 40.0 

Getter와 Setter를 이용하여 self.__x 변수에 self.x 의 형태로 접근이 가능해 졌다. v.x=10 을 이용하여 값을 바꿀 수 있는 것 또한 볼 수 있다. 

# Iter 확인 
for val in v:
    print('EX1-4 - ', val)

 EX1-4 -  10.0 
 EX1-4 -  40.0 

구현해 놓은 __iter__ 메소드를 확인하였다. 

- __slot__ 

: 파이썬 인터프리터에게 통보 , 해당 클래스가 가지는 속성을 제한 

* __dict__ 

: 속성 최적화 -> 다수 객체 생성 시 메모리 사용 공간 대폭 감소 

: 해당 클래스에 만들어진 인스턴스 속성 관리에 딕셔너리 대신 set 형태를 사용 

class TestA(object):
    __slots__ = ('a', )

class TestB(object):
    pass

* 객체 생성 

use_slot = TestA()
no_slot = TestB()

* 사용

print('EX2-1 - ', use_slot)
# print('EX2-2 - ', use_slot.__dict__)  # 속성 값 확인 --> dictionary이기 때문에 안됨 
print('EX2-3 - ', no_slot)
print('EX2-3 - ', no_slot.__dict__)

 EX2-1 -  <__main__.TestA object at 0x000001BE68801C78> 
 EX2-3 -  <__main__.TestB object at 0x000001BE68A4D6A0> 
 EX2-3 -  {} 

* 메모리 사용량 비교

import timeit

# 측정을 위한 함수 선언 
def repeat_outer(obj):
    def repeat_inner():
        obj.a = 'TEST'
        del obj.a
    return repeat_inner

obj.a = 'TEST' 를 선언하고 obj.a를 삭제하는 시간을 측정하기 위한 함수를 생성한다. 

print(min(timeit.repeat(repeat_outer(use_slot), number=100000))) 
print(min(timeit.repeat(repeat_outer(no_slot), number=100000)))

 0.015717999999999982 
 0.018735899999999972 

100000번을 반복하여 가장 작은 시간을 출력해 보았을 때, slot을 사용한 클래스의 객체가 더 빠른 것을 알 수 있다. 

- 객체 슬라이싱

class ObjectS:
    def __init__(self):
        self._numbers = [n for n in range(1, 100, 3)]

    def __len__(self):
        return len(self._numbers)

    def __getitem__(self, idx):
        return self._numbers[idx]

인스턴스 변수를 리스트 타입으로 생성하고, __len__, __getitem__ 메소드를 선언해 놓은 ObjectS 클래스를 생성한다. 

* 객체 생성

s = ObjectS()

print('EX3-1 - ', s.__dict__)    
print('EX3-2 - ', len(s))
print('EX3-3 - ', len(s._numbers))  # __len__ 이 없으면 . 
print('EX3-4 - ', s[1:100])
print('EX3-5 - ', s[-1])
print('EX3-6 - ', s[::10])

 EX3-1 -  {'_numbers': [1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49,  
 52, 55, 58, 61, 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97]} 

 EX3-2 -  33 
 EX3-3 -  33 

__len__ 메소드를 선언해 놓지 않는다면 EX3-3과 같이 작성하여 리스트의 길이를 확인할 수 있다. 
 EX3-4 -  [4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58, 61,  
 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97] 
 EX3-5 -  97 
 EX3-6 -  [1, 31, 61, 91] 

__getitem__ 메소드를 사용하여 객체 자체에서 인덱싱과 슬라이싱을 가능하게 만들었다. 만약 __getitem__ 메소드를 생성하지 않았다면 다음과 같은 에러가 난다.

 Traceback (most recent call last): 
  File "c:/Users/sooki/Desktop/python_high/chapter05_02.py", line 114, in <module>      
    print('EX3-4 - ', s[1:100])
 TypeError: 'ObjectS' object is not subscriptable 

- 파이썬 추상 클래스 

https://docs.python.org/3/library/collections.abc.html

1. 자체적으로 객체 생성 불가 

2. 상속을 통해서 '자식 클래스' 에서 생성해야 함 

3. 개발과 관련된 공통된 내용 (필드, 메소드) 추출 및 통합해서 공통된 내용으로 작성하게 하는 것

** Sequence 상속 받지 않았지만, 자동으로 __iter__, __contain__ 기능 작동 

** 객체 전체를 자동으로 조사 -> 시퀀스 프로토콜 

class IterTestA():
    def __getitem__(self, idx):
        return range(1, 50, 2)[idx] # range(1, 50, 2)

__getitem__ 메소드를 선언한 IterTestA 클래스를 생성한다. 

* 객체 생성

i1 = IterTestA()

print('EX4-1 - ', i1[4])
print('EX4-2 - ', i1[4:10])
print('EX4-3 - ', 3 in i1[1:10])  # __contain__ 구현하지 않아도 사용됨 
print('EX4-4 - ', [i for i in i1]) # 구현하지 않은 __iter__ 실행

 EX4-1 -  9 
 EX4-2 -  range(9, 21, 2) 
 EX4-3 -  True 
 EX4-4 -  [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49] 

인덱싱과 슬라이싱이 가능하도록 __getitem__ 메소드만 생성을 해 놓았지만 , 4-3, 4-4 가 실행이 되는 것을 볼 수 있다. __contain__과 __iter__메소드를 클래스 내에 생성하지 않았어도 실행이 된 것이다. 

- Sequence 상속 

: 요구사항인 추상메소드를 모두 구현해야 동작 

from collections.abc import Sequence

class IterTestB(Sequence):
    def __getitem__(self, idx):
        return range(1, 50, 2)[idx] # range(1, 50, 2)

    def __len__(self, idx):
        return len(range(1, 50, 2)[idx])

Sequence를 상속 받는 IterTestB 클래스를 생성한다.  __getitem__, __len__ <--- 이 두개의 메소드를 구현하지 않으면 동작하지 않는다. 

i2 = IterTestB()  # ---> __getitem__, __len__ 함수가 없으면 객체 생성 불가. (강제성을 띈다.)

두개의 메소드를 하나라도 구현하지 않으면 다음과 같은 에러가 난다. 

TypeError: Can't instantiate abstract class IterTestB with abstract methods __len__  

print('EX4-5 - ', i2[4])
print('EX4-6 - ', i2[4:10])
print('EX4-7 - ', 3 in i2[1:10])

 EX4-5 -  9 
 EX4-6 -  range(9, 21, 2) 
 EX4-7 -  True 

- abc 활용 예제 

https://docs.python.org/ko/3/library/abc.html

import abc

class RandomMachine(abc.ABC): # metaclass=abc.ABCMeta(3.4 이하)
    # __metaclass__ = abc.ABCMeta

    #추상 메소드  ---> 데코레이터가 붙은 건 무조건 자식 클래스에서 구현해주어야 한다.
    @abc.abstractmethod
    def load(self, iterobj):
        '''Iterable 항목 추가'''

    # 추상 메소드 
    @abc.abstractmethod
    def pick(self, iterobj):
        '''무작위 항목 뽑기'''

    def inspect(self):
        items = []
        while True:
            try:
                items.append(self.pick())
            except LookupError:
                break
            return tuple(sorted(items))

데코레이터로 @abc.abstractmethod 가 붙은 메소드는 무조건 자식 클래스에서 구현 해주어야 하는 메소드이다 . load와 pick 메소드에 데코레이터가 달려있다. 위와 같이 abc를 상속받는 추상클래스에 데코레이터 메소드를 구현하고, 메소드에 주석 설명을 달아 놓으면 자식 클래스에서 자세한 구현을 하게되는 방식이다. 

import random

class CraneMachine(RandomMachine):
    def __init__(self, items):
        self._randomizer = random.SystemRandom()
        self._items = []
        self.load(items)
        
    def load(self, items):
        self._items.extend(items)
        self._randomizer.shuffle(self._items)

    def pick(self):
        try:
            return self._items.pop()
        except IndexError:
            raise LookupError('Empty Crane Box')

    def __call__(self):
        return self.pick()

이와 같이 abc를 상속받았던 RandomMachine 클래스를 상속받는 CraneMachine 을 생성한다. 입력한 아이템 리스트 중에서 랜덤 뽑기를 하는 클래스이다. RandomMachine에서 구현해놓았던 추상 메소드 load, pick 함수는 필수로 구현해주어야 한다. 

* 서브 클래스 확인 

print('EX5-1 - ', issubclass(RandomMachine, CraneMachine))
print('EX5-2 - ', issubclass(CraneMachine, RandomMachine))

 EX5-1 -  False 
 EX5-2 -  True 

issubclass를 사용하여 서브클래스인지 확인 해본다. issubclass(RandomMachine, CraneMachine)은 RandomMachine이 CraneMachine의 서브클래스냐? 라는 뜻이다. 

* 상속 구조 확인 

print('EX5-3 - ', CraneMachine.__mro__)  # 가계도를 보여준다. 상속을 받은 순서를 보여줌

 EX5-3 -  (<class '__main__.CraneMachine'>, <class '__main__.RandomMachine'>, <class 'abc.ABC'>, <class 'object'>) 

* 객체 생성

cm = CraneMachine(range(1, 100)) # 추상 메소드 구현 안하면 에러

Sequence를 상속했을 때 __getitem__, __len__ 메소드가 필수였다면, abc를 상속할 때는 추상 메소드를 필수로 구현해 주어야 한다는 강제성을 띈다. 

print('EX5-4 - ', cm._items)
print('EX5-5 - ', cm.pick())
print('EX5-6 - ', cm())
print('EX5-7 - ', cm.inspect()) # --> 부모의 메소드가 실행된다.

 EX5-4 -  [53, 83, 95, 24, 97, 2, 43, 89, 85, 3, 59, 15, 78, 12, 46, 11, 29, 72, 6, 60, 41, 51, 1, 67, 10, 88, 5, 62, 33, 18, 55, 61, 13, 63, 90, 81, 32, 65, 86, 75, 94, 71, 93, 70, 26, 54, 31, 20, 91, 35, 34, 68, 57, 42, 23, 8, 77, 69, 36, 28, 99, 17, 98, 56, 44, 22, 14, 27, 30, 48, 37, 80, 87, 52, 49, 50, 40, 74, 25, 47, 96, 9, 45, 73, 4, 16, 21, 7, 82, 39, 58, 66, 84, 19, 79, 76, 38, 64, 92] 
 EX5-5 -  92 
 EX5-6 -  64 
 EX5-7 -  (38,) 

inspect메소드는 자식클래스에서 구현해주지 않아도 부모의 클래스의 메소드가 실행된다. 

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

<이전 글>

https://silvercoding.tistory.com/26

- 얕은 복사 & is  vs  __eq__ (==) 

x = {'name': 'Kim','age': 33, 'city' : 'Seoul'}
y = x  # ---> 얕은 복사

우선 x에 딕셔너리를 저장한다. 그다음 단순한 복사를 한다. 

print('EX2-1', id(x), id(y))  
print('EX2-2 - ', x == y)
print('EX2-3 - ', x is y)
print('EX2-4 - ', x, y)

 EX2-1 2324412065760 2324412065760 

우선 id 값을 출력해보니 두 값이 완전히 같았다. 

 EX2-2 -  True 

 EX2-3 -  True 

2-2와 2-3은 직관적으로 봐도 x와 y가 같은지를 물어보는 코드인 것 같다. 하지만 다른 종류의 확인법이다. __eq__ (==) 와 같은 경우는 x와 y의 값이 같은지를 확인하는 것이고 , is는 x와 y의 id값이 같은지를 확인하는 것이다. 

** 정리 

==(__eq__) : 값을 비교  vs  is : 객체 주소 (정체성) 비교

 EX2-4 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul'} {'name': 'Kim', 'age': 33, 'city': 'Seoul'} 

위 예제에서는 값, id 모두 같다. x와 y를 출력하면 당연한 결과로 같은 딕셔너리가 나오는 것을 볼 수 있다. 

x의 값을 수정하거나 추가하면 y도 바뀔까? id값이 같으므로 바뀔 것으로 추정할 수 있다. 

x['class'] = 10 
print('EX2-5 - ', x, y)

 EX2-5 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} 

x에 값을 추가했더니 y도 똑같이 추가되는 것을 알 수 있다. 

z = {'name': 'Kim','age': 33, 'city' : 'Seoul', 'class' : 10}

새 딕셔너리 객체를 만들어 본다. 값은 x와 같도록! 

print('EX2-6 - ', x, z)
print('EX2-7 - ', x is z)  # 같은 객체냐 
print('EX2-8 - ', x is not z)  
print('EX2-9 - ', x == z)  # 값이 같냐

 EX2-6 -  {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} {'name': 'Kim', 'age': 33, 'city': 'Seoul', 'class': 10} 
 EX2-7 -  False 
 EX2-8 -  True 
 EX2-9 -  True 

x와 z를 비교해 보면 id값은 다르고, 값만 같다고 나오는 것을 볼 수 있다. 이 경우에는 x의 값을 변경하여도 z의 값은 변하지 않을 것이다. (당연한 소리) 

*** cf ) 튜플 (불변형) 비교 

tuple1 = (10, 15, [100, 1000])
tuple2 = (10, 15, [100, 1000])

print('EX3-1 - ', id(tuple1), id(tuple2))
print('EX3-2 - ', tuple1 is tuple2)
print('EX3-3 - ', tuple1 == tuple2)
print('EX3-4 - ', tuple1.__eq__(tuple2))

 EX3-1 -  2324415315832 2324415315544 
 EX3-2 -  False 
 EX3-3 -  True 
 EX3-4 -  True 

- Copy & DeepCopy (얕은 복사 , 깊은 복사) 

tl1 = [10, [100, 105], (5, 10, 15)]
tl2 = tl1
tl3 = list(tl1)

리스트 안에 숫자, 리스트, 튜플을 각각 넣은 후, tl2에는 얕은 복사를 , tl3에는 list의 인자에 넣어 새 객체를 생성해 준다. 

print('EX4-1 - ', tl1 == tl2)
print('EX4-2 - ', tl1 is tl2)
print('EX4-3 - ', tl1 == tl3)
print('EX4-4 - ', tl1 is tl3)

 EX4-1 -  True 
 EX4-2 -  True 
 EX4-3 -  True 
 EX4-4 -  False 

4-3과 4-4와 같은 경우는 값은 같지만, 객체는 다르다는 것을 알 수 있다. 

tl1.append(1000)
tl1[1].remove(105)

tl1에 1000을 추가하고, 1번째 리스트에서 105를 제거하면 어떻게 될까 ! 

print('EX4-5 - ', tl1)
print('EX4-6 - ', tl2)
print('EX4-7 - ', tl3)

 EX4-5 -  [10, [100], (5, 10, 15), 1000] 
 EX4-6 -  [10, [100], (5, 10, 15), 1000] 
 EX4-7 -  [10, [100], (5, 10, 15)] 

tl2는 같은 객체로 복사되어 있기 때문에 tl1과 같은 것을 볼 수 있다. 그런데 tl3는 반만 똑같다! 왜 그럴까? 

print(id(tl1[1])) # tl1과 tl3의 id는 다르지만 안에 있는 리스트의 id값은 같다. ! 
print(id(tl3[1]))

 2324415643528 
 2324415643528 

아 . tl1과 tl3 자체 객체의 id값은 달랐지만, 그 안에 있는 1번째 리스트의 id값은 같았다. 점점 이 방법으로 하는 복사의 허점이 보이기 시작한다. 

tl1[1] += [110, 120]
tl1[2] += (110, 120)

tl1의 리스트와 튜플에 각각 값을 추가해준다. 

print('EX4-8 - ', tl1)
print('EX4-9 - ', tl2) # 튜플 재 할당 (깩체 새로 생성) ---> 데이터가 현저히 많을 떈 주의 해야 한다. 객체를 새로 생성한다는 것은 데이터 손실이 있을 수도 있고 , 메모리를 더 차지할 수도 있게 되기 때문 !
print('EX4-10 - ', tl3)

 EX4-8 -  [10, [100, 110, 120], (5, 10, 15, 110, 120), 1000] 
 EX4-9 -  [10, [100, 110, 120], (5, 10, 15, 110, 120), 1000] 
 EX4-10 -  [10, [100, 110, 120], (5, 10, 15)] 

우선 tl1, tl2는 여기서도 똑같이 움직인 다는 것을 알 수 있다. 그런데 tl3에서는 조금 이상한 현상이 일어났다. 리스트는 값이 추가되었지만 , 튜플은 값이 추가되지 않았다. 답은 코드 주석에 써있듯이, 튜플은 객체를 새로 생성하여 재 할당이 되기 때문인데, 이해를 위하여 id값을 출력해보았다. 

# 리스트, 튜플에 값 추가 전 
print(id(tl1[2]))
print(id(tl2[2]))
print(id(tl3[2]))

...

# 리스트, 튜플에 값 추가 후
print(id(tl1[2]))
print(id(tl2[2]))
print(id(tl3[2]))

 1367137568664 
 1367137568664 
 1367137568664 

 1367137218056 
 1367137218056 
 1367137568664 

리스트처럼 tl1, tl3의 튜플 id값은 같았다. 튜플에선 이게 이슈가 되는 것이다! tl1[2] += (110, 120) <--- 이 코드가 실행되면 튜플이 재할당되어 새 객체가 생성된다. 그래서 id값을 보면 이 코드 전과 후의 tl1, tl2 id값이 달라진 것을 볼 수 있다. 그래서 전과 같은 id값을 가진 tl3의 튜플은 변화하지 않는 것이다. 

*** copy & Deep copy (깊은 복사) 실습해보기 

(ex) 장바구니 클래스 

class Basket:
    def __init__(self, products=None):
        if products is None:
            self._products = []
        else:
            self._products = list(products)  # 새로운 객체 생성

    def put_prod(self, prod_name):
        self._products.append(prod_name)

    def del_prod(self, prod_name):
        self._products.remove(prod_name)

_products에 물건을 담고, put_prod 메소드로 물건 추가 , del_prod 메소드로 물건 삭제를 하는 클래스 생성! 

import copy

basket1 = Basket(['Apple', 'Bag', 'TV', 'Snack', 'Water'])
basket2 = copy.copy(basket1)  # 얕은 복사 
basket3 = copy.deepcopy(basket1)  # 깊은 복사 ---> 객체 안에 있는 인스턴스 변수까지 참조

copy를 import하여 얕은 복사(copy.copy) 와 깊은 복사(copy.deepcopy) 를 해본다. 

print('EX5-1 - ', id(basket1), id(basket2), id(basket3))
print('EX5-2 - ', id(basket1._products), id(basket2._products), id(basket3._products))

 EX5-1 -  1367137770520 1367137770464 1367137771304 
 EX5-2 -  1367137799240 1367137799240 1367137626888 

copy를 사용하면 객체 자체는 모두 다르게 나오는 것을 볼 수 있다. EX5-2에서 얕은 복사와 깊은복사의 차이점이 보인다. deepcopy는 객체 안에 있는 인스턴스 변수까지 참조를 하기 때문에 변수의 객체까지 id의 값이 다르다! 

basket1.put_prod('Orange')
basket2.del_prod('Snack')

basket1에 Orange를 넣고, Snack을 삭제하면 어떻게 변하는지 확인해 보자! 

# 빅데이터나, 웹개발할 떄 주의해야 한다. 
print('EX5-3 - ', basket1._products)
print('EX5-4 - ', basket2._products)  
print('EX5-5 - ', basket3._products)

 EX5-3 -  ['Apple', 'Bag', 'TV', 'Water', 'Orange'] 
 EX5-4 -  ['Apple', 'Bag', 'TV', 'Water', 'Orange'] 
 EX5-5 -  ['Apple', 'Bag', 'TV', 'Snack', 'Water'] 

이렇게 basket1과 basket2는 서로 영향을 받는다. 깊은복사를 한 basket3는 영향을 받지 않는다. 

이는 빅데이터 또는 웹개발을 할 때 주의해야 한다. 예를 들어 빅데이터 분석을 할 때 원본은 손상시키지 않고 복사를 하여 전처리를 할 경우 얕은 복사를 하게 되면 생각만 해도 아찔하다. 

- 함수 매개변수 전달 주의 

def mul(x, y):
    x += y
    return x

x에 y를 더해서 x에 넣고, x를 return해주는 mul 함수 생성 

x = 10 
y = 5

print('EX6-1 - ', mul(x, y), x, y)

 EX6-1 -  15 10 5 

함수 안의 x가 15라고 해서 전역변수 x의 값이 변경되지는 않는다. 

* 가변형 a -> 원본 데이터 변경/ 함수에 전달할 때 원본의 주소까지 넘김

a = [10, 100]
b = [5, 10]

print('Ex6-2 - ', mul(a, b), a, b)  # ---> 확장! ! ! ! !

 Ex6-2 -  [10, 100, 5, 10] [10, 100, 5, 10] [5, 10] 

하지만 가변형인 리스트 타입의 a를 mul에 넣으면 전역변수인 a의 값까지 변해버린다. 즉 원본데이터가 변경되는 것이다. 함수에 이 데이터를 전달할 때 원본의 주소까지 넘기기 때문이다. 

* 불변형 c ---> 원본 데이터 변경 안됨

c = (10, 100)
d = (5, 10)
print('Ex6-2 - ', mul(c, d), c, d)

불변형인 튜플타입의 c같은 경우에는 원본 데이터의 변경이 되지 않는다. 위에서 배웠듯이 튜플의 내용이 갱신될 때는 새로운 주소에 할당이 되기 때문이다. 

- 파이썬 불변형 예외 

: str, bytes, frozenset, Tuple ---> 사본 생성 X ---> 참조 반환 (같은 값이면 id 도 같다) 

tt1 = (1, 2, 3, 4, 5)
tt2 = tuple(tt1)
tt3 = tt1[:]

이번엔 튜플을 각각 다른 방법으로 복사하여 tt2와 tt3를 생성하였다. 

print('EX7-1 - ', tt1 is tt2, id(tt1), id(tt2))
print('EX7-2 - ', tt1 is tt3, id(tt1), id(tt3))

 EX7-1 -  True 1367134857000 1367134857000 
 EX7-2 -  True 1367134857000 1367134857000 

리스트는 위와 같은 방법으로 객체를 생성하면 새로운 주소가 부여됐었다. 튜플은 불변형이므로 같은 값이면 id는 같다. 따라서 모든 id값이 같게 나왔다. 튜플은 불변형이기 때문에 튜플에 튜플을 더할 때 기존 튜플에 값이 추가되는 개념이기 보다는 새로운 튜플 객체가 만들어지는 것이라고 보면 된다.  

tt4 = (10, 20, 30, 40, 50)
tt5 = (10, 20, 30, 40, 50)
ss1 = 'Apple'
ss2 = 'Apple'

튜플과 또다른 불변형 str로 검증을 해보고 마친다. 

print('EX7-3 - ', tt4 is tt5, tt4 == tt5, id(tt4), id(tt5))
print('EX7-4 - ', ss1 is ss2, ss1 == ss2, id(ss1), id(ss2))

 EX7-3 -  True True 1367137216648 1367137216648 
 EX7-4 -  True True 1367137769320 1367137769320 

값이 같으면 다른 변수에 따로 생성을 해도 같은 주소를 갖고 있다는 것을 알 수 있다. 

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

<이전 글>

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 

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

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

<이전 글>

https://silvercoding.tistory.com/24

예전 글에서도 다루었듯이 파이썬의 모든 것은 객체 라는 개념은 아주 중요한 개념이었다. 이를 통해 함수 또한 객체라는 것을 알 수 있다. 

일급함수(일급 객체) - 파이썬 함수의 특징 

1. 런타임 초기화 가능 

2. 변수에 할당 가능 

3. 함수 인수에 전달 가능 (ex) sorted(keys=len) --- 함수 안에 함수 

4. 함수 결과로 반환 가능 (ex) return function  

- 팩토리얼 함수 구현 예제 

def factorial(n):
    print("run")
    '''Factorial Function -> n:int'''
    if n ==1: # n < 2 
        return 1 
    return n * factorial(n-1)
    
    
class A: 
    pass 

위에서 보았던 일급함수의 특징 중 4번을 사용하였다. 함수의 결과로 함수를 반환해서 팩토리얼을 구현한 것이다. 

A클래스는 함수와 비교해 보기 위해서 생성한 것 . 

* 사용해보기

print('EX1-1 - ', factorial(5))
print('EX1-2 - ', factorial.__doc__)
print('EX1-3 - ', type(factorial), type(A))
print('EX1-4 - ', set(sorted(dir(factorial)))-set(sorted(dir(A)))) # 클래스와 다르게 함수가 갖고있는 메소드들
print('EX1-5 - ', factorial.__name__) # 함수 이름 
print('EX1-6 - ', factorial.__code__) # 함수 코드 위치 

EX1-1 에서 볼 수 있듯이 factorial(5) 를 하면 run이 5번 호출 되는 것을 볼 수 있다. 

* 변수 할당 / 함수 인자 전달

val_func = factorial
print('EX2-1 - ', val_func)
print('EX2-2 - ', val_func(5))
print('EX2-3 - ', map(val_func, range(1, 6)))
print('EX2-4 - ', list(map(val_func, range(1, 6))))

일급함수의 특징 2번과 같이 변수에 할당할 수 있다. 변수에 함수를 넣고, 기존 만들어 놓았던 함수와 똑같이 사용해 주면 된다. EX2-3, 4 에서는 특징 3번과 같이 map함수의 인자에 factorial 함수를 넣어 사용한 것이다.

EX2-4는 위와같이 리스트로 결과 값을 볼 수 있다. 

# 함수 인수 전달 및 함수로 결과 반환 -> 고위 함수 (Higher-order Function)
print('EX3-1 - ', list(map(val_func, filter(lambda x: x%2, range(1, 6))))) # --> 함수 안에 함수 전달 
print('EX3-2 - ', [val_func(i) for i in range(1, 6) if i % 2])

EX2-4 에서 더 나아가 1-6 중에서 홀수인 숫자들만 factorial을 적용시키는 코드이다. 

EX3-1과 EX3-2 는 같은 결과가 나오는 코드이지만, EX3-2는 list comprehension을 사용하였고, EX3-1은 함수의 인수로 함수를 전달한다는 점에서 차이가 있다. 

- reduce 

from functools import reduce
import functools
from operator import add

print('EX3-3 - ', reduce(add, range(1, 11))) # 누적 
print('EX3-4 - ', sum(range(1, 11)))

1부터 10까지 더하는 코드를 짜야한다고 하면 EX3-4 처럼 sum함수를 사용하여 짜는 것이 일반적이다. 이 방법 말고도 functools의 reduce를 사용하여 구현할 수도 있다. 1부터 11까지 차례대로 더해가며 줄여나가는 방식이다. 

* 익명함수 (lambda) 와 reduce 

*** 익명함수 (lambda) 

1. 가급적 주석 사용 (가독성이 떨어지기 때문) 

2. 가급적 함수 사용 

3. 일반 함수 형태로 리팩토링 권장 

print('EX3-5 - ', reduce(lambda x, t: x + t, range(1, 11)))

위에서의 add함수 대신 lambda함수를 사용할 수 있다. 1 + 2 ---> 3 + 3 ---> 6 + 4 ---> 10 + 5 이런 식으로 더해진 값에 누적으로 다음 수를 더해주는 원리이다. 

<lambda, map(), reduce(), filter() 참고>

https://wikidocs.net/64

어려움을 느낄 땐 예시를 보고 오기! 

- Callable : 호출 연산자 

* 메소드 형태로 호출 가능한지 확인 

---- 로또 추첨 클래스 예제 ----

* 클래스 선언 

import random

class LottoGame:
    def __init__(self):
        self._balls = [n for n in range(1, 46)]

    def pick(self):
        random.shuffle(self._balls)
        return sorted([random.choice(self._balls) for n in range(6)])

우선 random을 import 해준다. 객체를 초기 생성했을 때 _balls에는 1부터 45까지의 숫자를 리스트를 넣어준다. 

pick 함수에서는 random.shuffle을 사용하여 _balls를 섞어 준다. 그다음 6개를 뽑아준다. 

* 객체 생성 

game = LottoGame()

* 로또추첨 실행 

print('EX4-2 - ', game.pick())

 EX4-2 -  [1, 5, 14, 24, 30, 34] 

이렇게 6개가 잘 뽑히는 것을 알 수 있다. 

--- callable 사용 

print('EX4-1 - ', callable(str), callable(list), callable(factorial), callable(3.14), callable(game))

위에서 말했듯이 callable을 사용하여 메소트 형태로 호출 가능한지 알 수 있다. 

 EX4-1 -  True True True False False 

str, list, factorial은 모두 메소드 형태로 호출이 가능하지만, 실수인 3.14 또는 객체가 들어가 있는 변수인 game 같은 경우는 메소드 형태로 호출이 불가능 하다. 3.14(), game() <--- 이와 같은 형태로 사용할 수 없다는 소리이다. 

하지만 클래스에서 __call__메소드를 사용하면 game같은 객체가 담긴 변수는 메소드 형태로 호출을 가능하게 만들 수 있다. 

--- __call__ 메소드 사용하기 (매우 중요한 개념임) 

class LottoGame:

    ...

    def __call__(self):
        return self.pick()

LottoGame 클래스에 __call__메소드를 추가해 준다. self.pick을 return 해주는 것으로 작성하였으므로, game()을 호출하면 pick 이 실행될 것이다. 

*** 사용해보기 

print('EX4-3 - ', game())
print('EX4-4 - ', callable(game))

 EX4-3 -  [14, 18, 42, 44, 44, 45] 
 EX4-4 -  True 

-- 매개변수 입력 (*args, **kwargs) 

def args_test(name, *contents, point=None, **attrs):
    return '<args_test> -> ({}) ({}) ({}) ({})'.format(name, contents, point, attrs)

볼 때마다 헷갈렸던 별표! 함수의 인자에 별 하나 (*) 가 붙으면 튜플을 받고, 별 두개 (**) 가 붙으면 딕셔너리를 받는다. 

테스트를 하기 위해 일반 변수 name, 튜플을 받는 contents, default 값이 정해져 있는 point, 딕셔너리를 받는 attrs, 총 4개의 인자를 받는 함수 args_test를 생성하였다. 

print('EX5-1 - ', args_test('test1'))
print('EX5-2 - ', args_test('test1', 'test2'))
print('EX5-3 - ', args_test('test1', 'test2', 'test3', id='admin'))
print('EX5-4 - ', args_test('test1', 'test2', 'test3', id='admin', point=7))
print('EX5-4 - ', args_test('test1', 'test2', 'test3', id='admin', point=7, password='1234'))

* 하나씩 풀어서 정리 

 EX5-1 -  <args_test> -> (test1) (()) (None) ({}) 

'test1' 하나를 넣었더니 name에 들어 갔다. 

 EX5-2 -  <args_test> -> (test1) (('test2',)) (None) ({}) 

'test1', 'test2' 를 넣었더니 name, contents 튜플에 들어갔다. (default값이 있는 point는 point를 명시해 주어야 하며, attr은 딕셔너리를 받으므로 key, value값을 적어주어야 한다.)  

 EX5-3 -  <args_test> -> (test1) (('test2', 'test3')) (None) ({'id': 'admin'}) 

'test1', 'test2', 'test3' 를 연속적으로 적어 주었더니 name에 test1, contents 튜플에 test2, test3가 들어간 것을 볼 수 있다. 차례대로 적더라도 point에는 들어가지 않는다. key와 value를 넣어주니 attr 딕셔너리에 들어간 것 또한 볼 수 있다. 

 EX5-4 -  <args_test> -> (test1) (('test2', 'test3')) (7) ({'id': 'admin'}) 

이번에는 point를 명시해주어 값을 넣었더니 잘 들어 가 있다. 

 EX5-4 -  <args_test> -> (test1) (('test2', 'test3')) (7) ({'id': 'admin', 'password': '1234'}) 

순서와 상관 없이 key, value 를 넣어주면 딕셔너리에 들어 가 있다. 

- 함수 Signature

: 함수의 인자에 대한 정보를 표시해줄 수 있는 클래스 형태의 메소드 

from inspect import signature

우선 inspect의 signature를 import 해준다. 

sg = signature(args_test)

print('EX6-1 - ', sg)
print('EX6-2 - ', sg.parameters)

 EX6-1 -  (name, *contents, point=None, **attrs) 
 EX6-2 -  OrderedDict([('name', <Parameter "name">), ('contents', <Parameter "*contents">), ('point', <Parameter "point=None">), ('attrs', <Parameter "**attrs">)]) 

위와 같이 함수의 인자에 대한 정보를 확인할 수 있다. 

* 인자의 모든 정보 출력해보기 

# 모든 정보 출력 

for name, param in sg.parameters.items():
    print('EX6-3 - ', name, param.kind, param.default)

 EX6-3 -  name  POSITIONAL_OR_KEYWORD  <class 'inspect._empty'> 
 EX6-3 -  contents  VAR_POSITIONAL  <class 'inspect._empty'> 
 EX6-3 -  point  KEYWORD_ONLY  None 
 EX6-3 -  attrs  VAR_KEYWORD  <class 'inspect._empty'> 

- partial 

1. 주로 특정 인수를 고정한 후 콜백함수에 사용

2. 하나 이상의 인수가 이미 할당된 함수의 새 버전(새 버전의 함수) 반환 

3. 함수의 새 객체 타입은 이전함수의 자체를 기술하고 있음 

글로 읽으면 이해가 잘 가지 않을 수 있다. 사용해 보자! 

from functools import partial

우선 functools의 partial을 import 해준다. 

*** cf ) mul 함수는 왜 있나 

from operator import mul 

print('EX7-1 - ', mul(10, 100))

위 코드 같은 경우는 10 * 100 을 하면 같은 결과가 나올텐데, 굳이 mul과 같은 함수가 존재하는 이유는 무엇인가. 

---> mul과 같은 함수를 인수로 받는 경우가 있기 때문이다. 

* 인수 고정 

five = partial(mul, 5)

이렇게 partial함수의 인자에 mul함수를 넣어주기 위한 용도로 쓰일 수 있다. 

그래서 partial 함수가 무엇인가! 

인수를 고정시켜 놓는 역할을 한다. partial(mul, 5) 는 mul(5) <--- 이 상태로 5를 고정시켜 놓겠다는 소리이다. 

* 고정 추가 

six = partial(five, 6)

이렇게 하면 mul(5, 6) <--- 이 상태로 고정이 되는 것이다. 

* 사용

print('EX7-2 - ', five(100)) # 한개만 받을 수 있음 
# print(six(100)) # ---> 오류 남 . 아무것도 받을 수 없음 
print('EX7-3 - ', six())
print('EX7-4 - ', [five(i) for i in range(1, 11)])
print('EX7-5 - ', list(map(five, range(1, 11)))) 

EX7-4, 5 와 같이 5에 1~10의 숫자를 곱하는 것과 비슷한 상황에서 편리하게 코드를 짤 수 있다.