from typing import List, Dict, Callable, Any
import time
from functools import lru_cache
import timeit
import dis

def measure_time(func: Callable, *args, **kwargs) -> float:
    """함수 실행 시간 측정
    
    Args:
        func: 측정할 함수
        args: 함수 인자
        kwargs: 함수 키워드 인자
        
    Returns:
        float: 실행 시간(초)
    """
    start_time = time.time()
    result = func(*args, **kwargs)
    end_time = time.time()
    print(f"{func.__name__} 실행 시간: {end_time - start_time:.6f}초")
    return end_time - start_time

# 1. 리스트 컴프리헨션 사용
def create_list_loop(n: int) -> List[int]:
    """루프를 사용한 리스트 생성 (비효율적)"""
    numbers = []
    for i in range(n):
        if i % 2 == 0:
            numbers.append(i)
    return numbers

def create_list_comprehension(n: int) -> List[int]:
    """리스트 컴프리헨션 사용 (최적화)"""
    return [i for i in range(n) if i % 2 == 0]

# 2. 제너레이터 사용 (메모리 효율성)
def number_list(n: int) -> List[int]:
    """리스트 반환 (메모리 집약적)"""
    return [i for i in range(n)]

def number_generator(n: int):
    """제너레이터 반환 (메모리 효율적)"""
    for i in range(n):
        yield i

# 3. 캐싱 사용
def fibonacci_naive(n: int) -> int:
    """재귀적 피보나치 (비효율적)"""
    if n < 2:
        return n
    return fibonacci_naive(n-1) + fibonacci_naive(n-2)

@lru_cache(maxsize=128)
def fibonacci_cached(n: int) -> int:
    """캐싱된 피보나치 (최적화)"""
    if n < 2:
        return n
    return fibonacci_cached(n-1) + fibonacci_cached(n-2)

# 4. 함수 호출 최소화
def process_items_inefficient(items: List[int]) -> List[int]:
    """함수 호출이 많은 비효율적 방식"""
    result = []
    for item in items:
        result.append(item * 2)
    return result

def process_items_efficient(items: List[int]) -> List[int]:
    """함수 호출을 최소화한 효율적 방식"""
    append = result.append  # 지역 변수에 메소드 바인딩
    result = []
    for item in items:
        append(item * 2)
    return result

# 5. 변수 지역화
x = 0  # 전역 변수
def increment_global():
    """전역 변수 사용 (느림)"""
    global x
    for i in range(1000000):
        x += 1
    return x

def increment_local():
    """지역 변수 사용 (빠름)"""
    x = 0
    for i in range(1000000):
        x += 1
    return x

# 효율성 비교 예시
if __name__ == "__main__":
    # 리스트 컴프리헨션 vs 루프
    n = 1000000
    measure_time(create_list_loop, n)
    measure_time(create_list_comprehension, n)
    
    # 일반 리스트 vs 제너레이터
    print("\n메모리 사용 비교:")
    print("리스트: 모든 항목을 메모리에 저장")
    numbers_list = number_list(1000000)
    print(f"제너레이터: 값을 필요할 때만 생성")
    numbers_gen = number_generator(1000000)
    
    # 캐싱 효과
    print("\n캐싱 효과:")
    n = 35
    measure_time(fibonacci_naive, n)
    measure_time(fibonacci_cached, n)
    # 두 번째 호출은 캐시에서 바로 가져옴
    measure_time(fibonacci_cached, n)
    
    # 바이트코드 분석
    print("\n바이트코드 비교:")
    dis.dis(lambda: [i for i in range(10)])
    print("---")
    dis.dis(lambda: list(range(10)))

from collections import defaultdict, Counter, deque, namedtuple
import array
import time
import sys
import numpy as np

def measure_operation(setup_code: str, operation_code: str, repeat: int = 3) -> float:
    """작업 시간 측정
    
    Args:
        setup_code: 설정 코드
        operation_code: 측정할 작업 코드
        repeat: 반복 횟수
        
    Returns:
        float: 평균 실행 시간(초)
    """
    times = timeit.repeat(operation_code, setup_code, number=100000, repeat=repeat)
    return min(times)

