# 예제 1: 숫자 5를 만나면 반복 종료
for i in range(10):
    if i == 5:
        break
    print(i)  # 0,1,2,3,4 출력

# 예제 2: while문에서의 break
while True:
    response = input("계속하시겠습니까? (y/n): ")
    if response == 'n':
        break

# 예제 1: 짝수만 출력
for i in range(5):
    if i % 2 != 0:
        continue
    print(i)  # 0,2,4 출력

# 예제 2: 특정 조건 건너뛰기
for name in ['John', '', 'Jane', '', 'Mike']:
    if name == '':
        continue
    print(name)  # 빈 문자열 제외하고 출력

# 예제 1: 클래스 뼈대 만들기
class MyEmptyClass:
    pass

# 예제 2: 조건문에서 사용
if True:
    pass  # 나중에 구현할 예정
else:
    print("else")

# for-else 예제
for i in range(5):
    if i == 10:
        break
else:
    print("반복문이 정상적으로 완료됨")

# while-else 예제
count = 0
while count < 3:
    print(count)
    count += 1
else:
    print("while문이 정상적으로 완료됨")

# 중첩 반복문에서 break 사용
for i in range(3):
    for j in range(3):
        if i == j:
            break
        print(i, j)

# 중첩 조건문에서 continue 사용
for i in range(5):
    if i < 2:
        continue
    if i > 3:
        break
    print(i)  # 2,3 출력

# 기본 try-except
try:
    result = 10 / 0
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다")

# try-except-else-finally
try:
    number = int(input("숫자를 입력하세요: "))
    result = 100 / number
except ValueError:
    print("올바른 숫자를 입력하세요")
except ZeroDivisionError:
    print("0으로 나눌 수 없습니다")
else:
    print(f"결과: {result}")  # 예외가 발생하지 않으면 실행
finally:
    print("항상 실행되는 코드")  # 예외 발생 여부와 관계없이 실행

# 파일 처리에 with 사용
with open('example.txt', 'w') as file:
    file.write('Hello, World!')
# 파일이 자동으로 닫힘

# 여러 컨텍스트 관리자 동시 사용
with open('input.txt', 'r') as input_file, open('output.txt', 'w') as output_file:
    content = input_file.read()
    output_file.write(content.upper())

# 사용자 정의 컨텍스트 관리자
from contextlib import contextmanager

@contextmanager
def timer():
    import time
    start = time.time()
    yield  # 이 지점에서 with 블록 내부 코드 실행
    end = time.time()
    print(f"실행 시간: {end - start}초")

# 사용
with timer():
    # 시간을 측정할 코드
    sum(range(1000000))

# 기본 사용법
def process_response(status):
    match status:
        case 200:
            return "OK"
        case 404:
            return "Not Found"
        case 500:
            return "Server Error"
        case _:  # 기본값
            return "Unknown"

# 패턴 매칭 활용
def process_command(command):
    match command.split():
        case ["quit"]:
            return "프로그램을 종료합니다."
        case ["help"]:
            return "도움말을 표시합니다."
        case ["open", filename]:
            return f"{filename} 파일을 엽니다."
        case ["save", filename]:
            return f"{filename} 파일을 저장합니다."
        case ["open", *filenames]:
            return f"여러 파일을 엽니다: {filenames}"
        case _:
            return "알 수 없는 명령어입니다."

# 객체 패턴 매칭
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

def classify_point(point):
    match point:
        case Point(x=0, y=0):
            return "원점"
        case Point(x=0, y=y):
            return f"y축 위의 점 (y={y})"
        case Point(x=x, y=0):
            return f"x축 위의 점 (x={x})"
        case Point(x=x, y=y) if x == y:
            return f"대각선 위의 점 (x=y={x})"
        case Point():
            return f"일반 좌표 ({point.x}, {point.y})"

# 중첩 조건문
def process_data(data):
    if data:
        if isinstance(data, list):
            if len(data) > 0:
                # 데이터 처리
                return "처리 완료"
            else:
                return "빈 리스트"
        else:
            return "리스트가 아님"
    else:
        return "데이터 없음"

# 조기 반환 패턴
def process_data_optimized(data):
    if not data:
        return "데이터 없음"
    
    if not isinstance(data, list):
        return "리스트가 아님"
    
    if len(data) == 0:
        return "빈 리스트"
    
    # 데이터 처리
    return "처리 완료"

# 선형 검색 - break 활용
def find_element(data, target):
    result = -1
    for i, value in enumerate(data):
        if value == target:
            result = i
            break
    return result

