36. 제너레이터(generator)와 지연 반복(lazy iteration)

# 100만 개의 제곱을 담은 리스트 만들기
def get_squares_list(n):
    """0부터 n-1까지의 제곱 리스트를 반환합니다."""
    squares = []
    for i in range(n):
        squares.append(i * i)
    return squares
 
# 이것은 메모리에 1,000,000개의 숫자를 담은 리스트를 생성합니다
numbers = get_squares_list(1_000_000)
print(f"First five squares: {numbers[:5]}")  # Output: First five squares: [0, 1, 4, 9, 16]

# 제곱을 생성하는 제너레이터 만들기
def get_squares_generator(n):
    """0부터 n-1까지의 제곱을 한 번에 하나씩 생성합니다."""
    for i in range(n):
        yield i * i  # yield는 함수를 일시 중지하고 값을 반환합니다
 
# 이것은 리스트가 아니라 제너레이터 객체를 생성합니다
squares_gen = get_squares_generator(1_000_000)
print(squares_gen)  # Output: <generator object get_squares_generator at 0x...>
 
# 값을 한 번에 하나씩 가져오기
print(next(squares_gen))  # Output: 0
print(next(squares_gen))  # Output: 1
print(next(squares_gen))  # Output: 4

import sys
 
# 리스트 접근: 모든 값을 저장합니다
def squares_list(n):
    return [i * i for i in range(n)]
 
# 제너레이터 접근: 필요할 때 값을 계산합니다
def squares_generator(n):
    for i in range(n):
        yield i * i
 
# 100,000개 숫자에 대한 메모리 사용량 비교
list_result = squares_list(100_000)
gen_result = squares_generator(100_000)
 
print(f"List size in memory: {sys.getsizeof(list_result):,} bytes")
# Output: List size in memory: 800,984 bytes (실제 크기는 다를 수 있음)
 
print(f"Generator size in memory: {sys.getsizeof(gen_result)} bytes")
# Output: Generator size in memory: 200 bytes (실제 크기는 다를 수 있음)

def read_large_file(filename):
    """파일에서 한 번에 한 줄씩 생성합니다."""
    with open(filename, 'r') as file:
        for line in file:
            yield line.strip()
 
# 거대한 로그 파일을 메모리에 전부 올리지 않고 처리하기
for line in read_large_file('huge_log.txt'):
    if 'ERROR' in line:
        print(line)

def fibonacci():
    """피보나치 수를 무한히 생성합니다."""
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
 
# 피보나치 수를 영원히 생성하기(또는 더 이상 요청하지 않을 때까지)
fib = fibonacci()
print([next(fib) for _ in range(10)])
# Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

def countdown(n):
    """n부터 1까지 카운트다운을 생성합니다."""
    while n > 0:
        yield n
        n -= 1
 
# 제너레이터는 for 반복문에서 바로 동작합니다
for num in countdown(5):
    print(num)
# Output:
# 5
# 4
# 3
# 2
# 1

def simple_generator():
    """yield가 실행을 어떻게 일시 중지하는지 보여 줍니다."""
    print("Starting generator")
    yield 1
    print("Resuming after first yield")
    yield 2
    print("Resuming after second yield")
    yield 3
    print("Generator finished")
 
gen = simple_generator()
print("Created generator")
# Output:
# Created generator
 
print(f"First value: {next(gen)}")
# Output:
# Starting generator
# First value: 1
 
print(f"Second value: {next(gen)}")
# Output:
# Resuming after first yield
# Second value: 2
 
print(f"Third value: {next(gen)}")
# Output:
# Resuming after second yield
# Third value: 3
 
try:
    next(gen)
except StopIteration:
    print("Generator exhausted - no more values")
# Output:
# Generator finished
# Generator exhausted - no more values

def counter(start=0):
    """start부터 시작하는 순차 숫자 생성."""
    current = start
    while True:
        yield current
        current += 1
 
# Generator는 yield 사이에 'current'를 기억합니다
count = counter(10)
print(next(count))  # Output: 10
print(next(count))  # Output: 11
print(next(count))  # Output: 12
 
# 각 generator는 독립적인 상태를 가집니다
count1 = counter(0)
count2 = counter(100)
print(next(count1))  # Output: 0
print(next(count2))  # Output: 100
print(next(count1))  # Output: 1
print(next(count2))  # Output: 101

def even_numbers(start, end):
    """주어진 범위에서 짝수를 생성합니다."""
    current = start if start % 2 == 0 else start + 1
    while current <= end:
        yield current
        current += 2
 
# 제너레이터 사용하기
evens = even_numbers(1, 20)
print(list(evens))
# Output: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

def process_data(data):
    """상태 메시지와 함께 처리된 데이터를 생성합니다."""
    yield "Starting processing..."
    
    cleaned = [item.strip().lower() for item in data]
    yield f"Cleaned {len(cleaned)} items"
    
    unique = list(set(cleaned))
    yield f"Found {len(unique)} unique items"
    
    for item in sorted(unique):
        yield item
 