# 1. 적절한 자료구조 선택
def membership_test():
    """자료구조별 멤버십 테스트 성능 비교"""
    # 테스트용 데이터
    n = 10000
    data = list(range(n))
    lookup_value = n // 2
    
    # 리스트 검색 (O(n))
    list_time = measure_time(lambda: lookup_value in data)
    
    # 세트 검색 (O(1))
    data_set = set(data)
    set_time = measure_time(lambda: lookup_value in data_set)
    
    # 딕셔너리 검색 (O(1))
    data_dict = {i: True for i in data}
    dict_time = measure_time(lambda: lookup_value in data_dict)
    
    print(f"리스트 검색: {list_time:.6f}초")
    print(f"세트 검색: {set_time:.6f}초")
    print(f"딕셔너리 검색: {dict_time:.6f}초")
    print(f"세트/리스트 속도 비율: {list_time/set_time:.2f}x")

# 2. Defaultdict 사용
def word_count_inefficient(words: List[str]) -> Dict[str, int]:
    """일반 딕셔너리로 단어 카운트 (비효율적)"""
    word_count = {}
    for word in words:
        if word not in word_count:
            word_count[word] = 0
        word_count[word] += 1
    return word_count

def word_count_defaultdict(words: List[str]) -> Dict[str, int]:
    """defaultdict로 단어 카운트 (효율적)"""
    word_count = defaultdict(int)
    for word in words:
        word_count[word] += 1
    return word_count

def word_count_counter(words: List[str]) -> Dict[str, int]:
    """Counter로 단어 카운트 (가장 효율적)"""
    return Counter(words)

# 3. 메모리 효율적인 배열
def compare_memory_usage():
    """자료구조별 메모리 사용량 비교"""
    n = 1000000
    
    # 일반 리스트
    lst = list(range(n))
    list_size = sys.getsizeof(lst) + sum(sys.getsizeof(i) for i in lst[:100]) / 100 * n
    
    # array 모듈 (타입 지정)
    arr = array.array('i', range(n))
    array_size = sys.getsizeof(arr)
    
    # NumPy 배열
    np_arr = np.arange(n, dtype=np.int32)
    numpy_size = np_arr.nbytes
    
    print(f"리스트 메모리: {list_size/1024/1024:.2f} MB")
    print(f"Array 메모리: {array_size/1024/1024:.2f} MB")
    print(f"NumPy 메모리: {numpy_size/1024/1024:.2f} MB")
    print(f"Array/리스트 메모리 비율: {array_size/list_size:.2f}x")
    print(f"NumPy/리스트 메모리 비율: {numpy_size/list_size:.2f}x")

# 4. 큐 최적화
def queue_operations():
    """큐 구현별 성능 비교"""
    # 리스트를 큐로 사용 (비효율적)
    queue_list = []
    list_time = measure_time(lambda: [queue_list.append(i) for i in range(10000)] + 
                                    [queue_list.pop(0) for _ in range(10000)])
    
    # deque 사용 (효율적)
    queue_deque = deque()
    deque_time = measure_time(lambda: [queue_deque.append(i) for i in range(10000)] + 
                                     [queue_deque.popleft() for _ in range(10000)])
    
    print(f"리스트 큐: {list_time:.6f}초")
    print(f"Deque 큐: {deque_time:.6f}초")
    print(f"리스트/Deque 속도 비율: {list_time/deque_time:.2f}x")

# 5. namedtuple vs 클래스
Point = namedtuple('Point', ['x', 'y'])

class PointClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def compare_namedtuple_class():
    """namedtuple과 클래스 성능 비교"""
    # namedtuple 생성 및 접근
    namedtuple_time = measure_time(lambda: [Point(i, i*2).x for i in range(10000)])
    
    # 클래스 생성 및 접근
    class_time = measure_time(lambda: [PointClass(i, i*2).x for i in range(10000)])
    
    print(f"Namedtuple: {namedtuple_time:.6f}초")
    print(f"Class: {class_time:.6f}초")
    print(f"상대적 성능: {class_time/namedtuple_time:.2f}x")

# 자료구조 최적화 데모
if __name__ == "__main__":
    print("===== 자료구조별 검색 성능 =====")
    membership_test()
    
    print("\n===== 단어 카운팅 방법별 성능 =====")
    words = ["apple", "banana", "cherry", "apple", "banana", "apple", "date", "fig"]
    measure_time(word_count_inefficient, words)
    measure_time(word_count_defaultdict, words)
    measure_time(word_count_counter, words)
    
    print("\n===== 메모리 사용량 비교 =====")
    compare_memory_usage()
    
    print("\n===== 큐 구현별 성능 =====")
    queue_operations()
    
    print("\n===== namedtuple vs 클래스 =====")
    compare_namedtuple_class()

