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

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

 

 

<이전 글>

https://silvercoding.tistory.com/28

[python 심화] 11. 클래스 Getter, Setter, 추상클래스 , class ABC

* 이번 포스팅 부터 공부할 것 : 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에 넣어 그룹별로 확인해볼 수 있다.