42. 타입 힌트(type hints) 친절한 입문 (선택)

# 대규모 코드베이스에서, 이 함수는 무엇을 기대하고 무엇을 반환할까?
def calculate_discount(customer, items, code):
    # ... 50 lines of code ...
    return result

# 타입 힌트 없이
def add(a, b):
    return a + b
 
# 타입 힌트와 함께
def add(a: int, b: int) -> int:
    return a + b

def calculate_discount(customer: dict, items: list, code: str) -> float:
    # ... 50줄의 코드 ...
    return result

def greet(name: str) -> str:
    return f"Hello, {name}!"
 
# 42는 문자열이 아닌데도 잘 작동합니다
result = greet(42)
print(result)  # 출력: Hello, 42!

def calculate_total(prices: list) -> float:
    """가격들의 합계를 계산합니다."""
    return sum(prices)
 
# 이건 잘 작동합니다
print(calculate_total([10.99, 5.50, 3.25]))  # 출력: 19.74
 
# 하지만 이건 런타임에 실패합니다!
print(calculate_total("not a list"))  # TypeError: 'str' object is not iterable

def add_numbers(a: int, b: int) -> int:
    """두 숫자를 더합니다."""
    return a + b
 
# IDE가 여기서 경고를 보여줍니다 (코드를 실행하기 전에)
result = add_numbers("Hello", "World")  # IDE: 경고 - int를 기대했는데 str을 받음

def process(data: list) -> list:
    return [x * 2 for x in data]
 
# 실수로 문자열을 전달하면:
process("hello")  # IDE 경고: list를 기대했는데 str을 받음
# 코드를 실행하기 전에 고칩니다!

def add_numbers(a: int, b: int) -> int:
    return a + b
 
# 타입이 맞지 않아도 Python은 실행합니다
print(add_numbers(5.5, 3.2))        # 출력: 8.7 (작동합니다!)
print(add_numbers("Hi", " there"))  # 출력: Hi there (이것도 작동합니다!)

def greet(name: str):
    """이름으로 사람을 맞이합니다."""
    return f"Hello, {name}!"
 
# 사용법
message = greet("Alice")
print(message)  # 출력: Hello, Alice!

def calculate_area(width: float, height: float):
    """직사각형의 넓이를 계산합니다."""
    return width * height
 
# 사용법
area = calculate_area(5.0, 3.0)
print(area)  # 출력: 15.0

def get_full_name(first: str, last: str) -> str:
    """이름과 성을 합칩니다."""
    return f"{first} {last}"
 
# 사용법
name = get_full_name("John", "Doe")
print(name)  # 출력: John Doe

def is_adult(age: int) -> bool:
    """누군가가 성인(18세 이상)인지 확인합니다."""
    return age >= 18
 
# 사용법
adult = is_adult(25)
print(adult)  # 출력: True

def calculate_discount(price: float, discount_percent: float) -> float:
    """할인된 가격을 계산합니다."""
    discount_amount = price * (discount_percent / 100)
    return price - discount_amount
 
# 사용법
original_price = 100.0
discount = 20.0
final_price = calculate_discount(original_price, discount)
print(f"최종 가격: ${final_price:.2f}")  # 출력: 최종 가격: $80.00

def repeat_message(message: str, times: int) -> str:
    """메시지를 지정된 횟수만큼 반복합니다."""
    return message * times
 
# 사용법
repeated = repeat_message("Hello! ", 3)
print(repeated)  # 출력: Hello! Hello! Hello! 

def create_greeting(name: str, formal: bool = False) -> str:
    """인사 메시지를 생성합니다."""
    if formal:
        return f"Good day, {name}."
    return f"Hi, {name}!"
 
# 사용법
print(create_greeting("Alice"))              # 출력: Hi, Alice!
print(create_greeting("Bob", formal=True))   # 출력: Good day, Bob.

def format_price(amount: float, currency: str = "USD", decimals: int = 2) -> str:
    """통화 기호와 함께 가격을 포맷팅합니다."""
    if currency == "USD":
        symbol = "$"
    elif currency == "EUR":
        symbol = "€"
    else:
        symbol = currency
    
    return f"{symbol}{amount:.{decimals}f}"
 
# 사용법
print(format_price(99.99))                          # 출력: $99.99
print(format_price(99.99, "EUR"))                   # 출력: €99.99
print(format_price(99.995, "USD", 3))               # 출력: $99.995