from typing import List, Set, Dict, Tuple, Optional, Any
import heapq
import time
import random
import bisect
from functools import lru_cache

def measure_time(func, *args, **kwargs):
    """함수 실행 시간 측정"""
    start_time = time.time()
    result = func(*args, **kwargs)
    end_time = time.time()
    print(f"{func.__name__} 실행 시간: {end_time - start_time:.6f}초")
    return result

# 1. 이진 검색 최적화
def linear_search(arr: List[int], target: int) -> int:
    """선형 검색 구현 (O(n))"""
    for i, val in enumerate(arr):
        if val == target:
            return i
    return -1

def binary_search(arr: List[int], target: int) -> int:
    """이진 검색 구현 (O(log n))"""
    left, right = 0, len(arr) - 1
    
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    
    return -1

def bisect_search(arr: List[int], target: int) -> int:
    """bisect 모듈 사용 이진 검색"""
    i = bisect.bisect_left(arr, target)
    if i != len(arr) and arr[i] == target:
        return i
    return -1

# 2. 정렬 알고리즘 선택
def bubble_sort(arr: List[int]) -> List[int]:
    """버블 정렬 구현 (O(n²))"""
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

def insertion_sort(arr: List[int]) -> List[int]:
    """삽입 정렬 구현 (O(n²), 작은 배열에 효율적)"""
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

def merge_sort(arr: List[int]) -> List[int]:
    """병합 정렬 구현 (O(n log n))"""
    if len(arr) <= 1:
        return arr
    
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    
    return merge(left, right)

def merge(left: List[int], right: List[int]) -> List[int]:
    """병합 정렬의 병합 단계"""
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    
    result.extend(left[i:])
    result.extend(right[j:])
    return result

def quick_sort(arr: List[int]) -> List[int]:
    """퀵 정렬 구현 (평균 O(n log n))"""
    if len(arr) <= 1:
        return arr
    
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    
    return quick_sort(left) + middle + quick_sort(right)

def timsort_python(arr: List[int]) -> List[int]:
    """파이썬 내장 정렬 (Timsort)"""
    return sorted(arr)

# 3. 동적 프로그래밍
def fibonacci_recursive(n: int) -> int:
    """재귀적 피보나치 (지수적 시간 복잡도)"""
    if n <= 1:
        return n
    return fibonacci_recursive(n-1) + fibonacci_recursive(n-2)

def fibonacci_dp(n: int) -> int:
    """동적 프로그래밍 피보나치 (선형 시간 복잡도)"""
    if n <= 1:
        return n
    
    fib = [0] * (n + 1)
    fib[1] = 1
    
    for i in range(2, n + 1):
        fib[i] = fib[i-1] + fib[i-2]
    
    return fib[n]

@lru_cache(maxsize=None)
def fibonacci_memoization(n: int) -> int:
    """메모이제이션 피보나치 (선형 시간 복잡도)"""
    if n <= 1:
        return n
    return fibonacci_memoization(n-1) + fibonacci_memoization(n-2)

# 4. 그리디 알고리즘
def coin_change_greedy(coins: List[int], amount: int) -> List[int]:
    """그리디 동전 교환 (최적해가 아닐 수 있음)"""
    coins.sort(reverse=True)
    result = []
    
    for coin in coins:
        while amount >= coin:
            amount -= coin
            result.append(coin)
    
    if amount == 0:
        return result
    return []  # 해결책이 없음

def coin_change_dp(coins: List[int], amount: int) -> int:
    """동적 프로그래밍 동전 교환 (최적해)"""
    # dp[i] = amount i를 만드는데 필요한 최소 동전 수
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0
    
    for coin in coins:
        for i in range(coin, amount + 1):
            dp[i] = min(dp[i], dp[i - coin] + 1)
    
    return dp[amount] if dp[amount] != float('inf') else -1

