이터레이터, 제너레이터, 코루틴의 이해와 관계
파이썬의 이터레이터는 for 루프의 근간을 이루는 가장 기본적인 반복 프로토콜로, __next__ 메서드를 통해 다음 요소를 순차적으로 반환하는 객체입니다. 이러한 이터레이터를 직접 클래스로 구현하는 복잡함을 해결하기 위해 등장한 것이 제너레이터이며, 함수 내에서 yield 키워드를 사용하면 파이썬이 자동으로 이터레이터 객체를 생성해주어, 함수의 실행을 중간에 멈추고 값을 반환했다가 다시 재개하는 강력한 기능을 간결하게 구현할 수 있다.
코루틴은 제너레이터의 ‘일시 정지 및 재개’라는 개념을 데이터 스트리밍이 아닌 비동기(Asynchronous) 동시성 처리로 발전시킨 것으로, async/await라는 전용 문법을 통해 I/O 작업과 같이 오래 걸리는 작업을 기다리는 동안 프로그램의 제어권을 이벤트 루프에 넘겨 다른 작업을 처리하게 함으로써 전체 시스템이 멈추지 않고 효율적으로 작동하는 논블로킹(Non-blocking) 프로그래밍을 가능하게 하는 고도로 전문화된 제너레이터의 한 형태이다.
결국 이들은 반복(이터레이터)이라는 기본 개념에서 출발하여, 간편한 지연 연산(제너레이터)를 거쳐, 효율적인 동시성 처리(코루틴)라는 고차원적인 기능으로 점진적으로 발전해 온 밀접한 관계를 가진다
이터레이터 (Iterator)
이터레이터는 파이썬에서 반복 가능한 객체를 구현하는 가장 기본적인 방법이다. 이터레이터는 __iter__()와 __next__() 메서드를 반드시 구현해야 하며, 이를 통해 for 루프나 next() 함수와 함께 사용할 수 있다. __iter__()메서드는 이터레이터 객체 자신을 반환하고, __next__() 메서드는 호출될 때마다 다음 값을 반환하며 더 이상 반환할 값이 없으면 StopIteration 예외를 발생시킨다.
이터레이터의 가장 큰 특징은 지연 연산(lazy evaluation)를 통해 메모리를 효율적으로 사용한다는 점입니다. 모든 값을 미리 생성하여 메모리에 저장하지 않고, 필요할 때마다 하나씩 생성하여 반환하므로 대용량 데이터도 메모리 부족 없이 처리할 수 있다. 하지만 이터레이터를 직접 구현하려면 클래스를 정의하고 두 개의 특수 메서드를 구현해야 하므로 코드가 복잡해지는 단점이 있다.
예시 코드: 카운트다운 이터레이터
class CountdownIterator:
def __init__(self, start):
self.current = start
def __iter__(self):
# 이터레이터 객체는 자기 자신을 반환해야 함
return self
def __next__(self):
if self.current <= 0:
raise StopIteration # 반복 종료
# 현재 값을 반환하고, 다음을 위해 1 감소
result = self.current
self.current -= 1
return result
# 사용법
print("이터레이터 클래스로 카운트다운:")
countdown = CountdownIterator(3)
for num in countdown:
print(num) # 3, 2, 1 출력
사용자 정의 예외 처리는 이터레이터가 데이터를 생성하거나 처리하는 과정에서 실제 오류가 발생했을 때 사용된다. 예를 들어 파일을 읽는 이터레이터에서 파일이 손상되었거나, 네트워크 이터레이터에서 연결이 끊어졌거나, 데이터베이스 이터레이터에서 쿼리 오류가 발생한 경우 등이 해당된다. 이런 상황에서는 적절한 예외를 발생시켜 호출자가 문제 상황을 인지하고 대응할 수 있도록 해야 한다.
사용자 정의 예외를 사용할 때는 예외의 종류를 세분화하여 호출자가 상황에 맞는 처리를 할 수 있도록 하는 것이 중요하다. 일시적인 네트워크 오류는 재시도할 수 있지만, 파일 권한 오류나 데이터 형식 오류는 다른 방식으로 처리해야 하기 때문이다.
제너레이터 (Generator)
제너레이터는 이터레이터를 훨씬 간단하게 만들 수 있게 해주는 파이썬의 강력한 기능입니다. 함수 안에서 yield 키워드를 사용하면 해당 함수는 제너레이터 함수가 되며, 호출할 때마다 제너레이터 객체를 반환합니다. yield는 함수의 실행을 일시 중지하고 값을 반환한 후, 다음 호출 시 중지된 지점에서 다시 실행을 재개한다.
제너레이터의 핵심 장점은 코드의 간결성과 메모리 효율성입니다. 복잡한 클래스 구현 없이도 yield 키워드만으로 이터레이터를 만들 수 있어 코드가 매우 직관적이고 읽기 쉬워집니다. 또한 함수의 지역 변수와 실행 상태가 자동으로 보존되므로 상태 관리에 대한 부담이 없습니다. 제너레이터는 데이터 파이프라인 구축, 무한 시퀀스 생성, 대용량 파일 처리 등에 특히 유용하며, 함수형 프로그래밍 스타일을 지원한다.
예시 코드: 카운트다운 제너레이터
위의 CountdownIterator 클래스와 완전히 동일하게 동작하지만, 코드는 훨씬 간결하다.
def countdown_generator(start):
current = start
while current > 0:
yield current # 값을 반환하고 여기서 실행을 멈춤
current -= 1
# 사용법
print("\n제너레이터 함수로 카운트다운:")
countdown_gen = countdown_generator(3)
for num in countdown_gen:
print(num) # 3, 2, 1 출력
Python 2.2: 제너레이터의 탄생 (yield)
Python 2.2 버전에서 제너레이터가 처음 도입된 배경은 이터레이터를 구현하는 기존 방법이 너무 복잡했기 때문이다. 이전에는 이터레이터를 만들기 위해 클래스를 정의하고 __iter__()와 __next__()메서드를 직접 구현해야 했으며, 상태 관리와 예외 처리까지 개발자가 모두 신경 써야 했다.
제너레이터는 이러한 복잡성을 획기적으로 해결했다. 함수 안에서 yield 키워드를 사용하기만 하면 그 함수는 자동으로 제너레이터 함수가 되며, 파이썬이 이터레이터 프로토콜을 자동으로 구현해준다. 이는 몇십 줄의 클래스 코드를 몇 줄의 간단한 함수로 대체할 수 있게 해주었다.
제너레이터 함수의 독특한 특징은 호출했을 때 즉시 실행되지 않는다는 점이다. 대신 제너레이터 객체를 반환하며, 이 객체는 값을 하나씩 생산할 준비가 된 상태로 대기한다. 실제 실행은 next() 함수나 for 루프를 통해 값을 요청할 때 시작되며, yield를 만날 때마다 실행을 일시 중지하고 값을 반환한다.
이러한 지연 연산(lazy evaluation) 방식 덕분에 메모리를 효율적으로 사용할 수 있게 되었고, 무한 시퀀스나 대용량 데이터도 문제없이 처리할 수 있게 되었다. 제너레이터의 등장으로 파이썬에서 반복 가능한 객체를 만드는 일이 훨씬 쉽고 직관적으로 바뀌었다.
예시 코드 : 이터레이터 클래스 방식 (복잡함)
class NumberIterator:
def __init__(self, limit):
self.limit = limit
self.current = 0
def __iter__(self):
return self
def __next__(self):
if self.current < self.limit:
result = self.current
self.current += 1
return result
else:
raise StopIteration
print("이터레이터 클래스 사용:")
for num in NumberIterator(3):
print(num)
예시 코드 : 제너레이터 함수 방식 (간결함)
def number_generator(limit):
"""0부터 limit-1까지 숫자를 생산하는 제너레이터"""
print(">> 제너레이터 시작")
current = 0
while current < limit:
yield current # 값을 반환하고 여기서 실행을 멈춤
current += 1
print(">> 제너레이터 종료")
print("\n제너레이터 함수 사용:")
for num in number_generator(3):
print(num)
이 단계에서 제너레이터는 단순히 데이터를 생산하는 단방향 역할만 수행했다.
Python 2.5: 양방향 통신과 코루틴의 시작 (.send())
Python 2.5 버전에서는 제너레이터가 단순한 데이터 생산자를 넘어 외부와 상호작용할 수 있는 강력한 도구로 발전했다. 이전까지 제너레이터는 yield를 통해 값을 밖으로 내보내기만 할 수 있었지만, 이 버전부터는 외부에서 값을 받아올 수도 있게 되었다.
가장 중요한 변화는 yield의 역할이 확장된 것이다. 기존에는 단순히 값을 반환하는 문장이었던 yield가 이제 표현식으로도 사용될 수 있게 되어, received_value = yield처럼 외부에서 보낸 값을 변수에 저장할 수 있게 되었다. 이는 제너레이터가 일방향 통신에서 양방향 통신으로 진화했음을 의미한다.
또한 .send(value) 메서드가 새롭게 추가되어 제너레이터 함수 안으로 값을 전달할 수 있게 되었다. 이를 통해 제너레이터는 외부의 명령이나 데이터를 받아 그에 따라 동작을 변경하거나 처리 결과를 달리할 수 있게 되었다. 이러한 기능들이 결합되면서 제너레이터는 단순한 반복자를 넘어 외부와 협력하여 작업을 수행하는 코루틴의 초기 형태가 되었다.
예시 코드: 외부에서 받은 값을 더하는 코루틴
def adder_coroutine():
"""외부에서 숫자를 받아 누적 합계를 출력하는 코루틴"""
print("코루틴 시작. 초기값 대기 중...")
total = 0
while True:
# yield를 통해 외부에서 값을 받고, 그 값을 value에 저장
value = yield total
if value is None: # 처음 next() 호출 시에는 무시
continue
print(f"코루틴: {value} 받음")
total += value
# 사용법
coro = adder_coroutine()
# 코루틴을 처음 시작할 때는 next()를 호출해 첫 yield 지점까지 실행 (프라이밍)
# 이 때, value = yield total에서 total(초기값 0)을 반환함
initial_total = next(coro)
print(f"초기 반환값: {initial_total}")
# .send()로 코루틴 안으로 값을 보냄
# send(10)은 value에 10을 할당하고, 다음 yield를 만날 때까지 실행 후 total을 반환
print(f"누적 합계: {coro.send(10)}")
print(f"누적 합계: {coro.send(20)}")
print(f"누적 합계: {coro.send(5)}")
coro.close()
Python 3.3: 제너레이터 위임 (yield from)
Python 3.3에서 도입된 yield from은 복잡한 제너레이터나 코루틴을 구조화하고 관리하는 문제를 해결하기 위해 등장했다. 이전까지는 여러 개의 제너레이터를 연결하거나 중첩된 코루틴을 다룰 때 복잡한 반복문과 예외 처리 코드가 필요했으며, 코드의 가독성과 유지보수성이 크게 떨어졌다.
yield from의 핵심은 상위 제너레이터가 하위 제너레이터에게 제어권을 완전히 위임한다는 점이다. 마치 전화 통화에서 상대방을 다른 사람에게 연결해주는 것처럼, 상위 제너레이터는 단순히 통로 역할만 하며 모든 상호작용을 하위 제너레이터가 직접 처리하게 된다. 이를 통해 외부에서 호출하는 next()나 .send() 메서드가 중간 단계를 거치지 않고 바로 하위 제너레이터로 전달된다.
이러한 직접적인 연결 방식 덕분에 코드가 매우 간결해지고 성능도 향상되었다. 복잡한 비동기 로직을 여러 개의 작은 코루틴으로 나누어 구현할 수 있게 되었으며, 각 코루틴은 독립적으로 테스트하고 재사용할 수 있게 되었다. yield from은 후에 async/await 문법의 기반이 되어 현대 파이썬의 비동기 프로그래밍 발전에 중요한 역할을 했다.
예외 처리와 반환값 전달도 자동으로 처리되어 개발자가 신경 써야 할 부분이 크게 줄어들었다. 이로써 복잡한 비동기 프로그램을 작은 단위로 분해하여 구조적으로 설계할 수 있는 기반이 마련되었다.
예시 코드: 메인 코루틴이 하위 코루틴을 호출
def sub_generator():
"""하위 제너레이터"""
print("하위: 시작")
x = yield "하위: 준비 완료"
print(f"하위: {x} 받음")
yield x * 10
def main_generator():
"""메인 제너레이터"""
print("메인: 시작")
# yield from을 통해 sub_generator와 직접 통신
result = yield from sub_generator()
print(f"메인: 하위 제너레이터로부터 결과 {result} 받음")
# 사용법
main_gen = main_generator()
# 메인 제너레이터를 통해 하위 제너레이터와 상호작용
print(f"외부: {next(main_gen)}") # 메인 시작, 하위 시작, "하위: 준비 완료" 반환
print(f"외부: {main_gen.send(5)}") # 하위에 5 전달, 하위가 50 반환
Python 3.5: 네이티브 코루틴 (async/await)
Python 3.5에서 도입된 async/await 문법은 파이썬 비동기 프로그래밍의 역사에서 가장 중요한 전환점이었다. 이전까지 yield from을 사용한 코루틴은 일반 제너레이터와 문법적으로 구분되지 않아 코드를 읽는 사람이 해당 함수가 데이터 생성용 제너레이터인지 비동기 처리용 코루틴인지 파악하기 어려웠다. 또한 복잡한 yield from 체인은 초보자에게 이해하기 어려운 문법이었다.
async def 키워드는 비동기 처리를 위한 네이티브 코루틴을 정의하는 전용 문법으로, 해당 함수가 비동기 작업을 수행한다는 것을 명확히 표시한다. 이를 통해 개발자는 함수 정의만 보고도 그 함수의 목적과 사용법을 즉시 알 수 있게 되었다. async def로 정의된 함수는 호출할 때 코루틴 객체를 반환하며, 이벤트 루프를 통해 실행되어야 한다.
await 키워드는 다른 코루틴이나 비동기 작업의 완료를 기다리는 지점을 명확히 표시한다. await를 만나면 현재 코루틴은 실행을 일시 중지하고 이벤트 루프에 제어권을 넘겨준다. 이벤트 루프는 이 시간을 활용해 다른 준비된 코루틴들을 실행하거나 I/O 작업의 완료를 확인한다. 대기 중인 작업이 완료되면 이벤트 루프는 해당 코루틴을 다시 깨워 실행을 재개한다.
이러한 문법적 분리로 인해 제너레이터는 데이터 생성과 반복 처리에 집중하고, 코루틴은 비동기 프로그래밍에 특화될 수 있게 되었다. async/await 문법은 직관적이고 읽기 쉬워서 비동기 프로그래밍의 진입 장벽을 크게 낮췄으며, 현재는 파이썬 비동기 프로그래밍의 표준으로 완전히 자리 잡았다. 이로써 파이썬은 네트워크 프로그래밍, 웹 개발, 실시간 애플리케이션 등 다양한 분야에서 효율적인 비동기 처리가 가능한 언어로 발전했다.
예시 코드: 비동기 작업을 동시에 처리
import asyncio
import time
async def async_task(name, delay):
"""비동기 작업을 시뮬레이션하는 네이티브 코루틴"""
print(f"'{name}' 작업 시작...")
await asyncio.sleep(delay) # I/O 대기를 시뮬레이션하며 제어권 양보
print(f"'{name}' 작업 완료!")
return name
async def main():
"""여러 비동기 작업을 동시에 실행"""
start_time = time.time()
# asyncio.gather로 여러 코루틴을 동시에 실행 예약
results = await asyncio.gather(
async_task("작업 A", 2),
async_task("작업 B", 1)
)
end_time = time.time()
print(f"결과: {results}, 총 소요 시간: {end_time - start_time:.2f}초")
# asyncio.run()이 이벤트 루프를 실행하여 코루틴 작업을 관리
asyncio.run(main())
이처럼 파이썬 제너레이터는 단순 이터레이터에서 시작하여, 양방향 통신이 가능한 코루틴으로, 그리고 최종적으로는 현대적인 비동기 프로그래밍의 기반이 되는 async/await 문법으로 발전해왔다.
코루틴 (Coroutine)
코루틴은 제너레이터에서 발전한 개념으로, 단순히 값을 생산하는 것을 넘어 외부와 양방향 통신이 가능한 함수이다. 초기 코루틴은 제너레이터의 yield와 .send() 메서드를 활용하여 구현되었으며, 외부에서 값을 받아 처리하고 다시 값을 반환하는 상호작용이 가능했다. 현대 파이썬의 코루틴은 async def와 await 키워드를 사용하는 네이티브 코루틴으로 발전하여 비동기 프로그래밍을 위해 특별히 설계되었다. 이를 통해 I/O작업처럼 대기 시간이 긴 작업을 효율적으로 처리하며, 하나의 스레드에서 여러 작업을 동시에 처리하는 동시성을 구현한다.
초기 코루틴 (yield/send()활용)
초기 코루틴은 제너레이터의 yield 키워드와 .send() 메서드를 활용하여 구현되었으며, 외부에서 값을 받아 처리하고 다시 값을 반환하는 상호작용이 가능했습니다. 코루틴에서 yield는 표현식으로 사용되어 received = yield 형태로 값을 받을 수 있다.
예시 코드: 값을 받아 인사하는 코루틴
def greeting_coroutine():
print("코루틴: 누구신지 기다리는 중...")
while True:
# .send()로 보낸 값이 name 변수에 저장됨
name = yield
print(f"코루틴: 안녕하세요, {name}님!")
# 사용법
greeter = greeting_coroutine()
next(greeter) # 코루틴을 첫 yield 지점까지 실행 (프라이밍)
greeter.send("홍길동")
greeter.send("김철수")
# 출력:
# 코루틴: 누구신지 기다리는 중...
# 코루틴: 안녕하세요, 홍길동님!
# 코루틴: 안녕하세요, 김철수님!
현대 코루틴 (async/await활용)
현대 파이썬의 코루틴은 async def와 await키워드를 사용하는 네이티브 코루틴으로 발전했다. 이는 비동기 프로그래밍을 위해 특별히 설계된 문법으로, I/O 작업처럼 대기 시간이 긴 작업을 효율적으로 처리할 수 있다. await 키워드는 다른 코루틴의 완료를 기다리면서 이벤트 루프에 제어권을 넘겨주어, 하나의 스레드에서 여러 작업을 동시에 처리하는 동시성을 구현한다.
예시 코드: 여러 작업을 동시에 처리하는 비동기 프로그램
import asyncio
async def make_coffee():
print("커피를 만들기 시작합니다...")
await asyncio.sleep(2) # 2초 동안 물을 끓인다고 가정 (I/O 대기)
print("☕️ 커피 완성!")
async def make_toast():
print("토스트를 굽기 시작합니다...")
await asyncio.sleep(3) # 3초 동안 빵을 굽는다고 가정 (I/O 대기)
print("🍞 토스트 완성!")
async def main():
# asyncio.gather로 여러 코루틴을 동시에 실행
await asyncio.gather(make_coffee(), make_toast())
print("\n현대 코루틴으로 아침 식사 준비:")
asyncio.run(main())
코루틴의 예외 처리는 기본적으로 동기 코드의 try…except 구문과 동일하지만, 여러 코루틴을 동시에 다룰 때 특별한 처리 방식이 필요하다.
파이썬 반복과 비동기 처리의 진화 과정
파이썬의 이터레이터, 제너레이터, 코루틴으로 이어지는 발전 과정은 언어가 어떻게 개발자의 필요에 따라 진화해왔는지를 보여주는 훌륭한 사례다. 이 과정은 단순한 기능 추가가 아니라 각 단계에서 발견된 문제점을 해결하고 새로운 가능성을 열어가는 체계적인 발전이었다.
문제 해결 중심의 발전
초기 이터레이터는 반복 가능한 객체를 만드는 표준 방법을 제공했지만, 클래스 정의와 특수 메서드 구현이 필요해 코드가 복잡하고 작성하기 어려웠다. 제너레이터는 yield 키워드 하나로 이 모든 복잡성을 해결하며 코드를 대폭 간소화했다. 하지만 제너레이터는 값을 밖으로만 내보낼 수 있는 단방향 통신의 한계가 있었다.
이 한계는 .send() 메서드의 추가로 해결되어 양방향 통신이 가능한 초기 코루틴이 탄생했다. 그러나 yield를 이용한 코루틴은 문법이 복잡하고 일반 제너레이터와 구분이 어려운 새로운 문제를 만들었다. 최종적으로 async/await 문법이 도입되어 비동기 코드의 의도를 명확히 표현하고 가독성을 크게 향상시켰다.
기능의 점진적 확장
각 발전 단계는 이전 기능을 완전히 대체하는 것이 아니라 새로운 영역으로 확장하는 방식으로 진행되었다. 이터레이터는 여전히 반복 가능한 객체의 기본 프로토콜로 사용되고, 제너레이터는 메모리 효율적인 데이터 생성에 최적화되어 있으며, 코루틴은 비동기 프로그래밍의 핵심 도구가 되었다. 이러한 역할 분담을 통해 각 개념이 자신의 영역에서 최적의 성능을 발휘할 수 있게 되었다.
특히 흥미로운 점은 각 단계의 핵심 아이디어가 다음 단계의 기반이 되었다는 것이다. 이터레이터의 ‘실행 중지와 재개’ 개념이 제너레이터의 핵심이 되었고, 제너레이터의 ‘상태 보존’ 능력이 코루틴의 양방향 통신을 가능하게 했으며, 코루틴의 ‘협력적 멀티태스킹’ 아이디어가 현대 비동기 프로그래밍의 토대가 되었다.
현대 파이썬에서의 의미
이러한 발전 과정의 결과로 현재 파이썬은 동기 처리부터 고성능 비동기 처리까지 모든 상황에 적합한 도구를 제공하는 언어가 되었다. 간단한 데이터 반복에는 제너레이터를, 복잡한 웹 서버나 실시간 애플리케이션에는 코루틴을 사용할 수 있어 개발자가 상황에 맞는 최적의 도구를 선택할 수 있다. 이는 파이썬이 교육용 언어에서 시작하여 현재는 웹 개발, 데이터 사이언스, 인공지능 등 다양한 분야에서 널리 사용되는 범용 언어로 성장할 수 있었던 중요한 요인 중 하나다.
관계 예시 코드: 제너레이터 파이프라인
제너레이터가 어떻게 이터레이터의 역할을 하며 데이터 파이프라인을 구축하는지 보여주는 예시다.
# 1단계: 파일 읽기 (생산자)
def read_log(filename):
with open(filename, 'r') as f:
for line in f:
yield line.strip()
# 2단계: 에러 필터링 (중간 처리자)
def filter_errors(lines_iterator):
for line in lines_iterator:
if "ERROR" in line:
yield line
# 3단계: 데이터 파싱 (최종 처리자)
def parse_log_line(error_lines_iterator):
for error_line in error_lines_iterator:
parts = error_line.split(':', 2)
if len(parts) == 3:
yield {"level": parts[0], "code": parts[1], "message": parts[2]}
# 파이프라인 연결 및 실행
# 각 단계는 마지막 for 루프가 값을 요청하기 전까지 실행되지 않음 (지연 연산)
log_lines = read_log("app.log")
error_lines = filter_errors(log_lines)
parsed_data = parse_log_line(error_lines)
# 최종 소비자가 데이터를 요청하면서 파이프라인 전체가 작동 시작
for data in parsed_data:
print(data)
이처럼 이터레이터는 반복의 기초를 제공하고, 제너레이터는 효율적인 데이터 생산을 담당하며, 코루틴은 현대적인 비동기 프로그래밍을 가능하게 하는 역할을 각각 수행합니다. 이들은 서로 독립적이면서도 밀접하게 연관된 개념으로, 파이썬 프로그래밍의 핵심 도구들이 되었다.
파이썬의 이터레이터, 제너레이터, 코루틴의 여정을 살펴보면서 우리는 언어가 어떻게 개발자의 실제 요구사항에 응답하며 진화해왔는지를 확인할 수 있었다. 복잡한 클래스 구현에서 시작하여 간결한 yield 키워드로, 그리고 마침내 직관적인 async/await 문법에 이르기까지의 발전 과정은 단순한 기능 추가가 아닌 근본적인 패러다임의 변화였다.
이 세 가지 개념은 각각 고유한 역할을 수행하면서도 서로 밀접하게 연결되어 있습니다. 이터레이터는 반복의 기본 프로토콜을 제공하고, 제너레이터는 메모리 효율적인 데이터 생성을 담당하며, 코루틴은 현대적인 비동기 프로그래밍의 핵심이 되었다. 이러한 도구들 덕분에 파이썬은 간단한 스크립트부터 고성능 웹 애플리케이션, 실시간 데이터 처리 시스템까지 다양한 영역에서 효율적인 해결책을 제공할 수 있게 되었다.
특히 주목할 점은 이들 모두가 지연 연산(lazy evaluation)라는 공통된 철학을 바탕으로 하고 있다는 것입니다. 필요할 때만 값을 생성하고, 요청받을 때만 작업을 수행하는 이 접근 방식은 메모리 효율성과 성능 최적화의 핵심이 된다.
다음 글에서는 이러한 지연 연산(lazy evaluation)의 개념과 원리, 그리고 파이썬에서 이를 활용하는 다양한 방법들에 대해 더 자세히 살펴보겠습니다. 게으른 평가가 어떻게 대용량 데이터 처리를 가능하게 하고, 무한 시퀀스를 다루며, 메모리 사용량을 최적화하는지 구체적인 예시와 함께 알아보도록 하겠다.