TIL19. Python : Generator 이란?

📌 이 포스팅에서는 Python의 Generator에 대해 알아보겠습니다.

🌈 Generator 이란?

🔥 반복형과 iter

🔥 Generator는 왜 쓸까요?

🔥 Generator 내장 함수

1. 반복형과 iter

🤔 반복이 가능한 이유?

✔️ for, collections, List, Dict, Set, Tuple, unpacking 등의 반복형 데이터 타입이 반복이 가능한 이유는 내부적으로 iter 함수를 갖고 있기 때문입니다.

# for 사용
t = "ABCDEF"
for i in t:
    print(i)

# while문 사용
t = "ABCDEF"
w = iter(t) # 👈 반복형은 iter을 사용할 수 있음
while True:
    try:
        print(next(w))
    except StopIteration: # 👈 StopIteration 예외가 발생하면, 반복을 중단
        break

🤔 반복이 가능한지는 어떻게 확인할 수 있을까?

✔️ __iter__ 속성을 가지고 있는지 확인하려면, dir로 확인할 수 있습니다.
✔️ hasattr 함수는 대상이 해당 속성을 가지고 있는지 확인하여 Boolean값으로 반환해줍니다.
✔️ 이를 이용하여 확인할 대상과, iter 속성을 전달하여 반복이 가능한지 손쉽게 확인 가능합니다.

# 반복 가능여부 확인
t = "ABCDEF"
print(hasattr(t, '__iter__')) # True
print(hasattr(12345, '__iter__')) # False

2. Generator는 왜 쓸까요?

🤔 Generator 란?

✔️ 반복형에서 다음 순서인 요소를 가르키기만하고, next를 실행할 때 반환해주는 것이 Generator의 패턴입니다. Generator는 각 요소를 발전기에서 생산하듯이 호출할 때만 하나하나 반환시켜줍니다.

# Generator 패턴
class wordSplitIter:
    def __init__(self, text):
        self._idx = 0 
        self._text = text.split(" ") 
    # next 매서드 오버라이딩    
    def __next__(self):
        try:
            word = self._text[self._idx]  # 👈 인덱스를 이용하여 요소를 순차적으로 가르킵니다.
        except IndexError:
            raise StopIteration()
        self._idx += 1  # 👈 index를 1씩 증가시킵니다.
        return word  # 👈 요소를 반환합니다.
    def __repr__(self):
        return f"{self._text}"
# 객체 생성        
wi = wordSplitIter("What are you going to have for dinner tonight?")
print(wi)  # ['What', 'are', 'you', 'going', 'to', 'have', 'for', 'dinner', 'tonight?']
print(next(wi))  # What
print(next(wi))  # are
print(next(wi))  # you
print(next(wi))  # going
print(next(wi))  # to
print(next(wi))  # have
print(next(wi))  # for
print(next(wi))  # dinner
print(next(wi))  # tonight?

✔️ 위에 코드 처럼 next 매서드에 오버라이딩하여 구현하면, next매서를 통해 index를 기억하고 있어야합니다. 이런 불필요한 것들은 iter 매서드를 오버라이딩하면 아래처럼 간편하게 구현할 수 있습니다.
✔️ "yield" 예약어는 반복형의 index를 기억하여 다음 호출이 발생할 때 반환할 요소를 준비시키고 yield를 만나면 정지합니다.
✔️ 또한 "yield" 예약어는 모두 순회했을 때, StopIteration Error를 자동으로 일으킵니다. 이에 "StopIteration"의 except 구문을 직접 작성하지 않아도 됩니다.

# Generator 구현
class wordSplitGenerator:
    def __init__(self, text):
        self._text = text.split(" ")
    def __iter__(self):
        for word in self._text:
            yield word  # 👈 이것이 바로 Generator입니다ㅏ.
        return
    def __repr__(self):
        return f"{self._text}"
wg = wordSplitGenerator("What are you going to have for dinner tonight?")
wt = iter(wg) # 👈 iter에 전달해준뒤 사용합니다.
print(wt)  # <generator object wordSplitGenerator.__iter__ at 0x7ff3ef401900>
print(next(wt))  # What
print(next(wt))  # are
print(next(wt))  # you
print(next(wt))  # going
print(next(wt))  # to
print(next(wt))  # have
print(next(wt))  # for
print(next(wt))  # dinner
print(next(wt))  # tonight?

🤔 Generator 왜 쓸까?

✔️ Generator 패턴을 사용하면 지능형 리스트, 딕셔너리, 집합 등의 반복형을 사용할 때 보다 메모리 사용량 감소시킬 수 있습니다.
✔️ 영어사전에 모든 단어를 Dict나 List에 담는다면 엄청난 메모리를 필요로하지만, Generator 패턴은 현저히 적은 메모리를 사용하면서 자료구조를 활용할 수 있습니다.
✔️ Generator가 더 적은 메모리를 사용할 수 있는 이유는 Generator의 next라는 함수가 호출될 때만 데이터를 하나하나 가져오기 때문입니다.
✔️ 또한 단위 실행 가능한 Coroutine을 이해하기 위해서 Generator를 이해하는 것이 중요합니다.

🤔 Generator 특징

