# 기본 함수 구조
def 함수이름(매개변수):
    실행할_코드
    return 반환값

# 예제
def greet(name):
    return f"Hello, {name}!"

# 1. 매개변수와 반환값이 모두 있는 함수
def add(a, b):
    return a + b

# 2. 매개변수만 있는 함수
def print_info(name, age):
    print(f"이름: {name}, 나이: {age}")

# 3. 반환값만 있는 함수
def get_pi():
    return 3.14

# 4. 매개변수와 반환값이 모두 없는 함수
def say_hello():
    print("Hello!")

# *args: 여러 개의 위치 인자를 튜플로 받음
def sum_all(*args):
    return sum(args)

# **kwargs: 키워드 인자를 딕셔너리로 받음
def print_kwargs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))          # Hello, Alice!
print(greet("Bob", "Hi"))      # Hi, Bob!

# 일반 함수
def add(a, b):
    return a + b

# 람다 함수
add = lambda a, b: a + b

# 활용 예제
numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))

# 전역 변수
global_var = 10

def function():
    # 지역 변수
    local_var = 20
    print(global_var)  # 전역 변수 접근 가능
    
    # 전역 변수 수정
    global global_var
    global_var = 30

# 순수 함수
def pure_add(a, b):
    return a + b  # 외부 상태 변경 없음, 동일 입력 = 동일 출력

# 고차 함수: 함수를 인자로 받거나 함수를 반환
def apply_operation(a, b, operation):
    return operation(a, b)

result = apply_operation(5, 3, lambda x, y: x + y)  # 8

# 함수형 도구
from functools import reduce

# map: 각 요소에 함수 적용
numbers = [1, 2, 3, 4, 5]
doubled = list(map(lambda x: x * 2, numbers))  # [2, 4, 6, 8, 10]

# filter: 조건을 만족하는 요소만 필터링
evens = list(filter(lambda x: x % 2 == 0, numbers))  # [2, 4]

# reduce: 누적 집계
total = reduce(lambda acc, x: acc + x, numbers, 0)  # 15

def make_counter():
    count = 0  # 내부 변수
    
    def counter():
        nonlocal count  # 외부 함수의 변수 사용
        count += 1
        return count
    
    return counter  # 내부 함수 반환

# 사용 예시
counter = make_counter()
print(counter())  # 1
print(counter())  # 2
print(counter())  # 3

# 클로저로 함수 팩토리 만들기
def power_factory(exponent):
    def power(base):
        return base ** exponent
    return power

square = power_factory(2)
cube = power_factory(3)

print(square(4))  # 16
print(cube(3))    # 27

# 기본 데코레이터
def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"함수 {func.__name__} 실행 시작")
        result = func(*args, **kwargs)
        print(f"함수 {func.__name__} 실행 완료")
        return result
    return wrapper

# 데코레이터 적용
@log_decorator
def greet(name):
    return f"Hello, {name}!"

# 위 코드는 다음과 동일:
# greet = log_decorator(greet)

print(greet("Alice"))  # 로그 출력 후 "Hello, Alice!" 반환

# 인자를 받는 데코레이터
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            results = []
            for _ in range(times):
                results.append(func(*args, **kwargs))
            return results
        return wrapper
    return decorator

@repeat(3)
def say_hi():
    return "Hi!"

print(say_hi())  # ["Hi!", "Hi!", "Hi!"] 반환

# 팩토리얼 계산
def factorial(n):
    if n <= 1:  # 기저 조건(base case)
        return 1
    return n * factorial(n - 1)  # 재귀 호출

print(factorial(5))  # 120

# 피보나치 수열
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(6))  # 8

# 꼬리 재귀 최적화
def factorial_tail(n, acc=1):
    if n <= 1:
        return acc
    return factorial_tail(n - 1, n * acc)

print(factorial_tail(5))  # 120

# 제너레이터 함수
def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

# 사용
counter = count_up_to(5)
print(next(counter))  # 1
print(next(counter))  # 2