# 이진 검색 - 정렬된 데이터에서 효율적
def binary_search(data, target):
    low, high = 0, len(data) - 1
    
    while low <= high:
        mid = (low + high) // 2
        if data[mid] == target:
            return mid
        elif data[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    
    return -1

import time

# 루프 내 연산 최소화
def sum_squares_unoptimized(n):
    start = time.time()
    result = 0
    for i in range(n):
        result += i**2
    print(f"Unoptimized: {time.time() - start:.6f}초")
    return result

def sum_squares_optimized(n):
    start = time.time()
    # 루프 밖으로 비용이 큰 연산 이동
    result = sum(i**2 for i in range(n))
    print(f"Optimized: {time.time() - start:.6f}초")
    return result

# 예시: 처리할 데이터가 많을 때 효과적
sum_squares_unoptimized(1000000)
sum_squares_optimized(1000000)

def process_user(user_data):
    # 가드 절 - 유효하지 않은 경우 빠르게 반환
    if user_data is None:
        return "사용자 데이터가 없습니다"
    
    if not isinstance(user_data, dict):
        return "사용자 데이터는 딕셔너리 형태여야 합니다"
    
    if 'name' not in user_data:
        return "사용자 이름이 필요합니다"
    
    if 'age' not in user_data:
        return "사용자 나이가 필요합니다"
    
    # 모든 검증을 통과한 후 실제 처리 로직
    name = user_data['name']
    age = user_data['age']
    
    return f"{name}({age}세) 사용자 처리 완료"

class OrderState:
    def process(self, order):
        raise NotImplementedError
    
    def cancel(self, order):
        raise NotImplementedError

class NewOrder(OrderState):
    def process(self, order):
        print("주문 처리 시작")
        order.state = ProcessingOrder()
        return True
    
    def cancel(self, order):
        print("새 주문 취소")
        order.state = CancelledOrder()
        return True

class ProcessingOrder(OrderState):
    def process(self, order):
        print("이미 처리 중입니다")
        return False
    
    def cancel(self, order):
        print("처리 중 주문 취소")
        order.state = CancelledOrder()
        return True

class ShippedOrder(OrderState):
    def process(self, order):
        print("이미 발송되었습니다")
        return False
    
    def cancel(self, order):
        print("발송된 주문은 취소할 수 없습니다")
        return False

class CancelledOrder(OrderState):
    def process(self, order):
        print("취소된 주문은 처리할 수 없습니다")
        return False
    
    def cancel(self, order):
        print("이미 취소된 주문입니다")
        return False

class Order:
    def __init__(self):
        self.state = NewOrder()
    
    def process(self):
        return self.state.process(self)
    
    def cancel(self):
        return self.state.cancel(self)

def validate_username(username):
    if len(username) < 4:
        return False, "사용자 이름은 4자 이상이어야 합니다"
    return True, None

def validate_email(email):
    if '@' not in email:
        return False, "유효한 이메일 형식이 아닙니다"
    return True, None

def validate_password(password):
    if len(password) < 8:
        return False, "비밀번호는 8자 이상이어야 합니다"
    return True, None

def register_user(username, email, password):
    # 검증 체인
    validations = [
        (validate_username, username),
        (validate_email, email),
        (validate_password, password)
    ]
    
    for validator, value in validations:
        valid, error = validator(value)
        if not valid:
            return {"success": False, "error": error}
    
    # 모든 검증을 통과하면 사용자 등록
    return {"success": True, "message": "사용자가 등록되었습니다"}

from abc import ABC, abstractmethod

# 전략 인터페이스
class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data):
        pass

# 구체적인 전략들
class QuickSort(SortStrategy):
    def sort(self, data):
        print("퀵 정렬 수행")
        return sorted(data)  # 실제로는 퀵 정렬 구현

class MergeSort(SortStrategy):
    def sort(self, data):
        print("병합 정렬 수행")
        return sorted(data)  # 실제로는 병합 정렬 구현

class BubbleSort(SortStrategy):
    def sort(self, data):
        print("버블 정렬 수행")
        return sorted(data)  # 실제로는 버블 정렬 구현

# 컨텍스트
class Sorter:
    def __init__(self, strategy=None):
        self.strategy = strategy or QuickSort()
    
    def set_strategy(self, strategy):
        self.strategy = strategy
    
    def sort(self, data):
        return self.strategy.sort(data)

# 사용 예시
sorter = Sorter()
data = [3, 1, 4, 1, 5, 9, 2, 6]

# 기본 전략(퀵 정렬) 사용
result = sorter.sort(data)

# 전략 변경
sorter.set_strategy(MergeSort())
result = sorter.sort(data)

# 조건에 따른 전략 선택
if len(data) < 10:
    sorter.set_strategy(BubbleSort())
else:
    sorter.set_strategy(QuickSort())

result = sorter.sort(data)

import asyncio

# 기본 비동기 함수
async def fetch_data(id):
    print(f"데이터 {id} 가져오는 중...")
    await asyncio.sleep(1)  # 비동기 대기 (I/O 작업 시뮬레이션)
    return f"데이터 {id}"

# 동시 실행
async def fetch_all_data():
    # 여러 작업 동시 실행
    tasks = [fetch_data(i) for i in range(1, 6)]
    results = await asyncio.gather(*tasks)
    return results

