Python

# 리스트 컴프리헨션 - Python의 핵심 문법

# 1. 기본 리스트 컴프리헨션
squares = [x**2 for x in range(10)]
# 결과: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 2. 조건부 필터링
even_squares = [x**2 for x in range(10) if x % 2 == 0]
# 결과: [0, 4, 16, 36, 64]

# 3. 중첩 리스트 컴프리헨션
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
# 결과: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 4. 딕셔너리 컴프리헨션
word = "python"
char_index = {char: idx for idx, char in enumerate(word)}
# 결과: {'p': 0, 'y': 1, 't': 2, 'h': 3, 'o': 4, 'n': 5}

# 5. 셋 컴프리헨션
unique_lengths = {len(word) for word in ["apple", "banana", "cherry", "date"]}
# 결과: {4, 5, 6}

# 6. 제너레이터 표현식 (메모리 효율적)
sum_of_squares = sum(x**2 for x in range(1000000))
# 리스트를 생성하지 않고 한 번에 하나씩 처리

# 7. 실전 예제: 파일에서 특정 라인 필터링
# config_lines = [line.strip() for line in open('config.txt')
#                 if line.strip() and not line.startswith('#')]

# 8. 조건부 값 변환
numbers = [1, -2, 3, -4, 5]
absolute = [x if x > 0 else -x for x in numbers]
# 결과: [1, 2, 3, 4, 5]

# 데코레이터 - Python의 강력한 메타프로그래밍 기능
import functools
import time
from typing import Callable, Any

# 1. 기본 데코레이터 - 실행 시간 측정
def timer(func: Callable) -> Callable:
    """함수 실행 시간을 측정하는 데코레이터"""
    @functools.wraps(func)
    def wrapper(*args, **kwargs) -> Any:
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} 실행 시간: {end - start:.4f}초")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "완료"

# 2. 인자를 받는 데코레이터
def retry(max_attempts: int = 3, delay: float = 1.0):
    """재시도 데코레이터"""
    def decorator(func: Callable) -> Callable:
        @functools.wraps(func)
        def wrapper(*args, **kwargs) -> Any:
            for attempt in range(max_attempts):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts - 1:
                        raise
                    print(f"시도 {attempt + 1} 실패, {delay}초 후 재시도...")
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=3, delay=0.5)
def unstable_api_call():
    import random
    if random.random() < 0.7:
        raise ConnectionError("API 연결 실패")
    return "성공!"

# 3. 클래스 기반 데코레이터
class Cache:
    """결과를 캐싱하는 데코레이터"""
    def __init__(self, func: Callable):
        self.func = func
        self.cache = {}
        functools.update_wrapper(self, func)

    def __call__(self, *args) -> Any:
        if args not in self.cache:
            self.cache[args] = self.func(*args)
        return self.cache[args]

@Cache
def fibonacci(n: int) -> int:
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

# 4. 내장 데코레이터 활용
class MyClass:
    _instance = None

    @staticmethod
    def utility_function():
        """인스턴스 없이 호출 가능"""
        return "유틸리티 결과"

    @classmethod
    def get_instance(cls):
        """싱글톤 패턴 구현"""
        if cls._instance is None:
            cls._instance = cls()
        return cls._instance

    @property
    def computed_value(self):
        """속성처럼 접근 가능한 메서드"""
        return self._value * 2