# 5. 그래프 알고리즘
def dijkstra(graph: Dict[str, Dict[str, int]], start: str) -> Dict[str, int]:
    """다익스트라 알고리즘 (최단 경로)"""
    # 초기화
    distances = {node: float('infinity') for node in graph}
    distances[start] = 0
    priority_queue = [(0, start)]
    
    while priority_queue:
        current_distance, current_node = heapq.heappop(priority_queue)
        
        # 이미 처리한 노드는 건너뜀
        if current_distance > distances[current_node]:
            continue
        
        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            
            # 더 짧은 경로를 찾으면 업데이트
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(priority_queue, (distance, neighbor))
    
    return distances

# 알고리즘 성능 비교
if __name__ == "__main__":
    # 검색 알고리즘 비교
    print("===== 검색 알고리즘 비교 =====")
    arr = sorted(random.sample(range(1000000), 10000))
    target = arr[5000]  # 존재하는 값
    
    measure_time(linear_search, arr, target)
    measure_time(binary_search, arr, target)
    measure_time(bisect_search, arr, target)
    
    # 정렬 알고리즘 비교
    print("\n===== 정렬 알고리즘 비교 =====")
    # 작은 배열에서는 삽입 정렬이 효율적일 수 있음
    small_arr = random.sample(range(100), 20)
    measure_time(bubble_sort, small_arr.copy())
    measure_time(insertion_sort, small_arr.copy())
    
    # 큰 배열에서는 효율적인 정렬 알고리즘 필요
    large_arr = random.sample(range(10000), 1000)
    measure_time(merge_sort, large_arr.copy())
    measure_time(quick_sort, large_arr.copy())
    measure_time(timsort_python, large_arr.copy())
    
    # 피보나치 구현 비교
    print("\n===== 피보나치 구현 비교 =====")
    n = 30
    measure_time(fibonacci_recursive, n)
    measure_time(fibonacci_dp, n)
    measure_time(fibonacci_memoization, n)
    
    # 동전 교환 문제
    print("\n===== 동전 교환 문제 =====")
    coins = [1, 5, 10, 25]
    amount = 63
    greedy_result = measure_time(coin_change_greedy, coins, amount)
    dp_result = measure_time(coin_change_dp, coins, amount)
    print(f"그리디 결과: {greedy_result} (동전 수: {len(greedy_result)})")
    print(f"DP 결과: 최소 동전 수 {dp_result}개")
    
    # 다익스트라 알고리즘
    print("\n===== 다익스트라 알고리즘 =====")
    graph = {
        'A': {'B': 2, 'C': 5},
        'B': {'A': 2, 'D': 3, 'E': 1},
        'C': {'A': 5, 'F': 3},
        'D': {'B': 3},
        'E': {'B': 1, 'F': 1},
        'F': {'C': 3, 'E': 1}
    }
    shortest_paths = measure_time(dijkstra, graph, 'A')
    print(f"A로부터의 최단 경로: {shortest_paths}")

import asyncio
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import multiprocessing
import threading
import time
from typing import List, Callable, Any
import requests
import aiohttp
import math

def measure_time(func: Callable, *args, **kwargs) -> Any:
    """함수 실행 시간 측정"""
    start_time = time.time()
    result = func(*args, **kwargs)
    end_time = time.time()
    print(f"{func.__name__} 실행 시간: {end_time - start_time:.4f}초")
    return result

# 1. CPU 바운드 작업: 멀티프로세싱
def cpu_intensive_task(n: int) -> int:
    """CPU 집약적 작업 (소수 계산)
    
    Args:
        n: 계산할 범위
        
    Returns:
        int: 소수 개수
    """
    count = 0
    for i in range(2, n + 1):
        is_prime = True
        for j in range(2, int(math.sqrt(i)) + 1):
            if i % j == 0:
                is_prime = False
                break
        if is_prime:
            count += 1
    return count

def process_data_sequential(numbers: List[int]) -> List[int]:
    """순차 처리"""
    return [cpu_intensive_task(n) for n in numbers]

def process_data_multiprocessing(numbers: List[int], num_processes: int = None) -> List[int]:
    """멀티프로세싱 처리
    
    Args:
        numbers: 처리할 숫자 리스트
        num_processes: 프로세스 수 (None이면 CPU 코어 수 사용)
        
    Returns:
        List[int]: 결과 리스트
    """
    if num_processes is None:
        num_processes = multiprocessing.cpu_count()
    
    with ProcessPoolExecutor(max_workers=num_processes) as executor:
        results = list(executor.map(cpu_intensive_task, numbers))
    
    return results