# for 루프에서 사용
for num in count_up_to(3):
    print(num)  # 1, 2, 3 출력

# 제너레이터 표현식
squares = (x**2 for x in range(5))
print(list(squares))  # [0, 1, 4, 9, 16]

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

counter = infinite_sequence()
for i in range(5):
    print(next(counter))  # 0, 1, 2, 3, 4 출력

# 기본 타입 힌트
def greeting(name: str) -> str:
    return f"Hello, {name}!"

# 복합 타입
from typing import List, Dict, Tuple, Optional, Union, Callable

def process_items(items: List[int]) -> List[int]:
    return [item * 2 for item in items]

def merge_dicts(dict1: Dict[str, int], dict2: Dict[str, int]) -> Dict[str, int]:
    return {**dict1, **dict2}

# 선택적 매개변수
def find_user(user_id: int, full_info: Optional[bool] = None) -> Dict[str, Union[str, int]]:
    user = {"id": user_id, "name": "John Doe"}
    if full_info:
        user["email"] = "[email protected]"
    return user

# 함수 타입
def apply_transformation(items: List[int], transform: Callable[[int], int]) -> List[int]:
    return [transform(item) for item in items]

result = apply_transformation([1, 2, 3], lambda x: x * x)

from functools import partial

# 부분 적용
def multiply(a, b, c):
    return a * b * c

# 첫 번째 인자만 고정
double = partial(multiply, 2)
print(double(3, 4))  # 2 * 3 * 4 = 24

# 두 번째 인자까지 고정
double_triple = partial(multiply, 2, 3)
print(double_triple(4))  # 2 * 3 * 4 = 24

# 커링 직접 구현
def curry(func):
    def curried(*args, **kwargs):
        if len(args) + len(kwargs) >= func.__code__.co_argcount:
            return func(*args, **kwargs)
        return lambda *more_args, **more_kwargs: curried(*(args + more_args), **{**kwargs, **more_kwargs})
    return curried

@curry
def add3(a, b, c):
    return a + b + c

add1 = add3(1)
add1_2 = add1(2)
print(add1_2(3))  # 1 + 2 + 3 = 6
print(add3(1)(2)(3))  # 1 + 2 + 3 = 6
print(add3(1, 2, 3))  # 1 + 2 + 3 = 6

from contextlib import contextmanager
import time

# 컨텍스트 관리자 함수
@contextmanager
def timer():
    start = time.time()
    try:
        yield  # 이 지점에서 with 블록 내부 코드 실행
    finally:
        end = time.time()
        print(f"실행 시간: {end - start:.5f}초")

# 사용 예시
with timer():
    # 시간을 측정할 코드
    result = sum(i**2 for i in range(10000))

# 리소스 관리를 위한 컨텍스트 관리자
@contextmanager
def open_file(filename, mode='r'):
    try:
        f = open(filename, mode)
        yield f
    finally:
        f.close()

# 사용 예시
with open_file('example.txt', 'w') as f:
    f.write('Hello, World!')

import asyncio

# 비동기 함수 정의
async def fetch_data(url):
    print(f"{url} 데이터 요청 중...")
    await asyncio.sleep(1)  # 비동기 대기 (I/O 작업 시뮬레이션)
    return f"{url}의 데이터"

# 여러 비동기 작업 실행
async def fetch_all():
    urls = [
        "https://example.com/api/1",
        "https://example.com/api/2",
        "https://example.com/api/3"
    ]
    
    # 동시 실행
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    
    return results

# 비동기 메인 함수
async def main():
    results = await fetch_all()
    for result in results:
        print(result)

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

# 비동기 제너레이터
async def async_generator():
    for i in range(5):
        await asyncio.sleep(0.1)
        yield i

# 비동기 이터레이션
async def use_async_gen():
    async for value in async_generator():
        print(value)

import time
import functools

