파이썬 - 제너레이터

제너레이터의 정의와 기본 개념

제너레이터는 파이썬에서 이터레이터(iterator)를 생성하는 함수다.
일반 함수와 달리 yield 문을 사용하여 데이터를 하나씩 반환한다.
이는 모든 결과를 메모리에 저장하지 않고, 필요할 때마다 값을 생성할 수 있게 해준다.
제너레이터 함수가 호출되면, 함수 본문이 즉시 실행되지 않는다. 대신, 제너레이터 객체가 반환된다.
이 객체의 next() 메서드가 호출될 때마다 함수는 다음 yield 문까지 실행되고, 해당 값을 반환한다.

제너레이터를 처음 접했을 때는 그저 '특이한 함수' 정도로만 생각했다. 하지만 실제 프로젝트에서 사용해보니, 그 유용성에 놀랐다. 특히 대용량 데이터를 다룰 때 메모리 사용량을 크게 줄일 수 있었다.

• 간단한 제너레이터 함수의 예시

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()
print(next(gen))  # 출력: 1
print(next(gen))  # 출력: 2
print(next(gen))  # 출력: 3

이 예시에서 simple_generator 함수는 세 개의 값을 순차적으로 생성한다. next() 함수를 호출할 때마다 다음 값이 반환된다.

제너레이터의 장점

1. 메모리 효율성

제너레이터는 모든 값을 한 번에 메모리에 저장하지 않고, 필요할 때마다 값을 생성한다. 이는 대용량 데이터셋을 다룰 때 특히 유용하다.

한 번은 수 기가바이트 크기의 로그 파일을 분석해야 했는데, 제너레이터를 사용하지 않았다면 메모리 부족으로 프로그램이 중단되었을 것이다. 제너레이터 덕분에 원활하게 작업을 완료할 수 있었다.

2. 성능 향상

필요한 값만 생성하므로, 전체 시퀀스를 미리 계산하는 것보다 초기 응답 시간이 빠르다.

3. 무한 시퀀스 표현

제너레이터를 사용하면 이론적으로 무한한 데이터 스트림을 표현할 수 있다.

무한 시퀀스 개념은 처음에는 이해하기 어려웠다. 하지만 실시간 데이터 스트리밍 프로젝트에서 이 개념이 얼마나 유용한지 깨달았다. 센서 데이터를 지속적으로 처리하는 작업에서 제너레이터가 완벽한 해결책이 되었다.

4. 코드 간결성

복잡한 이터레이터 로직을 간단한 함수로 표현할 수 있다.

제너레이터 표현식

제너레이터 함수 외에도, 파이썬은 제너레이터 표현식을 지원한다. 이는 리스트 컴프리헨션과 유사하지만 대괄호 대신 괄호를 사용한다.

# 리스트 컴프리헨션
squares_list = [x**2 for x in range(10)]

# 제너레이터 표현식
squares_gen = (x**2 for x in range(10))

제너레이터 표현식은 리스트 컴프리헨션의 메모리 효율적인 버전이라고 생각한다. 대규모 데이터 처리 작업에서 이 작은 차이가 프로그램의 성능을 크게 향상시켰다.

실제 사용 사례

1. 대용량 파일 처리

def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()

for line in read_large_file('huge_file.txt'):
    process_line(line)

이 예시에서 read_large_file 함수는 대용량 파일을 한 줄씩 읽어 처리한다. 전체 파일을 메모리에 로드하지 않고도 효율적으로 처리할 수 있다.

제너레이터 표현식은 리스트 컴프리헨션의 메모리 효율적인 버전이라고 생각한다. 대규모 데이터 처리 작업에서 이 작은 차이가 프로그램의 성능을 크게 향상시켰다.

2. 피보나치 수열 생성

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

fib = fibonacci()
for _ in range(10):
    print(next(fib))

이 제너레이터는 무한한 피보나치 수열을 생성한다. 필요한 만큼만 값을 생성할 수 있어 효율적이다.

무한 시퀀스의 개념을 이해하는 데 이 예제가 큰 도움이 되었다. 실제로 이런 패턴을 사용해 페이지네이션 없이 무한 스크롤 기능을 구현한 적이 있다.

3. 데이터 파이프라인 구축

def data_source():
    for i in range(100):
        yield i

def process_data(data):
    for item in data:
        yield item * 2

def filter_data(data):
    for item in data:
        if item % 4 == 0:
            yield item

pipeline = filter_data(process_data(data_source()))
for item in pipeline:
    print(item)

이 예시는 데이터 소스, 처리, 필터링의 파이프라인을 제너레이터를 사용해 구현한다. 각 단계가 필요할 때만 실행되어 메모리 사용을 최소화한다.

이런 파이프라인 패턴은 데이터 처리 작업에서 정말 유용하다. 한 번은 이 패턴을 사용해 복잡한 ETL(Extract, Transform, Load) 프로세스를 구현했는데, 코드의 가독성과 유지보수성이 크게 향상되었다.

제너레이터의 고급 기능

1. send() 메서드

제너레이터는 send() 메서드를 통해 외부에서 값을 주입받을 수 있다.

def echo_generator():
    while True:
        received = yield
        yield f"Echo: {received}"

gen = echo_generator()
next(gen)  # 제너레이터 초기화
print(gen.send("Hello"))  # 출력: Echo: Hello
print(gen.send("World"))  # 출력: Echo: World