# 2. I/O 바운드 작업: 멀티스레딩
def io_task(url: str) -> int:
    """I/O 작업 (웹 요청)
    
    Args:
        url: 요청할 URL
        
    Returns:
        int: 응답 크기
    """
    response = requests.get(url)
    return len(response.content)

def process_urls_sequential(urls: List[str]) -> List[int]:
    """순차 처리"""
    return [io_task(url) for url in urls]

def process_urls_multithreading(urls: List[str], num_threads: int = 10) -> List[int]:
    """멀티스레딩 처리
    
    Args:
        urls: 처리할 URL 리스트
        num_threads: 스레드 수
        
    Returns:
        List[int]: 결과 리스트
    """
    with ThreadPoolExecutor(max_workers=num_threads) as executor:
        results = list(executor.map(io_task, urls))
    
    return results

# 3. 비동기 I/O
async def async_io_task(url: str, session: aiohttp.ClientSession) -> int:
    """비동기 I/O 작업
    
    Args:
        url: 요청할 URL
        session: aiohttp 세션
        
    Returns:
        int: 응답 크기
    """
    async with session.get(url) as response:
        content = await response.read()
        return len(content)

async def process_urls_async(urls: List[str]) -> List[int]:
    """비동기 처리
    
    Args:
        urls: 처리할 URL 리스트
        
    Returns:
        List[int]: 결과 리스트
    """
    async with aiohttp.ClientSession() as session:
        tasks = [async_io_task(url, session) for url in urls]
        return await asyncio.gather(*tasks)

# 4. 혼합 접근: 프로세스 풀 + 스레드 풀
def hybrid_task(data: tuple) -> int:
    """CPU 및 I/O 혼합 작업
    
    Args:
        data: (계산할 숫자, 요청할 URL) 튜플
        
    Returns:
        int: 계산 결과 + 응답 크기
    """
    n, url = data
    
    # CPU 작업
    prime_count = cpu_intensive_task(n)
    
    # I/O 작업
    with ThreadPoolExecutor(max_workers=1) as executor:
        response_size = executor.submit(io_task, url).result()
    
    return prime_count + response_size

def process_hybrid_tasks_sequential(data_list: List[tuple]) -> List[int]:
    """순차 처리"""
    return [hybrid_task(data) for data in data_list]

def process_hybrid_tasks_parallel(data_list: List[tuple], num_processes: int = None) -> List[int]:
    """병렬 처리 (프로세스 풀)
    
    Args:
        data_list: 처리할 데이터 리스트
        num_processes: 프로세스 수
        
    Returns:
        List[int]: 결과 리스트
    """
    if num_processes is None:
        num_processes = multiprocessing.cpu_count()
    
    with ProcessPoolExecutor(max_workers=num_processes) as executor:
        results = list(executor.map(hybrid_task, data_list))
    
    return results

# 5. 비동기 제너레이터
async def async_generator(n: int):
    """비동기 제너레이터
    
    Args:
        n: 생성할 항목 수
    """
    for i in range(n):
        await asyncio.sleep(0.01)  # 비동기 대기
        yield i * i

async def consume_async_generator(n: int) -> List[int]:
    """비동기 제너레이터 소비
    
    Args:
        n: 처리할 항목 수
        
    Returns:
        List[int]: 수집된 결과
    """
    results = []
    async for value in async_generator(n):
        results.append(value)
    return results

# 병렬 및 비동기 처리 벤치마크
def run_benchmarks():
    """다양한 병렬 및 비동기 접근 방식 벤치마크"""
    # 1. CPU 바운드 작업 벤치마크
    print("===== CPU 바운드 작업 비교 =====")
    numbers = [10000, 20000, 30000, 40000]
    
    sequential_results = measure_time(process_data_sequential, numbers)
    multiprocessing_results = measure_time(process_data_multiprocessing, numbers)
    
    print(f"순차 처리 결과: {sequential_results}")
    print(f"멀티프로세싱 결과: {multiprocessing_results}")
    
    # 2. I/O 바운드 작업 벤치마크
    print("\n===== I/O 바운드 작업 비교 =====")
    urls = [
        "https://www.python.org",
        "https://docs.python.org",
        "https://pypi.org",
        "https://www.djangoproject.com",
        "https://flask.palletsprojects.com"
    ] * 2  # 10개 URL
    
    sequential_io = measure_time(process_urls_sequential, urls)
    multithreading_io = measure_time(process_urls_multithreading, urls)
    
    # 비동기 I/O 실행
    async def run_async():
        return await process_urls_async(urls)
    
    start_time = time.time()
    async_io = asyncio.run(run_async())
    end_time = time.time()
    print(f"process_urls_async 실행 시간: {end_time - start_time:.4f}초")
    
    print(f"순차 I/O 결과 수: {len(sequential_io)}")
    print(f"멀티스레딩 I/O 결과 수: {len(multithreading_io)}")
    print(f"비동기 I/O 결과 수: {len(async_io)}")
    
    # 3. 혼합 작업 벤치마크
    print("\n===== 혼합 작업 비교 =====")
    hybrid_data = list(zip(numbers, urls[:len(numbers)]))
    
    sequential_hybrid = measure_time(process_hybrid_tasks_sequential, hybrid_data)
    parallel_hybrid = measure_time(process_hybrid_tasks_parallel, hybrid_data)
    
    print(f"순차 혼합 결과: {sequential_hybrid}")
    print(f"병렬 혼합 결과: {parallel_hybrid}")

