# 기본 제너레이터 함수
def number_generator():
    yield 1
    yield 2
    yield 3

# 사용
gen = number_generator()
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3
# print(next(gen))  # StopIteration 예외 발생

# for 루프로 사용
for num in number_generator():
    print(num)  # 1, 2, 3 순서대로 출력

# 일반 함수와 비교
def get_numbers_list():
    return [1, 2, 3]  # 모든 값을 한꺼번에 메모리에 생성

def get_numbers_generator():
    yield 1
    yield 2
    yield 3  # 값을 필요할 때 하나씩 생성

def countdown(n):
    print("카운트다운 시작!")
    while n > 0:
        print(f"{n} 반환 준비 중...")
        yield n
        print(f"{n} 반환 완료, 계속 실행")
        n -= 1
    print("카운트다운 종료!")

# 사용
counter = countdown(3)
print(next(counter))  # 카운트다운 시작! / 3 반환 준비 중... / 3
print(next(counter))  # 3 반환 완료, 계속 실행 / 2 반환 준비 중... / 2
print(next(counter))  # 2 반환 완료, 계속 실행 / 1 반환 준비 중... / 1
# next(counter)       # 1 반환 완료, 계속 실행 / 카운트다운 종료! / StopIteration

# 피보나치 수열 생성
def fibonacci(limit):
    a, b = 0, 1
    count = 0
    while count < limit:
        yield a
        a, b = b, a + b
        count += 1

for fib in fibonacci(10):
    print(fib, end=' ')  # 0 1 1 2 3 5 8 13 21 34

# 제너레이터 표현식
squares = (x**2 for x in range(10))
print(next(squares))  # 0
print(next(squares))  # 1

# 메모리 사용 비교
import sys
list_comp = [x**2 for x in range(1000000)]  # 메모리 많이 사용
gen_exp = (x**2 for x in range(1000000))    # 메모리 적게 사용

print(f"리스트 크기: {sys.getsizeof(list_comp)} 바이트")
print(f"제너레이터 크기: {sys.getsizeof(gen_exp)} 바이트")

# 필터링과 함께 사용
even_squares = (x**2 for x in range(10) if x % 2 == 0)
print(list(even_squares))  # [0, 4, 16, 36, 64]

# 중첩 제너레이터 표현식
matrix = ((i*j for j in range(3)) for i in range(3))
for row in matrix:
    print(list(row))  # [0, 0, 0], [0, 1, 2], [0, 2, 4]

def counter():
    i = 0
    while True:
        val = (yield i)  # yield 표현식
        if val is not None:
            i = val
        else:
            i += 1

c = counter()
print(next(c))      # 0 (첫 번째 yield까지 실행)
print(c.send(10))   # 10 (값을 보내고 다음 yield까지 실행)
print(next(c))      # 11
print(next(c))      # 12

# throw() 메서드로 예외 전달
def exception_handler():
    try:
        while True:
            try:
                x = yield
            except ValueError:
                print("ValueError 처리됨")
            else:
                print(f"값 받음: {x}")
    finally:
        print("제너레이터 종료")

g = exception_handler()
next(g)  # 첫 번째 yield까지 진행
g.send(1)  # "값 받음: 1"
g.throw(ValueError)  # "ValueError 처리됨"
g.close()  # "제너레이터 종료"

# 코루틴으로 사용
def grep(pattern):
    print(f"패턴 '{pattern}' 검색 중...")
    while True:
        line = (yield)
        if pattern in line:
            print(line)

search = grep("python")
next(search)  # 첫 번째 yield까지 실행
search.send("hello world")  # 아무것도 출력 안 함
search.send("python is awesome")  # "python is awesome" 출력
search.close()  # 제너레이터 종료

def numbers():
    for i in range(1, 4):
        yield i

def squares(nums):
    for n in nums:
        yield n**2

def add_one(nums):
    for n in nums:
        yield n + 1

# 체이닝
chain = add_one(squares(numbers()))
print(list(chain))  # [2, 5, 10]

# yield from을 사용한 체이닝
def numbers_gen():
    yield from range(1, 4)

def squares_gen(nums):
    for n in nums:
        yield n**2

# 제너레이터로 데이터 파이프라인 구성
def process_file(filename):
    with open(filename, 'r') as f:
        yield from f  # 파일의 각 라인을 생성

def grep_filter(lines, pattern):
    for line in lines:
        if pattern in line:
            yield line

def replace_text(lines, old, new):
    for line in lines:
        yield line.replace(old, new)

# 파이프라인 구성 예시
# pipeline = replace_text(grep_filter(process_file('log.txt'), 'ERROR'), 'ERROR', 'CRITICAL')

# 무한 시퀀스 생성
def infinite_counter(start=0):
    while True:
        yield start
        start += 1

# 슬라이싱을 위한 itertools 사용
import itertools
counter = infinite_counter()
first_10 = list(itertools.islice(counter, 10))
print(first_10)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 여러 시퀀스 병합
def merge_sequences(*sequences):
    """여러 시퀀스를 번갈아가며 병합"""
    iterators = [iter(seq) for seq in sequences]
    active = len(iterators)
    
    while active:
        active = 0
        for it in iterators:
            try:
                yield next(it)
                active += 1
            except StopIteration:
                pass

# 효율적인 데이터 청킹
def chunk_data(iterable, size):
    """이터러블을 지정된 크기의 청크로 분할"""
    iterator = iter(iterable)
    while True:
        chunk = list(itertools.islice(iterator, size))
        if not chunk:
            break
        yield chunk

# 백트래킹 알고리즘 구현
def permutations(items):
    """재귀적 제너레이터를 사용한 순열 생성"""
    if len(items) <= 1:
        yield items
    else:
        for i in range(len(items)):
            for perm in permutations(items[:i] + items[i+1:]):
                yield [items[i]] + perm

for p in permutations([1, 2, 3]):
    print(p)  # [1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]

import time
import sys

# 메모리 사용량 측정 예제
def memory_usage_comparison():
    # 큰 리스트 vs 제너레이터
    start = time.time()
    big_list = [i for i in range(10000000)]
    list_memory = sys.getsizeof(big_list)
    list_time = time.time() - start
    
    start = time.time()
    big_gen = (i for i in range(10000000))
    gen_memory = sys.getsizeof(big_gen)
    gen_time = time.time() - start
    
    print(f"리스트 메모리: {list_memory:,} 바이트, 생성 시간: {list_time:.4f}초")
    print(f"제너레이터 메모리: {gen_memory:,} 바이트, 생성 시간: {gen_time:.4f}초")
    print(f"메모리 절약: {list_memory/gen_memory:.0f}배")

# 대용량 파일 처리 최적화
def process_large_file(filename, process_line):
    """대용량 파일을 메모리 효율적으로 처리"""
    with open(filename, 'r') as file:
        for line in file:  # 파일 이터레이터 활용
            yield process_line(line.strip())

# 지연 계산으로 성능 향상
def lazy_evaluation_example(n):
    """필요한 경우에만 계산 수행"""
    print("제너레이터 생성 시작")
    
    def expensive_calculation(x):
        print(f"{x}에 대한 비용이 많이 드는 계산 수행 중...")
        time.sleep(0.1)  # 비용이 많이 드는 작업 시뮬레이션
        return x**2
    
    # 모든 계산을 즉시 수행하지 않음
    for i in range(n):
        yield expensive_calculation(i)

# 사용 예:
# for result in lazy_evaluation_example(100):
#     if result > 50:  # 조건에 맞는 첫 번째 결과만 필요
#         print(f"결과 찾음: {result}")
#         break