def print_report(title: str, data: list) -> None:
    """포맷팅된 리포트를 출력합니다."""
    print(f"=== {title} ===")
    for item in data:
        print(f"  - {item}")
    # return 문이 없으므로 암묵적으로 None을 반환
 
# 사용법
print_report("Sales Data", [100, 150, 200])

=== Sales Data ===
  - 100
  - 150
  - 200

# 변수 어노테이션
name: str = "Alice"
age: int = 30
height: float = 5.7
is_student: bool = True
 
print(f"{name} is {age} years old")  # 출력: Alice is 30 years old

# 이런 어노테이션은 불필요합니다
name: str = "Alice"  # 명백히 문자열
count: int = 0  # 명백히 정수
prices: list = [10.99, 5.50]  # 명백히 리스트
settings: dict = {}  # 명백히 딕셔너리
 
# 그냥 이렇게 쓰세요
name = "Alice"
count = 0
prices = [10.99, 5.50]
settings = {}

def calculate_statistics(numbers: list) -> dict:
    """숫자 리스트의 기본 통계를 계산합니다."""
    # 사용하기 전에 변수 선언
    total: float
    count: int
    average: float
    
    # 이제 값 할당
    total = sum(numbers)
    count = len(numbers)
    average = total / count if count > 0 else 0.0
    
    return {
        "total": total,
        "count": count,
        "average": average
    }
 
# 사용법
result = calculate_statistics([10, 20, 30, 40])
print(f"Average: {result['average']}")  # 출력: Average: 25.0

# 문자열로 시작
value: str = "hello"
print(value)  # 출력: hello
 
# 다른 타입으로 재할당 - Python은 허용합니다
value = 42
print(value)  # 출력: 42
 
# 또 다른 타입 변경 - 여전히 허용됩니다
value = [1, 2, 3]
print(value)  # 출력: [1, 2, 3]

def find_user_by_email(email: str) -> dict:
    """이메일 주소로 사용자를 찾습니다."""
    users = [
        {"name": "Alice", "email": "alice@example.com"},
        {"name": "Bob", "email": "bob@example.com"}
    ]
    
    for user in users:
        if user["email"] == email:
            return user
    
    return None  # 타입 불일치! -> dict 힌트와 모순됩니다
 
# 사용법
user = find_user_by_email("alice@example.com")
if user:
    print(f"Found: {user['name']}")  # 출력: Found: Alice
else:
    print("User not found")

def find_user_by_email(email: str) -> dict | None:
    """이메일 주소로 사용자를 찾습니다. 찾지 못하면 None을 반환합니다."""
    users = [
        {"name": "Alice", "email": "alice@example.com"},
        {"name": "Bob", "email": "bob@example.com"}
    ]
    
    for user in users:
        if user["email"] == email:
            return user
    
    return None
 
# 사용법
user = find_user_by_email("alice@example.com")
if user:
    print(f"Found: {user['name']}")  # 출력: Found: Alice
 
missing = find_user_by_email("charlie@example.com")
if missing is None:
    print("User not found")  # 출력: User not found

def parse_value(text: str) -> int | float | None:
    """문자열을 숫자로 파싱합니다. 파싱이 실패하면 None을 반환합니다."""
    try:
        # 먼저 정수로 파싱 시도
        if '.' not in text:
            return int(text)
        # 그렇지 않으면 실수로 파싱
        return float(text)
    except ValueError:
        return None
 
# 사용법
print(parse_value("42"))      # 출력: 42 (int)
print(parse_value("3.14"))    # 출력: 3.14 (float)
print(parse_value("invalid")) # 출력: None

def get_user_age(user_id: int) -> int | None:
    """사용자의 나이를 가져옵니다. 사용자를 찾지 못하면 None을 반환합니다."""
    users = {1: 25, 2: 30, 3: 35}
    return users.get(user_id)
 
# 값을 사용하기 전에 항상 None 확인
age = get_user_age(1)
if age is not None:
    print(f"User is {age} years old")  # 출력: User is 25 years old
    if age >= 18:
        print("User is an adult")  # 출력: User is an adult
else:
    print("User not found")
 
# 존재하지 않는 사용자의 경우
age = get_user_age(999)
if age is None:
    print("User not found")  # 출력: User not found