if __name__ == "__main__":
    run_benchmarks()

from typing import Iterator, Generator, List, Dict, Any, Callable
import gc
import sys
import psutil
import os
import weakref
import time
import numpy as np
from memory_profiler import profile

def get_memory_usage() -> float:
    """현재 프로세스의 메모리 사용량 반환 (MB)"""
    process = psutil.Process(os.getpid())
    return process.memory_info().rss / 1024 / 1024

def print_memory_usage(label: str) -> None:
    """메모리 사용량 출력"""
    print(f"{label}: {get_memory_usage():.2f} MB")

# 1. 제너레이터를 사용한 메모리 최적화
def read_large_file_into_memory(file_path: str) -> List[str]:
    """파일을 모두 메모리에 로드 (비효율적)"""
    with open(file_path, 'r') as f:
        return f.readlines()

def read_large_file_generator(file_path: str) -> Generator[str, None, None]:
    """파일을 한 줄씩 처리하는 제너레이터 (효율적)"""
    with open(file_path, 'r') as f:
        for line in f:
            yield line.strip()

def demonstrate_file_reading(file_path: str) -> None:
    """파일 읽기 방식 비교"""
    # 테스트 파일 생성
    with open(file_path, 'w') as f:
        for i in range(1000000):
            f.write(f"Line {i}\n")
    
    # 전체 메모리 로드
    print_memory_usage("파일 읽기 전")
    try:
        lines = read_large_file_into_memory(file_path)
        print(f"전체 로드: {len(lines)} 줄")
    except MemoryError:
        print("메모리 에러! 파일이 너무 큽니다.")
    print_memory_usage("전체 파일 로드 후")
    
    # 제너레이터 사용
    print_memory_usage("제너레이터 사용 전")
    count = 0
    for line in read_large_file_generator(file_path):
        count += 1
        if count % 100000 == 0:
            print(f"처리 중: {count} 줄")
    print(f"제너레이터: {count} 줄 처리")
    print_memory_usage("제너레이터 사용 후")
    
    # 파일 삭제
    os.remove(file_path)

# 2. 메모리 누수 방지
class ResourceManager:
    """리소스 관리 클래스"""
    
    def __init__(self):
        """초기화"""
        self.resources = []
    
    def add_resource(self, resource: Any) -> None:
        """리소스 추가"""
        self.resources.append(resource)
    
    def cleanup(self) -> None:
        """리소스 정리"""
        for resource in self.resources:
            # 리소스 해제 로직 (파일, 연결 등)
            if hasattr(resource, 'close') and callable(resource.close):
                resource.close()
        self.resources.clear()
        
        # 가비지 컬렉션 강제 실행
        gc.collect()

def simulate_memory_leak() -> None:
    """메모리 누수 시뮬레이션"""
    class Resource:
        """리소스 시뮬레이션 클래스"""
        def __init__(self, size: int):
            self.data = [0] * size
        
        def close(self):
            self.data = None
    
    # 메모리 누수가 있는 코드
    print_memory_usage("누수 시뮬레이션 시작")
    leaky_resources = []
    for i in range(10):
        leaky_resources.append(Resource(1000000))  # 메모리 누수
        print_memory_usage(f"리소스 {i+1}개 추가")
    
    # 참조를 제거해도 메모리는 회수되지 않음
    leaky_resources = None
    print_memory_usage("참조 제거 후")
    gc.collect()
    print_memory_usage("가비지 컬렉션 후")
    
    # 적절한 리소스 관리
    print_memory_usage("리소스 관리자 시작")
    manager = ResourceManager()
    for i in range(10):
        manager.add_resource(Resource(1000000))
        print_memory_usage(f"관리된 리소스 {i+1}개 추가")
    
    # 적절한 정리
    manager.cleanup()
    print_memory_usage("리소스 정리 후")

