본문 바로가기
카테고리 없음

파이썬 제너레이터와 이터레이터 완벽 이해하기: 메모리 효율적인 코드 작성법

2025. 3. 18.
반응형

오늘은 파이썬의 강력한 기능 중 하나인 제너레이터(Generator)와 이터레이터(Iterator)에 대해 알아보려고 합니다. 이 개념들을 제대로 이해하고 활용하면 메모리 사용량을 획기적으로 줄이고 더 효율적인 코드를 작성할 수 있습니다.

대용량 데이터를 처리하거나 메모리 사용량이 중요한 프로젝트에서 일하고 계신가요? 아니면 그저 파이썬의 더 고급 기능을 마스터하고 싶으신가요? 어떤 이유든, 이 글을 통해 제너레이터와 이터레이터의 개념부터 실전 활용법까지 배워보겠습니다.

📚 목차

1. 이터레이션과 이터러블: 기본 개념

파이썬에서 이터레이션(iteration)이란 컬렉션(리스트, 튜플, 딕셔너리 등)의 요소를 하나씩 순회하는 과정을 말합니다. 여러분이 for 루프를 사용할 때마다 이터레이션이 일어납니다.

for item in [1, 2, 3, 4, 5]:
    print(item)

그런데 이렇게 순회가 가능한 객체들을 이터러블(Iterable)이라고 부릅니다. 파이썬의 리스트, 튜플, 문자열, 딕셔너리는 모두 이터러블입니다.

그렇다면 어떻게 파이썬은 이 객체들을 순회할 수 있는 걸까요? 바로 여기서 이터레이터의 개념이 등장합니다!

2. 이터레이터(Iterator) 심층 분석

2.1 이터레이터 프로토콜 이해하기

이터레이터는 이터레이터 프로토콜을 구현한 객체입니다. 이 프로토콜은 다음 두 가지 메서드로 구성됩니다:

  • __iter__(): 이터레이터 객체 자신을 반환
  • __next__(): 다음 값을 반환하거나, 더 이상 값이 없으면 StopIteration 예외를 발생

이 두 메서드만 제대로 구현되어 있다면, 그 객체는 for 루프에서 사용할 수 있는 이터레이터가 됩니다.

🔍 알고 계셨나요? for 루프를 사용할 때마다 파이썬은 내부적으로 iter() 함수로 이터레이터를 생성하고 next() 함수를 반복적으로, 더 이상 순회할 요소가 없을 때까지 호출합니다.

간단한 예로 리스트의 이터레이터가 어떻게 동작하는지 살펴볼까요?

my_list = [1, 2, 3]
iterator = iter(my_list)  # __iter__() 메서드를 호출하여 이터레이터 객체를 얻음

print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3
print(next(iterator))  # StopIteration 예외 발생

이렇게 이터레이터의 핵심 특징은 한 번에 하나의 값만 처리한다는 것입니다. 그래서 대용량 데이터를 다룰 때 매우 효율적입니다. 모든 데이터를 한꺼번에 메모리에 로드할 필요가 없기 때문이죠.

2.2 나만의 이터레이터 클래스 만들기

이제 직접 이터레이터를 만들어 보겠습니다. 1부터 n까지의 제곱수를 생성하는 이터레이터를 만들어 볼게요.

class SquareIterator:
    def __init__(self, n):
        self.n = n
        self.current = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.current >= self.n:
            raise StopIteration
        
        self.current += 1
        return self.current ** 2

# 사용 예
squares = SquareIterator(5)
for square in squares:
    print(square)

# 출력:
# 1
# 4
# 9
# 16
# 25

직접 만든 클래스가 for 루프에서 잘 동작하는 것을 볼 수 있습니다! 이는 이터레이터 프로토콜을 제대로 구현했기 때문입니다.

하지만 매번 이런 식으로 클래스를 정의하는 것은 번거롭죠? 여기서 제너레이터가 등장합니다!

3. 제너레이터(Generator)의 마법

제너레이터는 이터레이터를 생성하는 더 간편한 방법입니다. 일반 함수와 비슷하지만, return 대신 yield 키워드를 사용하여 값을 하나씩 반환합니다.

3.1 제너레이터 함수: yield의 힘

위의 SquareIterator 클래스를 제너레이터 함수로 다시 작성해 보겠습니다.

def square_generator(n):
    for i in range(1, n+1):
        yield i ** 2

# 사용 예
squares = square_generator(5)
for square in squares:
    print(square)

