🤍

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

<이전 글>

https://silvercoding.tistory.com/35

1. 딕셔너리 (Dictionary) 

: 순서 X, 중복 X, 수정 O, 삭제 O 

: Key, Value 형식으로 되어 있음. (Json/ MongoDB) 

- 선언 

a = {'name': 'kIM', 'Phone': '010-7777-7777', 'birth': 990101}
b = {0: 'Hello Python', 1: 'Hello Coding'}
c = {'arr': [1, 2, 3, 4, 5]}

print(type(a))

 <class 'dict'> 

딕셔너리 객체를 선언해 준다. 

- 출력 

print(a['name'])
print(a.get('name'))
print(a.get('adress'))  # 안전한 코딩 방식 : 이거 쓰는 것을 권장. 에러가 안나기 때문 
print(c['arr'][1:3])

 kIM 
 kIM 
 None 
 [2, 3] 

딕셔너리에서 값을 가져오기 위한 2가지 방법이 있다. 1. 키에 직접 접근 , 2. get() 사용 

1번 방법이 편리하지만, 없는 키 값을 사용하면 오류가 나게 된다. 2번 방법을 사용하면 없는 키 값을 넣더라도 None을 반환해주기 때문에 더 안전한 코딩이 가능하다. 

- 딕셔너리 추가 

a['adress'] = 'Seoul'
print(a)
a['rank'] = [1, 3, 4]
a['rank2'] = (1, 2, 3)
print(a)

 {'name': 'kIM', 'Phone': '010-7777-7777', 'birth': 990101, 'adress': 'Seoul'} 
 {'name': 'kIM', 'Phone': '010-7777-7777', 'birth': 990101, 'adress': 'Seoul', 'rank': [1, 3, 4], 'rank2': (1, 2, 3)} 

key와 value를 직접 적어주면 된다. 리스트와 튜플 또한 추가가 가능하다. 

- keys, values, items 

# print(a.keys()[0]) # 리스트 인덱스로 접근 불가 
temp = list(a.keys()) # ---> 형변환 해주어야 함 
print(temp)
print(temp[1:3])

 ['name', 'Phone', 'birth', 'adress', 'rank', 'rank2'] 
 ['Phone', 'birth'] 

a.keys() 를 사용하면 딕셔너리 a의 key값들만 모아서 나오게 된다. 언뜻 보면 리스트처럼 생겼지만 리스트를 사용하는 것 처럼 인덱싱이나 슬라이싱을 할 수 없다. 따라서 list()를 이용하여 형변환을 해주면 키 값들이 담긴 리스트를 생성할 수 있다. 

print(a.values())
print(list(a.values()))

print(a.items())
print(list(a.items()))

 dict_values(['kIM', '010-7777-7777', 990101, 'Seoul', [1, 3, 4], (1, 2, 3)]) 
 ['kIM', '010-7777-7777', 990101, 'Seoul', [1, 3, 4], (1, 2, 3)] 

 dict_items([('name', 'kIM'), ('Phone', '010-7777- 7777'), ('birth', 990101), ('adress', 'Seoul'), ('rank', [1, 3, 4]), ('rank2', (1, 2, 3))]) 
 [('name', 'kIM'), ('Phone', '010-7777-7777'), ('birth', 990101), ('adress', 'Seoul'), ('rank', [1, 3, 4]), ('rank2', (1, 2, 3))] 

values()와 items()도 마찬가지다! 

- 키 존재 여부 

print(1 in b)
print(2 in b)
print('name' in a)

 True 
 False 
 True 

위와 같이 딕셔너리에서 in을 이용하면 key값이 존재하는지에 대한 여부를 boolean 타입으로 반환해 준다. 

2. 집합 (Set) 

: 순서 X, 중복 X 

- 선언 

a = set()
b = set([1, 2, 3, 4])
c = set([1, 4, 6, 6, 6])

