Python - Iterators, Generators, Classic Coroutines

[!TIP] Source 전문가를 위한 파이썬(Fluent Python) 17장

Iterable, Iterator

반복형(Iterable)과 반복자(Iterator)

• 정의

  • 반복형(Iterable): for 루프에서 쓸 수 있는 객체. iter() 함수를 적용할 수 있는 객체.
  • 반복자(Iterator): next() 메서드로 다음 값을 계속 꺼낼 수 있는 객체. 끝에 도달하면 StopIteration 예외를 발생시킴.

• 둘의 관계: 반복형은 반복자를 생성하는 객체임. 즉 반복형은  __iter__() 메서드를 구현하고, 이 메서드는 반복자(iterator)를 리턴 해야 함.

• iter() 내장함수란?

  • 파이썬이 반복을 시작할 때 호출하는 함수로 다음 2가지 동작을 함
    • 객체에 __iter__()가 있으면 그걸 호출해서 반복자를 리턴.
    • 없으면, __getitem__() 이 구현되어 있는 경우, 인덱스 0부터 순차적으로 값을 꺼내 반복자를 흉내냄. 인덱스 오류가 나면 멈춤
      • 이게 바로 모든 시퀀스가 반복형인 이유 -> str, list, tuple 같은 시퀀스 객체는 __getitem__()을 통해 인덱스로 접근할 수 있어서 반복이 지원되기 때문

import re
import reprlib

RE_WORD = re.compile(r'\w+')


class Sentence:
    def __init__(self, text):
        self.text = text
        self.words = RE_WORD.findall(text)

    def __repr__(self):
        return f'Sentence({reprlib.repr(self.text)})'

    def __iter__(self):
        return SentenceIterator(self.words)  


class SentenceIterator:
    def __init__(self, words):
        self.words = words  
        self.index = 0  
    def __next__(self):
        try:
            word = self.words[self.index]  
        except IndexError:
            raise StopIteration() 
        self.index += 1  
        return word  
    def __iter__(self): 
        return self

• Iterator는 기본적으로 위 예시와 같이 index의 상태를 카운트함.

  • __next__를 구현해야 함 = 다음 값을 꺼내는 함수. 다음 값을 꺼내고, index를 하나 올리고, index가 끝까지 가면 StopIteration 예외를 발생시킴.
  • Iterator에서도 __iter__를 구현해야 함 = for 루프 등 반복형이 필요한 곳에 사용되려면 Iterator 자신도 iterable이어야 하기 때문에. 자기 자신을 돌려주도록 구현.

• __getitem__을 써도 반복형으로 잘 동작하는데 왜 Iterator를 제대로 구현해야 하나?

  • __getitem__의 단점은 한번에 메모리에 모든 데이터를 올려야 하고, 내부 상태가 없는 반복 → 매 반복마다 처음부터 시작
  • 위와 같은 구현의 장점
    • 지연 평가(lazy evaluation) 가능 → 즉 필요한 만큼만 가져와서 필요한 만큼만 계산한다 (메모리 절약)
      • lazy의 반대말은 eager다..
    • 내부 상태(index 등)를 갖고 있어서 복잡한 로직 구현 가능
    • 무한 반복자, 파일 스트리밍 등 동적이고 유연한 반복 처리 가능
    • 여러 개의 반복자를 병렬로 써도 각각 독립적으로 동작
  • 예를 들면
    • 대용량 텍스트 파일에서 줄 단위로 처리하고 싶을 때
    • 네트워크에서 스트리밍으로 데이터를 읽을 때
    • 한 번만 순회 가능한 객체 (예: 제너레이터) 등을 쓸 때

• 한번에 __iter__()과 __next__()를 구현하는 것은 (즉 위 예시에서 SentenceIterator를 안만들고 Sentence에 때려넣기) 안티패턴임

• 이유: 반복을 한번만 하면 끝나버림. 재사용 불가. 병렬 반복이 안됨

s = Sentence("this is not good")
for w in s:
    print(w)  # OK
for w in s:
    print(w)  # 아무 것도 안 나옴 (index가 이미 끝에 있음)

it1 = iter(s)
it2 = iter(s)  # 같은 객체 리턴됨 → 상태 공유됨
next(it1)  # it2도 영향을 받음

Generator

Sentence에서 Iterator를 별도로 만들지 않고 __iter__를 다음과 같이 쓴다면?

def __iter__(self):
    for word in self.words:
        yield word

• = 제너레이터

  • yield 구문을 사용해서 값을 하나씩 생성하는 특별한 함수나 표현식을 의미함
  • return 대신 yield를 사용해서 값을 하나씩 반환하고, 호출자가 next()로 요구할 때마다 중단했던 지점에서 이어서 실행
  • 반복자를 자동으로 만들어주는 문법적 편의 기능으로 이해..
    • 제너레이터 객체는 __next__를 제공하므로 반복자임

• 사실 이터레이터의 장점이 lazy할 수 있다는 거라고 했지만, 위의 예시들은 lazy하지 않았음. findall에서 이미 다 메모리에 올려놓고 순회를 시작하기 때문.

• lazy하게 만든다면?

def __iter__(self):
    for match in RE_WORD.finditer(self.text):
        yield match.group()

• finditer로 매칭되는 단어를 하나씩 돌려줌
• 텍스트가 커도 CPU, 메모리 자원을 효율적으로 사용

def __iter__(self):
    return (match.group() for match in RE_WORD.finditer(self.text))

• 동일한 내용을 제너레이터 표현식으로 작성했음
  • 로직이 간단하고 짧다면 가독성이 높음
  • 여러 줄로 걸칠 거면 그냥 제너레이터 함수 쓰자

표준 라이브러리 제너레이터

Filtering

Mapping

Merging

Expanding

Rearranging

Reduce

Classic Coroutines

• 코루틴은 “함수 ↔ 호출자” 간에 양방향으로 값을 주고받을 수 있는 실행 단위

  • 일반 함수: 호출자 → 함수 → return
  • 제너레이터: 호출자 → 함수 → yield
  • 코루틴: 호출자 ↔ 함수 ←→ send/yield

• 고전적 코루틴이란

  • async/await 문법이 없었을 때 제너레이터에 yield + .send()를 조합 해서 비슷하게 동작하게 했던 것 (파이썬 3.5 이전)

def package_receiver():
    while True:
        package = yield 
        print(f"택배를 받았다: {package}")

receiver = package_receiver()
next(receiver) # 코루틴 가동 (yield까지 실행)
receiver.send("의류")  
receiver.send("전자기기")  

• yield에서 멈추고, 이후에 send를 통해 외부에서 값을 받아서 하나씩 반복해서 동작하는 방식