# 출력:
# 1
# 4
# 9
# 16
# 25

놀랍게도 단 3줄만으로 이터레이터 클래스와 동일한 기능을 구현했습니다! 제너레이터의 강력함을 느끼시나요?

💡 제너레이터의 비밀

yield 키워드를 만나면 함수의 실행이 일시 중단되고 값을 호출자에게 반환합니다. 그리고 next()가 다시 호출되면 중단된 지점부터 실행을 재개합니다. 이런 특성 덕분에 제너레이터는 상태를 유지할 수 있습니다.

이런 동작 방식으로 인해 제너레이터는 메모리를 매우 효율적으로 사용합니다. 모든 값을 미리 계산하여 저장하지 않고, 필요할 때마다 계산하기 때문이죠.

3.2 제너레이터 표현식: 간결함의 예술

리스트 컴프리헨션에 익숙하신가요? 제너레이터 표현식은 이와 비슷하지만, 대괄호([]) 대신 괄호(())를 사용합니다.

# 리스트 컴프리헨션 (모든 값을 메모리에 저장)
squares_list = [i ** 2 for i in range(1, 6)]
print(squares_list)  # [1, 4, 9, 16, 25]

# 제너레이터 표현식 (값이 필요할 때만 계산)
squares_gen = (i ** 2 for i in range(1, 6))
print(squares_gen)  # <generator object <genexpr> at 0x...>

# 제너레이터 순회하기
for square in squares_gen:
    print(square)

제너레이터 표현식은 간결함과 효율성을 모두 갖춘 강력한 도구입니다. 대규모 데이터 처리에 특히 유용하죠.

그런데 진짜로 메모리 효율이 얼마나 차이 날까요? 다음 섹션에서 알아보겠습니다.

4. 메모리 효율성 비교: 리스트 vs 제너레이터

백만 개의 숫자를 다루는 상황을 생각해 봅시다. 리스트와 제너레이터의 메모리 사용량을 비교해 보겠습니다.

import sys

# 백만 개의 숫자를 포함하는 리스트
numbers_list = [i for i in range(1_000_000)]
print(f"리스트 크기: {sys.getsizeof(numbers_list) / (1024 * 1024):.2f} MB")

# 백만 개의 숫자를 생성하는 제너레이터
numbers_gen = (i for i in range(1_000_000))
print(f"제너레이터 크기: {sys.getsizeof(numbers_gen) / 1024:.2f} KB")

# 출력 예시:
# 리스트 크기: 8.39 MB
# 제너레이터 크기: 0.10 KB

결과를 보세요! 리스트는 약 8MB의 메모리를 사용하지만, 제너레이터는 단 0.1KB만 사용합니다. 이는 제너레이터가 모든 값을 미리 생성하지 않고, 필요할 때마다 값을 생성하기 때문입니다.

🧠 생각해보기: 1억 개의 데이터를 처리해야 한다면 어떨까요? 리스트는 약 800MB의 메모리가 필요하지만, 제너레이터는 여전히 불과 몇 KB만 사용할 것입니다!

이런 메모리 효율성은 대용량 데이터 처리, 스트리밍 데이터 처리, 또는 메모리가 제한된 환경에서 특히 중요합니다.

5. 고급 제너레이터 테크닉

이제 제너레이터의 더 강력한 기능들을 살펴보겠습니다. 일반 이터레이터로는 구현하기 어려운 기능들이죠.

5.1 send() 메서드로 양방향 통신하기

제너레이터는 yield를 통해 값을 반환할 뿐만 아니라, send() 메서드를 통해 값을 받을 수도 있습니다. 이는 양방향 통신을 가능하게 합니다.

def echo_generator():
    value = yield "준비되었습니다!"
    while True:
        value = yield f"에코: {value}"

gen = echo_generator()
print(next(gen))  # 첫 번째 yield 값: "준비되었습니다!"
print(gen.send("안녕하세요"))  # "에코: 안녕하세요"
print(gen.send("파이썬"))  # "에코: 파이썬"
print(gen.send("제너레이터는 멋져요"))  # "에코: 제너레이터는 멋져요"

이 예제에서 yield는 값을 반환할 뿐만 아니라, send()로 전달된 값을 받아 value 변수에 저장합니다. 이렇게 제너레이터는 단순한 데이터 생성기를 넘어 코루틴(coroutine)으로 활용될 수 있습니다.

5.2 데이터 파이프라인 구축하기