* 주의할 점은 a = { } 와 같이 선언하면 딕셔너리 객체가 만들어 지므로 빈 집합을 만들 경우엔 a = set() 의 형태로 선언해 주어야 한다. 

print(type(a))
print(c)

 <class 'set'> 
 {1, 4, 6} 

위와 같이 중복을 허용하지 않는다! 

- 형변환 

: Set 자료형은 주로 변환하여 사용한다. 

t = tuple(b)
print(t)
l = list(b)
print(l)

 (1, 2, 3, 4) 
 [1, 2, 3, 4] 

중복 값이 들어가지 않도록 set을 생성한 후 튜플이나 리스트 등으로 변환하여 사용하는 일이 많다고 한다.  

* 집합 연산 (교집합, 합집합, 차집합) 

s1 = set([1, 2, 3, 4, 5, 6])
s2 = set([4, 5, 6, 7, 8, 9])

연산을 수행하기 위한 집합을 선언한다. 

- 교집합 : intersection / &

print(s1.intersection(s2))
print(s1 & s2)

 {4, 5, 6} 
 {4, 5, 6} 

- 합집합 : union / |

print(s1.union(s2))
print(s1 | s2)

 {1, 2, 3, 4, 5, 6, 7, 8, 9} 
 {1, 2, 3, 4, 5, 6, 7, 8, 9} 

- 차집합 : difference / -

print(s1.difference(s2))
print(s1 - s2)

 {1, 2, 3, 4, 5, 6, 7, 8, 9} 
 {1, 2, 3} 
 {1, 2, 3} 

- 추가 & 제거 

s3 = set([7, 8, 10, 15])

s3.add(18)
s3.add(7)

print(s3)

 {7, 8, 10, 15, 18} 

add함수를 이용하여 값을 추가할 수 있다. 

s3.remove(15)
print(s3)

 {7, 8, 10, 18} 

remove함수를 이용하여 값 제거까지 가능하다. 

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

<이전 글>

https://silvercoding.tistory.com/34

1. 리스트 (list) 

: 순서 O, 중복 O, 삭제 O 

- 선언 

a = []
b = list()
c = [1, 2, 3, 4]
d = [10, 100, 'Pen', 'Banana', 'Orange']
e = [10, 100, ['Pen', 'Banana', 'Orange']]

여러 방법으로 리스트를 선언 해 줄 수 있다. 

- 인덱싱

print(d[3])
print(d[-2])
print(d[0] + d[1])
print(e[2][1])
print(e[-1][-2])

 Banana 
 Banana 
 110 
 Banana 
 Banana 

- 슬라이싱 

print(d[0:3])
print(e[2][1:3])

 [10, 100, 'Pen'] 
 ['Banana', 'Orange'] 

- 연산 

print(c + d)
print(c * 3)
print(str(c[0]) + 'hi')

 [1, 2, 3, 4, 10, 100, 'Pen', 'Banana', 'Orange'] 
 [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4] 
 1hi 

- 리스트 수정, 삭제 

c[0] = 77
print(c)

 [77, 2, 3, 4] 

0번쨰 인덱스에 값 넣어주기 

c[1:2] = [100, 1000, 10000]
print(c) # 원소가 들어감

 [77, 100, 1000, 10000, 3, 4] 

슬라이싱을 이용하여 여러 값을 넣어줄 수 있다.

c[1] = ['a', 'b', 'c']
print(c) # 리스트가 들어감

 [77, ['a', 'b', 'c'], 1000, 10000, 3, 4] 

리스트 자체를 넣어주려면 인덱싱을 사용하면 된다. 

del c[1]
print(c)

 [77, 1000, 10000, 3, 4] 

del을 이용하여 리스트의 값을 삭제할 수 있다. 

del c[-1]
print(c)

 [77, 1000, 10000, 3] 

-리스트 관련 함수 

(1) append 

y = [5, 2, 3, 1, 4]
print(y)
y.append(6) # 끝에 추가 
print(y)

 [5, 2, 3, 1, 4] 
 [5, 2, 3, 1, 4, 6] 