def format_name(first: str, middle: str | None = None, last: str = "") -> str:
    """전체 이름을 포맷팅합니다. 중간 이름은 선택사항입니다."""
    if middle and last:
        return f"{first} {middle} {last}"
    elif last:
        return f"{first} {last}"
    return first
 
# 사용법
print(format_name("John", "Q", "Doe"))    # 출력: John Q Doe
print(format_name("Jane", None, "Smith")) # 출력: Jane Smith
print(format_name("Prince"))              # 출력: Prince

def print_items(items: list) -> None:
    """리스트의 모든 항목을 출력합니다."""
    for item in items:
        print(item)
 
def get_user_settings() -> dict:
    """사용자 설정을 딕셔너리로 가져옵니다."""
    return {"theme": "dark", "notifications": True}
 
def get_position() -> tuple:
    """x, y 위치를 가져옵니다."""
    return (10, 20)

def calculate_total(prices: list[float]) -> float:
    """모든 가격의 합계를 계산합니다."""
    return sum(prices)
 
# 사용법
total = calculate_total([10.99, 5.50, 3.25])
print(f"Total: ${total:.2f}")  # 출력: Total: $19.74

def format_names(names: list[str]) -> str:
    """이름 리스트를 쉼표로 구분된 문자열로 포맷팅합니다."""
    return ", ".join(names)
 
# 사용법
students = ["Alice", "Bob", "Charlie"]
print(format_names(students))  # 출력: Alice, Bob, Charlie

def get_student_grades() -> dict[str, int]:
    """학생 이름과 성적을 매핑한 딕셔너리를 가져옵니다."""
    return {
        "Alice": 95,
        "Bob": 87,
        "Charlie": 92
    }
 
# 사용법
grades = get_student_grades()
for name, grade in grades.items():
    print(f"{name}: {grade}")

Alice: 95
Bob: 87
Charlie: 92

def get_user_data(user_id: int) -> dict[str, str | int]:
    """사용자 데이터를 가져옵니다. 값은 문자열 또는 정수일 수 있습니다."""
    return {
        "name": "Alice",
        "email": "alice@example.com",
        "age": 30,
        "id": 12345
    }
 
# 사용법
user = get_user_data(1)
print(f"{user['name']} is {user['age']} years old")  # 출력: Alice is 30 years old

def get_user_info(user_id: int) -> tuple[str, int, bool]:
    """
    사용자 정보를 튜플로 가져옵니다.
    반환값: (이름, 나이, 활성 상태)
    """
    return ("Alice", 30, True)
 
# 사용법
name, age, active = get_user_info(1)
print(f"{name}, {age}, active: {active}")  # 출력: Alice, 30, active: True

# 고정 길이 튜플: 정확히 2개의 실수
def get_2d_point() -> tuple[float, float]:
    """2D 좌표 (x, y)를 가져옵니다."""
    return (10.5, 20.3)
 
# 가변 길이 튜플: 임의 개수의 실수
def get_coordinates() -> tuple[float, ...]:
    """좌표를 가져옵니다. 2D, 3D, 또는 어떤 차원이든 가능합니다."""
    return (10.5, 20.3, 15.7)  # 이 경우 3D
 
# 사용법
point = get_2d_point()
coords = get_coordinates()
print(f"2D point: {point}")       # 출력: 2D point: (10.5, 20.3)
print(f"Coordinates: {coords}")   # 출력: Coordinates: (10.5, 20.3, 15.7)

def get_scores_by_student() -> dict[str, list[int]]:
    """각 학생의 시험 점수를 가져옵니다."""
    return {
        "Alice": [95, 87, 92],
        "Bob": [88, 91, 85],
        "Charlie": [90, 88, 94]
    }
 
# 사용법
scores = get_scores_by_student()
for name, tests in scores.items():
    average = sum(tests) / len(tests)
    print(f"{name}: {average:.1f}")

Alice: 91.3
Bob: 88.0
Charlie: 90.7

def get_student_records() -> list[dict[str, str | int]]:
    """학생 레코드 리스트를 가져옵니다."""
    return [
        {"name": "Alice", "age": 20, "major": "CS"},
        {"name": "Bob", "age": 21, "major": "Math"},
        {"name": "Charlie", "age": 19, "major": "Physics"}
    ]
 
# 사용법
students = get_student_records()
for student in students:
    print(f"{student['name']}, {student['age']}, {student['major']}")

Alice, 20, CS
Bob, 21, Math
Charlie, 19, Physics