제너레이터는 데이터 처리 파이프라인을 구축하는 데 매우 유용합니다. 각 단계를 제너레이터로 구현하면 메모리 효율적인 파이프라인을 만들 수 있습니다.

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

def filter_comments(lines):
    for line in lines:
        if not line.startswith('#'):
            yield line

def parse_data(lines):
    for line in lines:
        parts = line.split(',')
        if len(parts) >= 2:
            yield (parts[0], float(parts[1]))

# 파이프라인 구성
file_path = 'data.csv'
lines = read_data(file_path)
filtered_lines = filter_comments(lines)
data_points = parse_data(filtered_lines)

# 데이터 처리
for name, value in data_points:
    print(f"{name}: {value}")

위 코드는 파일을 한 줄씩 읽고, 주석을 필터링하고, 데이터를 파싱하는 파이프라인을 구성합니다. 각 단계는 필요할 때마다 처리되므로, 파일 크기에 관계없이 메모리 사용량이 일정합니다.

⚠️ 주의사항

제너레이터는 한 번만 순회할 수 있습니다. 두 번째 순회를 시도하면 아무 값도 얻을 수 없습니다. 필요하다면 제너레이터 함수를 다시 호출해야 합니다.

6. 실전 사례: 제너레이터와 이터레이터 활용

실제 프로젝트에서 제너레이터와 이터레이터를 어떻게 활용할 수 있을까요? 몇 가지 예를 살펴보겠습니다:

  1. 대용량 파일 처리: 기가바이트 단위의 로그 파일을 분석할 때, 전체 파일을 메모리에 로드하지 않고 한 줄씩 처리할 수 있습니다.
  2. 무한 시퀀스 생성: 무한한 수열(예: 피보나치 수열, 소수 등)을 필요한 만큼만 생성할 수 있습니다.
  3. 데이터베이스 쿼리 결과 처리: 대량의 데이터베이스 레코드를 한 번에 모두 메모리에 로드하지 않고 처리할 수 있습니다.
  4. 실시간 데이터 스트림 처리: 센서 데이터나 트위터 스트림과 같은 실시간 데이터를 효율적으로 처리할 수 있습니다.

예를 들어, 피보나치 수열을 생성하는 제너레이터를 만들어 보겠습니다:

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

# 사용 예
fib = fibonacci()
for _ in range(10):
    print(next(fib), end=' ')
# 출력: 0 1 1 2 3 5 8 13 21 34

이 제너레이터는 무한한 피보나치 수열을 생성할 수 있지만, 메모리는 상수 만큼만 사용합니다. 필요한 수만 계산하기 때문이죠.

7. 결론 및 요약

이제 파이썬의 이터레이터와 제너레이터에 대해 깊이 있게 알아보았습니다. 이러한 개념들은 메모리 효율적인 프로그래밍의 핵심이며, 대용량 데이터 처리에 필수적인 도구입니다.

요약하자면:

  • 이터레이터는 __iter__()와 __next__() 메서드를 구현한 객체로, 데이터를 하나씩 순회할 수 있게 해줍니다.
  • 제너레이터는 이터레이터를 쉽게 만들 수 있는 함수로, yield 키워드를 사용하여 값을 하나씩 반환합니다.
  • 이 둘의 가장 큰 장점은 메모리 효율성입니다. 전체 시퀀스를 메모리에 로드하지 않고, 필요한 값만 계산합니다.
  • 제너레이터는 send() 메서드를 통한 양방향 통신, 데이터 파이프라인 구축 등 고급 기능도 제공합니다.

이제 여러분도 대용량 데이터를 효율적으로 처리하는 파이썬 코드를 작성할 수 있을 것입니다. 제너레이터와 이터레이터를 적극 활용하여 메모리 사용량을 최소화하고, 더 깨끗하고 효율적인 코드를 작성해보세요!

마지막으로, 파이썬에서 제너레이터와 이터레이터를 마스터하는 것은 고급 파이썬 개발자로 성장하는 중요한 단계입니다. 이 개념들을 이해하고 활용함으로써, 여러분의 코딩 스킬은 한 단계 더 발전할 것입니다.

혹시 더 궁금한 점이 있거나, 제너레이터와 이터레이터를 활용한 여러분만의 경험이 있다면 댓글로 공유해 주세요! 함께 배우고 성장해 나가요.

반응형
저작자표시 비영리 변경금지 (새창열림)

댓글

티스토리툴바