리스트의 가장 끝에 값을 추가해 준다. 

(2) sort

y.sort() # 정렬 
print(y)

 [1, 2, 3, 4, 5, 6] 

리스트를 정렬해 준다. 

(3) reverse

y.reverse()
print(y)

 [6, 5, 4, 3, 2, 1] 

리스트를 뒤집어 준다. 

(4) insert

y.insert(2, 7)
print(y)

 [6, 5, 7, 4, 3, 2, 1] 

append와는 다르게 원하는 인덱스에 값을 추가해줄 수 있다. 

(5) remove

y.remove(2)
y.remove(7)
print(y) # 원소 값을 지운다.

 [6, 5, 4, 3, 1] 

del은 인덱스를 이용하여 지워주었는데, remove함수는 값을 넣으면 그 값을 지워준다. 

(7) pop

y.pop()
print(y) # LIFO 스택 자료구조

 [6, 5, 4, 3]  

pop을 사용하면 가장 끝에 있는 값을 지워준다. LIFO(Last In First Out) 의 자료구조로 사용된다. 

(8) extend

ex = [88, 77]
# y.append(ex) # 리스트 자체를 추가
y.extend(ex) # 값을 추가 
print(y)

 [6, 5, 4, 3, 88, 77] 

리스트 안에 리스트를 추가하는 것이 아니라, 리스트 안에 여러 값을 한 번에 넣어주고 싶을 때 extend함수를 사용한다. 

* 리스트 삭제 총정리 

del, remove, pop ( : 예외 발생 주의) 

2. 튜플 (tuple) 

: 순서 O, 중복 O, 수정 X, 삭제 X 

- 선언 

a = ()
b = (1,)
c = (1, 2, 3, 4)
d = (10, 100, ('a', 'b', 'c'))

이와 같이 여러 방법으로 튜플을 선언할 수 있다. 

- 삭제 : 불가 

del c[2] # -> 삭제 불가

 TypeError: 'tuple' object doesn't support item deletion 

튜플은 수정이나 삭제를 할 수 없다. 

- 인덱싱 

print(c[2])
print(c[3])
print(d[2][2])

 3 
 4 
 c 

- 슬라이싱 

print(d[2:])
print(d[2][0:2])

 (('a', 'b', 'c'),) 
 ('a', 'b') 

- 연산 

print(c + d)
print(c * 3)

 (1, 2, 3, 4, 10, 100, ('a', 'b', 'c')) 
 (1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4) 

- 튜플 관련 함수 

z = (5, 2, 1, 3, 1)
print(z)
print(3 in z)
print(z.index(5))  # 인덱스 값을 반환 
print(z.count(1))  # 1 이 몇개가 있냐

 (5, 2, 1, 3, 1) 
 True 
 0 
 2 

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

<이전 글>

https://silvercoding.tistory.com/33

* 데이터 타입 한눈에 보기 

v_str = "Niceman"
v_bool = True
v_str2 = "Goodboy"
v_float = 10.3
v_int = 7
v_dict = {
    "name" : "Kim", 
    "age" : 25
}
v_list = [3, 5, 7]
v_tuple = 3, 5, 7
v_set = {7, 8, 9}

print(type(v_str))
print(type(v_bool))
print(type(v_str2))
print(type(v_float))
print(type(v_int))
print(type(v_dict))
print(type(v_list))
print(type(v_tuple))
print(type(v_set))

 <class 'str'> 
 <class 'bool'> 
 <class 'str'>  
 <class 'float'> 
 <class 'int'> 
 <class 'dict'> 
 <class 'list'> 
 <class 'tuple'> 
 <class 'set'> 

1. 숫자형 

<숫자형 연산자 참고> 

 https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex

i1 = 39 
i2 = 939 
big_int1 = 999999999999999999999999999999999999999
big_int2 = 777777777777777777777777777777777777777
f1 = 1.234 
f2 = 3.1415
f3 = .5
f4 = 10.