# 데이터 처리하기
data = ["  Apple  ", "Banana", "apple", "Cherry", "BANANA"]
processor = process_data(data)
 
for result in processor:
    print(result)
# Output:
# Starting processing...
# Cleaned 5 items
# Found 3 unique items
# apple
# banana
# cherry

# Generator 함수
def squares_function(n):
    for x in range(n):
        yield x * x
 
# Generator expression - 같은 일을 합니다
squares_expression = (x * x for x in range(10))
 
# 둘 다 generator 객체를 생성합니다
gen1 = squares_function(10)
gen2 = squares_expression
 
print(type(gen1))  # Output: <class 'generator'>
print(type(gen2))  # Output: <class 'generator'>
 
# 둘 다 같은 값을 생성합니다
print(list(squares_function(10)))  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
print(list(squares_expression))  # Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 리스트 컴프리헨션 - 전체 리스트를 메모리에 생성합니다
squares_list = [x * x for x in range(10)]
print(squares_list)
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 
# 제너레이터 표현식 - 제너레이터 객체를 생성합니다
squares_gen = (x * x for x in range(10))
print(squares_gen)
# Output: <generator object <genexpr> at 0x...>
 
# 값을 보기 위해 리스트로 변환하기
print(list(squares_gen))
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

import sys
 
# 작은 시퀀스 - 차이가 거의 없습니다
small_list = [x for x in range(100)]
small_gen = (x for x in range(100))
 
print(f"Small list: {sys.getsizeof(small_list)} bytes")
# Output: Small list: 920 bytes (실제 크기는 다를 수 있음)
print(f"Small generator: {sys.getsizeof(small_gen)} bytes")
# Output: Small generator: 192 bytes (실제 크기는 다를 수 있음)
 
# 큰 시퀀스 - 차이가 큽니다
large_list = [x for x in range(1_000_000)]
large_gen = (x for x in range(1_000_000))
 
print(f"Large list: {sys.getsizeof(large_list):,} bytes")
# Output: Large list: 8,448,728 bytes (실제 크기는 다를 수 있음)
print(f"Large generator: {sys.getsizeof(large_gen)} bytes")
# Output: Large generator: 192 bytes (실제 크기는 다를 수 있음)

# 리스트를 만들지 않고 제곱의 합 계산하기
total = sum(x * x for x in range(100))  # Note: no extra parentheses needed
print(total)
# Output: 328350
 
# 변환된 값의 최댓값 찾기
numbers = [1, 2, 3, 4, 5]
max_square = max(x * x for x in numbers)
print(max_square)
# Output: 25
 
# 어떤 값이라도 조건을 만족하는지 확인하기
data = [10, 15, 20, 25, 30]
has_large = any(x > 100 for x in data)
print(has_large)
# Output: False

# 짝수만 필터링하기
numbers = range(20)
evens = (x for x in numbers if x % 2 == 0)
print(list(evens))
# Output: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
 
# 변환과 필터링
words = ["hello", "world", "python", "programming"]
long_upper = (word.upper() for word in words if len(word) > 5)
print(list(long_upper))
# Output: ['PYTHON', 'PROGRAMMING']

# 제너레이터 표현식에는 너무 복잡합니다
def process_log_lines(filename):
    """복잡한 로직으로 로그 파일을 처리합니다."""
    with open(filename, 'r') as file:
        for line in file:
            line = line.strip()
            if not line or line.startswith('#'):
                continue  # 빈 줄과 주석을 건너뜁니다
            
            parts = line.split('|')
            if len(parts) >= 3:
                timestamp, level, message = parts[0], parts[1], parts[2]
                if level in ('ERROR', 'CRITICAL'):
                    yield {
                        'timestamp': timestamp,
                        'level': level,
                        'message': message
                    }

# 제너레이터 표현식은 반복 사이에서 상태를 유지할 수 없습니다
def running_total(numbers):
    """숫자의 누적 합을 생성합니다."""
    total = 0
    for num in numbers:
        total += num
        yield total
 
numbers = [1, 2, 3, 4, 5]
print(list(running_total(numbers)))
# Output: [1, 3, 6, 10, 15]

# 제너레이터 표현식은 예외를 처리할 수 없습니다
def safe_divide(numbers, divisor):
    """에러를 처리하면서 나눗셈 결과를 생성합니다."""
    for num in numbers:
        try:
            yield num / divisor
        except ZeroDivisionError:
            yield float('inf')

# 대용량 파일에는 이렇게 하지 마세요
def count_errors_bad(filename):
    """전체 파일을 메모리에 로드 - 대용량 파일에서 충돌."""
    with open(filename, 'r') as file:
        lines = file.readlines()  # 전체 파일을 메모리에 로드
    
    error_count = 0
    for line in lines:
        if 'ERROR' in line:
            error_count += 1
    
    return error_count
 
# 파일이 10 GB라면, 10 GB를 메모리에 로드하려고 시도합니다!