# 3. 약한 참조 사용
def demonstrate_weak_references() -> None:
    """약한 참조 사용 예시"""
    class LargeObject:
        """큰 객체 시뮬레이션"""
        def __init__(self, name: str):
            self.name = name
            self.data = [0] * 1000000
    
    # 일반 참조
    print_memory_usage("시작")
    obj = LargeObject("big_object")
    print_memory_usage("객체 생성 후")
    
    # 약한 참조
    weak_ref = weakref.ref(obj)
    print(f"약한 참조 유효: {weak_ref() is not None}")
    
    # 원본 참조 제거
    obj = None
    print_memory_usage("원본 참조 제거 후")
    print(f"약한 참조 유효: {weak_ref() is not None}")
    
    # 가비지 컬렉션
    gc.collect()
    print_memory_usage("가비지 컬렉션 후")

# 4. 캐시 최적화
def demonstrate_caching() -> None:
    """캐시 최적화 예시"""
    # 비효율적인 캐시 (무제한 성장)
    unlimited_cache = {}
    
    # LRU 캐시 (제한된 크기)
    from functools import lru_cache
    
    @lru_cache(maxsize=100)
    def fibonacci(n: int) -> int:
        if n < 2:
            return n
        return fibonacci(n-1) + fibonacci(n-2)
    
    # 캐시 성장 시뮬레이션
    print_memory_usage("캐시 사용 전")
    
    # 무제한 캐시 성장
    for i in range(1000):
        key = f"key_{i}"
        unlimited_cache[key] = [0] * 10000  # 각 항목당 ~80KB
        if i % 100 == 0:
            print_memory_usage(f"무제한 캐시 {i}개 항목")
    
    # LRU 캐시 사용
    for i in range(200):
        fibonacci(i)
    print_memory_usage("LRU 캐시 사용 후")
    
    # 캐시 정리
    unlimited_cache.clear()
    gc.collect()
    print_memory_usage("캐시 정리 후")

# 5. NumPy 및 메모리 뷰 사용
def demonstrate_numpy_memory_views() -> None:
    """NumPy 및 메모리 뷰 최적화 예시"""
    # 일반 파이썬 리스트
    print_memory_usage("시작")
    py_list = list(range(10000000))  # 큰 리스트
    print_memory_usage("파이썬 리스트 생성 후")
    
    # NumPy 배열
    np_array = np.arange(10000000)  # 동일한 크기의 NumPy 배열
    print_memory_usage("NumPy 배열 생성 후")
    
    # 메모리 뷰
    buffer = bytes(range(255)) * 1000  # 바이트 버퍼
    mem_view = memoryview(buffer)  # 복사 없이 버퍼 참조
    print_memory_usage("메모리 뷰 생성 후")
    
    # 슬라이싱 비교
    # 파이썬 리스트 슬라이싱 (복사본 생성)
    py_slice = py_list[1000000:2000000]
    print_memory_usage("파이썬 슬라이스 후")
    
    # NumPy 슬라이스 (뷰)
    np_slice = np_array[1000000:2000000]
    print_memory_usage("NumPy 슬라이스 후")
    
    # 정리
    py_list = None
    np_array = None
    buffer = None
    mem_view = None
    py_slice = None
    np_slice = None
    gc.collect()
    print_memory_usage("정리 후")

# 메모리 최적화 실행
if __name__ == "__main__":
    print("===== 제너레이터와 파일 처리 =====")
    demonstrate_file_reading("large_test_file.txt")
    
    print("\n===== 메모리 누수 방지 =====")
    simulate_memory_leak()
    
    print("\n===== 약한 참조 활용 =====")
    demonstrate_weak_references()
    
    print("\n===== 캐시 최적화 =====")
    demonstrate_caching()
    
    print("\n===== NumPy 및 메모리 뷰 =====")
    demonstrate_numpy_memory_views()