print(i1 * i2)
print(big_int1 * big_int2)
print(f1 ** f2)
print(f3 + i2)

 36621 
 777777777777777777777777777777777777776222222222222222222222222222222222222223       
 1.93582713947248 
 939.5 

result = f3 + i2 
print(result, type(result))

 939.5 <class 'float'> 

int + float를 하면 자동적으로 float 타입이 된다. 

a = 5. 
b = 4
c = 10

print(type(a), type(b))
result2 = a + b 
print(result2)

 <class 'float'> <class 'int'> 
 9.0 

- 숫자형 형변환 (유연한 형변환 가능) 

* int, float, complex(복소수 : 잘 안씀) 

print(int(result2))
print(float(c))
print(complex(3))
print(int(True))
print(int(False))
print(int('3'))
print(complex(False))

 9 
 10.0 
 (3+0j) 
 1 
 0 

True, False는 각각 정수형으로 변환하면 1, 0 이 된다. 
 3 
 0j 

이처럼 파이썬은 유연한 형변환을 지원한다 .

y = 100 
y += 100 
print(y)

 200 

<수치 연산 함수 참고> 

https://docs.python.org/3/library/math.html

print(abs(-7))
n, m = divmod(100, 8)  # 몫, 나머지 
print(n, m)

 7 

abs() 함수는 절댓값을 씌워주는 함수이다. 
 12 4 

divmod()함수는 몫과 나머지를 동시에 반환해 준다. 

import math
print(math.ceil(5.1))  # 이 숫자보다 크면서 가장 작은 정수 
print(math.floor(3.874))  # 이 숫자보다 작으면서 가장 큰 정수

 6 
 3 

math.ceil() : 인자에 들어간 숫자보다 크면서 가장 작은 정수 

math.floor : 인자에 들어간 숫자보다 작으면서 가장 큰 정수 

2. 문자열 

str1 = "I am a geak!"
str2 = "NiceGirl"
str3 = ""
str4 = str()

print(len(str1), len(str2), len(str3), len(str4))  # 공백 포함

 12 8 0 0 

공백을 포함하여 문자열의 개수를 세는 len() 함수

escape_str1 = "Do you have a \"big collection\"?"
print(escape_str1)
escape_str2 = "Tab\tTab\tTab"
print(escape_str2)

 Do you have a "big collection"? 

같은 종류 따옴표를 안에 넣기 위하여 이스케이프 문자를 사용한다. 

 Tab     Tab     Tab 

- Raw String

raw_s1 = r'C:\Programs\Test\Bin'
print(raw_s1)
raw_s2 = r"\\a\\a"
print(raw_s2)

 C:\Programs\Test\Bin 
 \\a\\a 

rwa string으로 이스케이프문 없이 그대로 출력이 가능하다. 

- 멀티라인 : 다음줄과 이어진다. 

multi = \
"""
문자열 
멀티라인 
테스트
"""
print(multi)

 문자열 
 멀티라인 
 테스트 

- 문자열 연산 

str_o1 = '*'
str_o2 = 'abc'
str_o3 = 'def'
str_o4 = 'Niceman'

print(str_o1 * 100)
print(str_o2 + str_o3)
print(str_o1 * 3)
print('a' in str_o4)
print('f' in str_o4)
print('z' not in str_o4)

 **************************************************************************************************** 
 abcdef 
 *** 
 True 
 False 
 True 

문자열에 숫자를 곱하거나, 문자열끼리 더하는 연산이 가능하다. 

- 문자열 형변환 

print(str(77) + 'a')
print(str(10.4))

 77a 
 10.4 

- 문자열 함수

<문자열 함수 참고> 

https://www.w3schools.com/python/python_ref_string.asp

a = 'niceman'
b = 'orange'