def read_log_lines(filename):
    """로그 파일에서 한 번에 한 줄씩 생성."""
    with open(filename, 'r') as file:
        for line in file:
            yield line.strip()
 
def count_errors_good(filename):
    """전체 파일을 메모리에 로드하지 않고 에러 개수 세기."""
    error_count = 0
    for line in read_log_lines(filename):
        if 'ERROR' in line:
            error_count += 1
    
    return error_count
 
# 기가바이트 크기의 로그 파일에서도 효율적으로 작동
# 한 번에 한 줄만 메모리에 유지하기 때문
count = count_errors_good('huge_application.log')
print(f"{count}개의 에러 발견")

def user_input_stream():
    """사용자가 'quit'을 입력할 때까지 사용자 입력을 생성합니다."""
    while True:
        user_input = input("Enter a number (or 'quit'): ")
        if user_input.lower() == 'quit':
            break
        try:
            yield int(user_input)
        except ValueError:
            print("Invalid number, try again")
 
# 들어오는 즉시 사용자 입력을 처리하기
total = 0
count = 0
for number in user_input_stream():
    total += number
    count += 1
    print(f"Running average: {total / count:.2f}")

# 여러 단계를 거쳐 숫자 변환
def generate_numbers(n):
    """1부터 n까지 숫자 생성."""
    for i in range(1, n + 1):
        yield i
 
def square_numbers(numbers):
    """입력 숫자들의 제곱 생성."""
    for num in numbers:
        yield num * num
 
def keep_even(numbers):
    """짝수만 생성."""
    for num in numbers:
        if num % 2 == 0:
            yield num
 
# Generator 체인 - 중간 리스트 생성 안 됨
numbers = generate_numbers(10)
squared = square_numbers(numbers)
even_squares = keep_even(squared)
 
# 결과 처리
print(list(even_squares))
# Output: [4, 16, 36, 64, 100]

# 제너레이터 없는 접근 - 중간 리스트 생성
numbers = list(range(1, 11))           # [1, 2, 3, ..., 10]
squared = [n * n for n in numbers]     # [1, 4, 9, ..., 100]
even_squares = [n for n in squared if n % 2 == 0]  # [4, 16, 36, 64, 100]
 
# 제너레이터 사용 - 중간 리스트 없음
numbers = (i for i in range(1, 11))
squared = (n * n for n in numbers)
even_squares = (n for n in squared if n % 2 == 0)
print(list(even_squares))
# Output: [4, 16, 36, 64, 100]

# 리스트 - 여러 번 순회 가능
numbers = [1, 2, 3, 4, 5]
print(sum(numbers))      # Output: 15
print(max(numbers))      # Output: 5 (문제없음)
 
# Generator - 한 번만 순회 가능
numbers_gen = (x for x in range(1, 6))
print(sum(numbers_gen))  # Output: 15
print(max(numbers_gen))  # Output: ValueError: max() iterable argument is empty

# 인덱스로 요소에 접근해야 한다면 - 리스트 사용
students = ['Alice', 'Bob', 'Charlie', 'Diana']
print(students[2])  # Output: Charlie
 
# 제너레이터는 인덱싱을 지원하지 않습니다
students_gen = (name for name in students)
# students_gen[2]  # ERROR: 'generator' object is not subscriptable

# 길이를 알아야 한다면 - 리스트 사용
data = [1, 2, 3, 4, 5]
print(f"Processing {len(data)} items")
 
# 제너레이터에는 길이가 없습니다
data_gen = (x for x in data)
# len(data_gen)  # ERROR: object of type 'generator' has no len()

# 작은 데이터셋에서는 리스트로도 충분하고 더 편리합니다
small_data = [x * 2 for x in range(10)]
 
# 여기서는 제너레이터의 메모리 절약이 그다지 크지 않고
# 리스트가 더 유연합니다

# 제너레이터를 리스트로
numbers_gen = (x * 2 for x in range(5))
numbers_list = list(numbers_gen)
print(numbers_list)
# Output: [0, 2, 4, 6, 8]
 
# 리스트를 제너레이터로(제너레이터 표현식 사용)
numbers_list = [1, 2, 3, 4, 5]
numbers_gen = (x for x in numbers_list)

# 메모리 효율성을 위해 generator로 시작
numbers = (x for x in range(1, 1001))
filtered = (x for x in numbers if x % 7 == 0)
 
# 여러 번 순회가 필요할 때 리스트로 변환
multiples_of_seven = list(filtered)
 
# 이제 리스트 기능 사용 가능
print(f"개수: {len(multiples_of_seven)}")
# Output: 개수: 142
 
print(f"첫 번째: {multiples_of_seven[0]}")
# Output: 첫 번째: 7
 
print(f"마지막: {multiples_of_seven[-1]}")
# Output: 마지막: 994
 
# 여러 번 순회 가능
total = sum(multiples_of_seven)
average = total / len(multiples_of_seven)
print(f"평균: {average:.1f}")
# Output: 평균: 500.5