✔️ Generator는 일반적으로 함수로 사용합니다. 아래 Generator 함수를 통해 yield의 특징을 살펴보겠습니다.
✔️ 함수가 호출되었을 때, yield를 만나면 멈추었다가 다시 next로 호출이 이뤄지며 다음 yield를 만나기 전까지 작동되는 것을 볼 수 있습니다.
✔️ yield가 실행 때, 다음 yield를 만난 위치를 기억하고 대기하고 있는 것이죠.

def generator1():
    print("Start!")
    yield "AAA"
    print("Continue!")
    yield "BBB"
    print("Continue!")
    yield "CCC"
temp = iter(generator1())  # 👈 generator는 iter 함수에 담아 사용합니다.

print(next(temp))
"""
Start!
AAA
"""

print(next(temp))
"""
Continue!
BBB
"""

print(next(temp))
"""
Continue!
CCC
"""

✔️ Generator는 반복문과 사용할 때 진가를 발휘합니다. 순회 가능한 요소가 존재할 때 까지만 반복하기 때문이죠.
✔️ 즉, for문은 StopIteration Error를 발생시키지 않게해줍니다.
✔️ for문을 사용하지 않는다면 위에처럼 next함수를 여러번 이용해야하고, StopIteration Error이 발생될 수 있기 때문에 Generator는 for문과 함께 주로 사용됩니다.

for i in generator1():
    print(i)
"""
Start!
AAA
Continue!
BBB
Continue!
CCC
"""

✔️ 컴프리헨션과 Generator를 사용해보겠습니다.

temp2 = [i*3 for i in generator1()]
print(temp2)
"""
Start!
Continue!
Continue!
['AAAAAAAAA', 'BBBBBBBBB', 'CCCCCCCCC']
"""
for i in temp2:
    print(i)
"""
AAAAAAAAA
BBBBBBBBB
CCCCCCCCC
""" 

✔️ 튜플처럼 괄호로 컴프리헨션을 이용하면 Generator를 반환시켜줍니다. 메모리를 사용하지 않고, 반복형 데이터셋을 준비시켜줍니다.

temp3 = (i*3 for i in generator1())
print(temp3) # <generator object <genexpr> at 0x7fdd34a01900>
for i in temp3:
    print(i)
"""
Start!
AAAAAAAAA
Continue!
BBBBBBBBB
Continue!
CCCCCCCCC
"""   

3. Generator 내장 함수

🤔 itertools.count()

✔️ Generator의 다양한 함수를 이용하기 위해서는 "itertools"를 가져옵니다.
✔️ itertools의 count 함수는 start와 stop을 전달받아 next가 실행할 때마다 연산을 수행해줍니다.
✔️ count는 한계를 정해두지 않은 무한이기 때문에 for문을 돌리면 무한하게 작동하기 때문에 start와 stop을 통해 범위를 정해줍니다.

import itertools
gen1 = itertools.count(1, 2.5)
print(next(gen1)) # 1
print(next(gen1)) # 3.5
print(next(gen1)) # 6.0
print(next(gen1)) # 8.5

🤔 itertools.takewhile()

✔️ takewhile()은 첫번째 parameter로 종료 조건이 명시된 함수를 받고, 두번째 parameter로 generator를 전달해주면됩니다.
✔️ 1부터 100이전까지 2.5씩 증가하면서 generator를 생성합니다.

import itertools
gen2 = itertools.takewhile(lambda n: n<100, itertools.count(1, 2.5))
for i in gen2:
    print(i, end=', ')
"""
1, 3.5, 6.0, 8.5, 11.0, 13.5, 16.0, 18.5, 21.0, 23.5, 26.0, 28.5, 31.0, 33.5, 36.0, 38.5, 41.0, 43.5, 46.0, 48.5, 51.0, 
53.5, 56.0, 58.5, 61.0, 63.5, 66.0, 68.5, 71.0, 73.5, 76.0, 78.5, 81.0, 83.5, 86.0, 88.5, 91.0, 93.5, 96.0, 98.5
"""

🤔 itertools.filterfalse()

✔️ filterfalse()는 명시된 조건과 반대되는 값을 filtering하여 generator로 생성 후 반환합니다.
✔️ 첫번째 parameter는 조건을 함수로 받고, 두번째 parameter는 대상 범위를 받습니다.

import itertools
gen3 = itertools.filterfalse(lambda n: n<5, range(10))
for i in gen3:
    print(i)
"""
5
6
7
8
9
"""

🤔 itertools.accumulate()

✔️ accumulate()는 반복하면서 값을 누적시킵니다.

import itertools
gen4 = itertools.accumulate(x for x in range(1,11))    
for i in gen4:
    print(i)
"""
1
3
6
10
15
21
28
36
45
55
"""

🤔 itertools.product()

✔️ product()는 tuple 형태로 요소를 쪼개서 반환합니다.
✔️ repeat 옵션을 사용하면 그 수만큼 쪼갠 결과를 반복하여 모든 경우의 수를 generator를 생성합니다.

import itertools
gen5 = itertools.product('ABCDE')    
print(list(gen5)) # [('A',), ('B',), ('C',), ('D',), ('E',)]
gen6 = itertools.product('ABCDE', repeat=2)    
print(list(gen6))
"""
[('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')]
"""