2. throw() 메서드

제너레이터 내부로 예외를 전달할 수 있다.

def number_generator():
    try:
        yield 1
        yield 2
        yield 3
    except ValueError:
        yield 'Error occurred'

gen = number_generator()
print(next(gen))  # 출력: 1
print(gen.throw(ValueError))  # 출력: Error occurred

3. close() 메서드

제너레이터를 강제로 종료할 수 있다.

def countdown():
    i = 5
    while i > 0:
        yield i
        i -= 1

gen = countdown()
print(next(gen))  # 출력: 5
print(next(gen))  # 출력: 4
gen.close()
print(next(gen))  # StopIteration 예외 발생

close() 메서드는 리소스 관리 측면에서 매우 중요하다는 것을 깨달았다. 특히 데이터베이스 커넥션이나 파일 핸들러를 다루는 제너레이터에서 이 메서드를 활용하여 안전하게 리소스를 해제할 수 있었다.

제너레이터와 코루틴

제너레이터는 코루틴의 기반이 된다. 코루틴은 여러 진입점을 가진 서브루틴으로, 비동기 프로그래밍에서 중요한 역할을 한다.

import asyncio

async def async_generator():
    for i in range(3):
        await asyncio.sleep(1)
        yield i

async def main():
    async for item in async_generator():
        print(item)

asyncio.run(main())

이 예시는 비동기 제너레이터를 사용하여 비동기적으로 값을 생성하고 처리한다.

제너레이터의 성능 고려사항

제너레이터는 많은 경우에 리스트나 다른 시퀀스 타입보다 효율적이지만, 모든 상황에서 최선의 선택은 아니다.

1. 반복 횟수

데이터를 여러 번 반복해야 하는 경우, 제너레이터는 매번 값을 재생성해야 하므로 비효율적일 수 있다.

2. 인덱싱과 슬라이싱

제너레이터는 인덱싱과 슬라이싱을 직접 지원하지 않는다. 필요한 경우 리스트로 변환해야 한다.

3. 메모리 사용

대용량 데이터를 다룰 때 제너레이터가 유리하지만, 작은 데이터셋에서는 리스트가 더 빠를 수 있다.

close() 메서드는 리소스 관리 측면에서 매우 중요하다는 것을 깨달았다. 특히 데이터베이스 커넥션이나 파일 핸들러를 다루는 제너레이터에서 이 메서드를 활용하여 안전하게 리소스를 해제할 수 있었다.

• 성능 비교 예시

import time

def list_approach(n):
    return [i**2 for i in range(n)]

def generator_approach(n):
    return (i**2 for i in range(n))

n = 10**6

# 리스트 방식
start = time.time()
squares_list = list_approach(n)
sum(squares_list)
print(f"List time: {time.time() - start}")

# 제너레이터 방식
start = time.time()
squares_gen = generator_approach(n)
sum(squares_gen)
print(f"Generator time: {time.time() - start}")

이 예시는 큰 수의 제곱을 계산하고 합산하는 데 있어 리스트와 제너레이터의 성능을 비교한다. 대부분의 경우 제너레이터가 더 빠르고 메모리 효율적이다.

이런 성능 비교 테스트는 실제 프로젝트에서 매우 중요하다는 것을 깨달았다. 한 번은 이와 유사한 테스트를 통해 프로그램의 병목 지점을 찾아 전체 실행 시간을 절반으로 줄인 경험이 있다. 항상 가정이 아닌 실제 측정을 통해 최적화를 진행해야 한다는 교훈을 얻었다.

제너레이터의 디버깅과 테스팅

제너레이터는 지연 평가(lazy evaluation) 특성 때문에 디버깅이 까다로울 수 있다. 이 때 몇 가지 유용한 팁들이다.

1. 로깅 사용

yield 문 주변에 로그를 추가하여 실행 흐름을 추적한다.

로깅은 제너레이터 디버깅의 생명줄이다. 복잡한 데이터 처리 파이프라인에서 각 단계마다 로그를 추가하여 데이터 흐름을 추적했던 경험이 있다. 이를 통해 예상치 못한 데이터 변형 지점을 빠르게 찾아낼 수 있었다.

2. 리스트로 변환

디버깅 중에 제너레이터를 리스트로 변환하여 모든 값을 한 번에 확인한다.

3. 단위 테스트 작성

제너레이터 함수의 예상 출력을 검증하는 테스트를 작성한다.

• 테스트 예시

import unittest

def even_numbers(n):
    for i in range(n):
        if i % 2 == 0:
            yield i

class TestEvenNumbers(unittest.TestCase):
    def test_even_numbers(self):
        result = list(even_numbers(10))
        self.assertEqual(result, [0, 2, 4, 6, 8])

if __name__ == '__main__':
    unittest.main()

제너레이터의 단위 테스트 작성은 처음에는 어색했다. 하지만 복잡한 데이터 변환 로직을 테스트하면서 그 중요성을 깨달았다. 특히 엣지 케이스를 테스트하는 것이 중요한데, 한 번은 이를 통해 무한 루프 버그를 사전에 발견한 적이 있다. 테스트 주도 개발(TDD) 방식으로 제너레이터를 개발하는 것이 코드의 안정성을 크게 높인다는 것을 경험했다.