# 1. 메모이제이션(Memoization) - 재귀 함수 최적화
@functools.lru_cache(maxsize=None)
def fibonacci_memo(n):
    if n <= 1:
        return n
    return fibonacci_memo(n - 1) + fibonacci_memo(n - 2)

# 성능 비교
def fibonacci_normal(n):
    if n <= 1:
        return n
    return fibonacci_normal(n - 1) + fibonacci_normal(n - 2)

start = time.time()
fibonacci_normal(30)
print(f"일반 재귀: {time.time() - start:.5f}초")

start = time.time()
fibonacci_memo(30)
print(f"메모이제이션: {time.time() - start:.5f}초")

# 2. 제너레이터를 사용한 메모리 최적화
def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()
            
# 3. 지역 변수 최적화
def process_items_optimized(items):
    # 지역 변수에 함수 바인딩
    _len = len
    result = []
    _append = result.append
    
    for item in items:
        _append(_len(str(item)))
    
    return result

# 4. 인라인 함수 호출 최적화
def calculate_sum(numbers):
    # 함수 호출 대신 인라인 계산
    total = 0
    for num in numbers:
        total += num
    return total

# 객체 생성을 캡슐화하는 팩토리 함수
def create_person(name, age, profession=None):
    person = {
        'name': name,
        'age': age
    }
    
    if profession:
        person['profession'] = profession
        
    if age < 18:
        person['category'] = 'minor'
    else:
        person['category'] = 'adult'
        
    return person

# 사용 예시
student = create_person("Alice", 15)
developer = create_person("Bob", 28, "Software Developer")

# 다양한 전략 함수
def discount_regular(order_total):
    return order_total * 0.05  # 5% 할인

def discount_premium(order_total):
    return order_total * 0.1   # 10% 할인

def discount_vip(order_total):
    return max(order_total * 0.15, 100)  # 15% 할인, 최소 100

# 전략을 적용하는 함수
def apply_discount(order_total, customer_type):
    discount_strategies = {
        'regular': discount_regular,
        'premium': discount_premium,
        'vip': discount_vip
    }
    
    discount_func = discount_strategies.get(customer_type, lambda x: 0)
    return discount_func(order_total)

# 사용 예시
print(apply_discount(1000, 'regular'))  # 50
print(apply_discount(1000, 'vip'))      # 150

# 각 단계를 처리하는 함수들
def validate(data):
    if not isinstance(data, dict) or 'name' not in data:
        return None
    return data

def normalize(data):
    if data is None:
        return None
    
    result = data.copy()
    result['name'] = result['name'].strip().lower()
    return result

def process(data):
    if data is None:
        return None
    
    result = data.copy()
    result['processed'] = True
    return result

# 파이프라인 구현
def pipeline(*funcs):
    def pipe(data):
        result = data
        for func in funcs:
            result = func(result)
            if result is None:
                return None
        return result
    return pipe

# 사용 예시
process_data = pipeline(validate, normalize, process)
good_data = {'name': ' John Doe '}
bad_data = {'id': 123}

print(process_data(good_data))  # {'name': 'john doe', 'processed': True}
print(process_data(bad_data))   # None

class UserRepository:
    def __init__(self):
        self.users = {}
        self.next_id = 1
    
    # 명령 함수 (상태 변경)
    def add_user(self, name, email):
        user_id = self.next_id
        self.users[user_id] = {
            'id': user_id,
            'name': name,
            'email': email
        }
        self.next_id += 1
        return user_id
    
    def update_email(self, user_id, new_email):
        if user_id not in self.users:
            return False
        self.users[user_id]['email'] = new_email
        return True
    
    # 쿼리 함수 (상태 변경 없음)
    def get_user(self, user_id):
        return self.users.get(user_id)
    
    def find_by_email(self, email):
        for user in self.users.values():
            if user['email'] == email:
                return user
        return None

# 사용 예시
repo = UserRepository()
user_id = repo.add_user("John Doe", "[email protected]")
print(repo.get_user(user_id))
repo.update_email(user_id, "[email protected]")
print(repo.find_by_email("[email protected]"))