# 순차 실행
async def fetch_in_sequence():
    results = []
    for i in range(1, 6):
        result = await fetch_data(i)
        results.append(result)
    return results

# 타임아웃 처리
async def fetch_with_timeout(id, timeout=1.5):
    try:
        return await asyncio.wait_for(fetch_data(id), timeout)
    except asyncio.TimeoutError:
        return f"데이터 {id} 가져오기 시간 초과"

# 비동기 컨텍스트 관리자
async def process_data():
    async with asyncio.TaskGroup() as tg:
        task1 = tg.create_task(fetch_data(1))
        task2 = tg.create_task(fetch_data(2))
        task3 = tg.create_task(fetch_data(3))
    
    # 모든 작업이 완료된 후 결과 사용
    return [task1.result(), task2.result(), task3.result()]

# 비동기 이터레이션
async def async_range(start, stop):
    for i in range(start, stop):
        await asyncio.sleep(0.5)
        yield i

async def use_async_iterator():
    async for i in async_range(1, 5):
        print(f"비동기 이터레이션: {i}")

# 메인 함수
async def main():
    # 동시 실행
    results = await fetch_all_data()
    print(f"동시 실행 결과: {results}")
    
    # 순차 실행
    results = await fetch_in_sequence()
    print(f"순차 실행 결과: {results}")
    
    # 타임아웃 처리
    result = await fetch_with_timeout(5, 0.5)
    print(f"타임아웃 처리: {result}")
    
    # 비동기 컨텍스트 관리자
    results = await process_data()
    print(f"TaskGroup 결과: {results}")
    
    # 비동기 이터레이션
    await use_async_iterator()

# 실행
if __name__ == "__main__":
    asyncio.run(main())

# 각 단계별 처리 함수
def validate_data(data):
    if not data:
        return None
    return data

def transform_data(data):
    if data is None:
        return None
    
    try:
        transformed = [x * 2 for x in data]
        return transformed
    except Exception:
        return None

def filter_data(data):
    if data is None:
        return None
    
    return [x for x in data if x > 10]

def save_data(data):
    if data is None:
        return "처리 실패"
    
    # 저장 로직
    return f"저장 완료: {data}"

# 최적화 전 - 중첩 조건문
def process_pipeline_original(data):
    validated = validate_data(data)
    if validated is not None:
        transformed = transform_data(validated)
        if transformed is not None:
            filtered = filter_data(transformed)
            if filtered is not None:
                return save_data(filtered)
            else:
                return "필터링 실패"
        else:
            return "변환 실패"
    else:
        return "유효성 검사 실패"

# 최적화 후 - 조기 반환 및 파이프라인 패턴
def process_pipeline_optimized(data):
    validated = validate_data(data)
    if validated is None:
        return "유효성 검사 실패"
    
    transformed = transform_data(validated)
    if transformed is None:
        return "변환 실패"
    
    filtered = filter_data(transformed)
    if filtered is None:
        return "필터링 실패"
    
    return save_data(filtered)

# 함수형 접근법
def pipeline(*funcs):
    def process(data):
        result = data
        for func in funcs:
            result = func(result)
            if result is None:
                return None
        return result
    return process

# 사용 예시
process_data = pipeline(validate_data, transform_data, filter_data)
result = process_data([1, 5, 10, 15])
if result is not None:
    print(save_data(result))
else:
    print("파이프라인 처리 실패")

import time
from collections import defaultdict

class EventProcessor:
    def __init__(self):
        self.handlers = defaultdict(list)
        self.default_handler = lambda event: print(f"처리되지 않은 이벤트: {event}")
    
    def register(self, event_type, handler):
        self.handlers[event_type].append(handler)
    
    def process(self, event):
        event_type = event.get('type')
        
        # 빠른 경로(fast path): 알려진 이벤트 타입인 경우
        if event_type in self.handlers:
            for handler in self.handlers[event_type]:
                handler(event)
            return True
        
        # 느린 경로(slow path): 알려진 이벤트 타입이 아닌 경우
        self.default_handler(event)
        return False

# 이벤트 핸들러
def handle_click(event):
    print(f"클릭 이벤트 처리: {event.get('position')}")

def handle_hover(event):
    print(f"호버 이벤트 처리: {event.get('position')}")

def handle_key(event):
    print(f"키 이벤트 처리: {event.get('key')}")

# 사용 예시
processor = EventProcessor()
processor.register('click', handle_click)
processor.register('hover', handle_hover)
processor.register('keypress', handle_key)

# 이벤트 처리
events = [
    {'type': 'click', 'position': (10, 20)},
    {'type': 'hover', 'position': (30, 40)},
    {'type': 'keypress', 'key': 'Enter'},
    {'type': 'unknown', 'data': 'some data'}
]

for event in events:
    processor.process(event)