print(a.islower())  # 소문자인지 : Bool 반환
print(b.endswith('e'))  # e로 끝나는지 : Bool 반환
print(a.capitalize())  # 첫 글자를 대문자로 
print(a.replace('nice', 'good'))  # nice를 good으로 대체해라
print(list(reversed(b)))  # 뒤집어서 리스트로 반환하라

 True 

 True 
 Niceman 
 goodman 
 ['e', 'g', 'n', 'a', 'r', 'o'] 

- 문자열 슬라이싱 

a = 'niceman'
b = 'orange'

print(a[0:3])
print(a[0:4])
print(a[0:len(a)])
print(a[:4])
print(b[0:4:2])
print(b[1:-2])
print(b[::-1])

 nic 
 nice 
 niceman 
 nice 
 oa 
 ran 
 egnaro 

 a[0:n] 일 때 0번째 글자부터 n-1번째 글자까지를 반환한다. 

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

<참고 링크>

https://www.python-course.eu/python3_formatted_output.php

1. 기본 출력 

print('Hello Python!')
print("Hello Python!")
print("""Hello Python!""")
print('''Hello Python!''')

 Hello Python! 
 Hello Python! 
 Hello Python! 
 Hello Python! 

작은따옴표, 큰따옴표 1개 혹은 3개로 감싸준다. 

2. seperator 옵션 사용 

print('T', 'E', 'S', 'T', sep='')
print('2019', '02', '19', sep='-')
print('niceman', 'google.com', sep="@")

 TEST 
 2019-02-19 
 niceman@google.com 

print함수의 인자에 sep= 옵션을 넣어주면 sep에 들어가는 문자가 중간에 들어 가 문자열을 이어 준다. 

3. end 옵션 사용 

print('Welcom To', end=' ')
print('the black prade', end=' ')
print('piano notes')

 Welcom To the black prade piano notes 

end옵션은 defalut가 \n으로 들어 가 있어 사용하지 않으면 자동으로 줄바꿈이 됐었다. end=' ' 를 사용하면 위와 같이 그 다음 줄이 호출될 때 띄어 쓰기 한 번 후 출력이 된다. 

4. format 사용  { }. ( ) 

print('{} and {}'.format('You', 'Me'))
print("{0} and {1} and {0}".format('You', 'Me'))
print('{a} and {b}'.format(a='You', b='Me'))

 You and Me 
 You and Me and You 
 You and Me 

format 함수로 문자열에 값을 넣어줄 수 있다. 

print("%s favorite number is %d" % ('Silver', 7))
print("Test1: %5d, Price: %4.2f" % (776, 6534.123))

 Silver favorite number is 7 
 Test1:   776, Price: 6534.12 

* %s : 문자, %d : 정수, %f : 실수

%를 사용하여 글자수나, type에 대해 명시적으로 기입해 놓을 수 있다. 

print("Test1: {0: 5d}, Price: {1: 4.2f}".format(776, 6534.123))
print('Test1: {a: 5d}, Price: {b: 4.2f}'.format(a=776, b=6534.123))

 Test1:   776, Price:  6534.12 
 Test1:   776, Price:  6534.12 

위와 같이 format을 사용하여 글자수와 type을 지정해줄 수도 있다. 

5. 이스케이프 문자 

print("'you'")
print('\'you\'')
print('"you"')
print("""'you'""")
print('\\you\\\n')
print('\t\t\ttest')

 'you' 

종류가 다른 따옴표를 사용하면 이처럼 안에 있는 따옴표로 나오도록 할 수 있다. 

 'you' 

종류가 같은 따옴표를 사용하려면 이스케이프 문자를 사용하여 출력한다. 

 "you" 
 'you' 

 \you\ 

                              
                        test 

\\, \n, \t 을 사용하여 \, 줄바꿈, 탭을 실행할 수도 있따. 

* 이스케이프 문자 

\n : 개행

\t : 탭

\\ : 문자

\' : 문자

\" : 문자

\r : 캐리지 리턴

\f : 폼 피드

\a : 벨 소리

\b : 백 스페이스

\000 : 널 문자

...

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

<이전 글>

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에 넣어 그룹별로 확인해볼 수 있다.