25. 예외를 우아하게 처리하기

try:
    # 예외를 발생시킬 수 있는 코드
    risky_operation()
except:
    # 어떤 예외든 발생하면 실행되는 코드
    print("Something went wrong!")

# 예외 처리 없이 - 프로그램이 크래시 남
user_input = "hello"
number = int(user_input)  # ValueError: invalid literal for int() with base 10: 'hello'
print("This line never executes")

# 예외 처리 포함 - 프로그램이 계속 진행됨
user_input = "hello"
 
try:
    number = int(user_input)
    print(f"You entered: {number}")
except:
    print("That's not a valid number!")
    number = 0  # 기본값 사용
 
print(f"Using number: {number}")

That's not a valid number!
Using number: 0

# 예외로 실행 흐름을 관찰하기
print("1. Starting program")
 
try:
    print("2. Entered try block")
    number = int("hello")  # 예외가 여기서 발생함
    print("3. After conversion")   # 이 줄은 절대 실행되지 않음
    result = number * 2            # 이 줄은 절대 실행되지 않음
    print("4. After calculation")  # 이 줄은 절대 실행되지 않음
except ValueError:
    print("5. In except block - handling the error")
 
print("6. After try-except block")

1. Starting program
2. Entered try block
5. In except block - handling the error
6. After try-except block

# 예외 처리를 사용한 안전한 나이 입력
print("Please enter your age:")
user_input = input()
 
try:
    age = int(user_input)
    print(f"You are {age} years old.")
    
    # 출생 연도 계산(현재 연도가 2024라고 가정)
    birth_year = 2024 - age
    print(f"You were born around {birth_year}.")
except:
    print("Invalid input! Age must be a number.")
    print("Using default age of 0.")
    age = 0

Please enter your age:
25
You are 25 years old.
You were born around 1999.

Please enter your age:
twenty-five
Invalid input! Age must be a number.
Using default age of 0.

# try 블록에 두 개의 작업
print("Enter a number:")
user_input = input()
 
try:
    number = int(user_input)      # 첫 번째 작업 - ValueError를 발생시킬 수 있음
    result = 100 / number          # 두 번째 작업 - ZeroDivisionError를 발생시킬 수 있음
    print(f"100 / {number} = {result}")
except:
    print("Something went wrong!")

# try 블록에 여러 작업
print("Enter two numbers to divide:")
numerator_input = input("Numerator: ")
denominator_input = input("Denominator: ")
 
try:
    numerator = int(numerator_input)      # ValueError를 발생시킬 수 있음
    denominator = int(denominator_input)  # ValueError를 발생시킬 수 있음
    result = numerator / denominator      # ZeroDivisionError를 발생시킬 수 있음
    print(f"{numerator} / {denominator} = {result}")
except:
    print("Something went wrong with the calculation!")
    print("Make sure you enter valid numbers and don't divide by zero.")

Enter two numbers to divide:
Numerator: 10
Denominator: 2
10 / 2 = 5.0

Enter two numbers to divide:
Numerator: 10
Denominator: zero
Something went wrong with the calculation!
Make sure you enter valid numbers and don't divide by zero.

Enter two numbers to divide:
Numerator: 10
Denominator: 0
Something went wrong with the calculation!
Make sure you enter valid numbers and don't divide by zero.

# bare except는 모든 것을 잡음 - 우리가 예상하지 못한 것까지
numbers = [10, 20, 30]
 
try:
    index = 5  # index가 범위를 벗어나면 IndexError를 기대함
    value = numbers[index]
    print(f"Value at index {index}: {value}")
except:
    print("Could not access the list element.")

# 코드에 오타가 있다면?
numbers = [10, 20, 30]
 
try:
    index = 2
    value = numbrs[index]  # 오타: 'numbers'가 아니라 'numbrs'
    print(f"Value at index {index}: {value}")
except:
    print("Could not access the list element.")

Could not access the list element.

# 특정 예외 타입을 잡기
user_input = "hello"
 
try:
    number = int(user_input)
    print(f"You entered: {number}")
except ValueError:
    print("That's not a valid number!")
    number = 0
 
print(f"Using number: {number}")

That's not a valid number!
Using number: 0

# 잘못된 예외 타입을 잡기
user_input = "hello"
 
try:
    number = int(user_input)  # 이것은 ValueError를 발생시킴
    print(f"You entered: {number}")
except TypeError:  # 하지만 TypeError를 잡고 있음!
    print("That's not a valid number!")
    number = 0
 
print(f"Using number: {number}")

Traceback (most recent call last):
  File "example.py", line 4, in <module>
    number = int(user_input)
ValueError: invalid literal for int() with base 10: 'hello'

# 예외 종류별로 다르게 처리하기
print("Enter two numbers to divide:")
numerator_input = input("Numerator: ")
denominator_input = input("Denominator: ")
 
try:
    numerator = int(numerator_input)
    denominator = int(denominator_input)
    result = numerator / denominator
    print(f"{numerator} / {denominator} = {result}")
except ValueError:
    print("Error: Both inputs must be valid integers.")
    print("You entered something that isn't a number.")
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
    print("The denominator must be a non-zero number.")

Enter two numbers to divide:
Numerator: 10
Denominator: abc
Error: Both inputs must be valid integers.
You entered something that isn't a number.

Enter two numbers to divide:
Numerator: 10
Denominator: 0
Error: Cannot divide by zero.
The denominator must be a non-zero number.

# 여러 예외 타입을 함께 잡기
print("Enter a number:")
user_input = input()
 
try:
    number = int(user_input)
    result = 100 / number
    print(f"100 divided by {number} is {result}")
except (ValueError, ZeroDivisionError):
    print("Invalid input or division by zero.")
    print("Please enter a non-zero number.")

Enter a number:
hello
Invalid input or division by zero.
Please enter a non-zero number.

Enter a number:
0
Invalid input or division by zero.
Please enter a non-zero number.

# 예외 객체 내용 살펴보기
try:
    number = int("hello")
except ValueError as error:
    print("Exception caught! Let's examine it:")
    print(f"Type: {type(error)}")
    print(f"String representation: {error}")
    print(f"Args tuple: {error.args}")

Exception caught! Let's examine it:
Type: <class 'ValueError'>
String representation: invalid literal for int() with base 10: 'hello'
Args tuple: ("invalid literal for int() with base 10: 'hello'",)

# 예외 타입마다 서로 다른 속성을 가짐
numbers = [10, 20, 30]
 
try:
    value = numbers[10]
except IndexError as error:
    print(f"IndexError message: {error}")
    print(f"Exception args: {error.args}")
 
# 이제 딕셔너리로 시도
grades = {"Alice": 95}
 
try:
    grade = grades["Bob"]
except KeyError as error:
    print(f"KeyError message: {error}")
    print(f"Missing key: {error.args[0]}")

IndexError message: list index out of range
Exception args: ('list index out of range',)
KeyError message: 'Bob'
Missing key: Bob

# 성공 시에만 실행되는 코드를 else로 처리하기
print("Enter a number:")
user_input = input()
 
try:
    number = int(user_input)
except ValueError:
    print("That's not a valid number!")
else:
    # int(user_input)가 성공했을 때만 실행됨
    print(f"Successfully converted: {number}")
    squared = number ** 2
    print(f"The square of {number} is {squared}")

Enter a number:
5
Successfully converted: 5
The square of 5 is 25

Enter a number:
hello
That's not a valid number!

# else가 예외 범위 측면에서 유용한 이유 시연
try:
    number_1 = int(input("Enter a number_1: "))
except ValueError:
    print("Invalid input!")
else:
    # 여기서 오류가 발생하면 위의 except에서 잡히지 않음
    # 이는 입력 오류와 처리 오류를 구분하는 데 도움이 됨
    number_2 = int(input("Enter a number_2: ")) # ValueError를 발생시킬 수 있음

# 정리를 위해 finally 사용하기
print("Enter a number:")
user_input = input()
 
try:
    number = int(user_input)
    result = 100 / number
    print(f"Result: {result}")
except ValueError:
    print("Invalid number!")
except ZeroDivisionError:
    print("Cannot divide by zero!")
finally:
    print("Calculation attempt completed.")

Enter a number:
5
Result: 20.0
Calculation attempt completed.

Enter a number:
hello
Invalid number!
Calculation attempt completed.

Enter a number:
0
Cannot divide by zero!
Calculation attempt completed.

# 완전한 예외 처리 구조
print("Enter a number to calculate its reciprocal:")
user_input = input()
 
try:
    # 위험한 작업들
    number = int(user_input)
    reciprocal = 1 / number
except ValueError:
    # 변환 오류 처리
    print("Error: Input must be a valid integer.")
except ZeroDivisionError:
    # 0으로 나누기 처리
    print("Error: Cannot calculate reciprocal of zero.")
else:
    # 성공했을 때만 실행되는 코드
    print(f"The reciprocal of {number} is {reciprocal}")
    print(f"Verification: {number} × {reciprocal} = {number * reciprocal}")
finally:
    # 항상 실행되는 정리 코드
    print("Reciprocal calculation completed.")

Enter a number to calculate its reciprocal:
4
The reciprocal of 4 is 0.25
Verification: 4 × 0.25 = 1.0
Reciprocal calculation completed.

Enter a number to calculate its reciprocal:
hello
Error: Input must be a valid integer.
Reciprocal calculation completed.

Enter a number to calculate its reciprocal:
0
Error: Cannot calculate reciprocal of zero.
Reciprocal calculation completed.

# 의도적으로 예외를 발생시키기
age = -5
 
if age < 0:
    raise ValueError("Age cannot be negative!")
 
print(f"Age: {age}")  # 이 줄은 절대 실행되지 않음

Traceback (most recent call last):
  File "example.py", line 5, in <module>
    raise ValueError("Age cannot be negative!")
ValueError: Age cannot be negative!

# 예외를 발생시켜 입력을 검증하는 함수
def calculate_discount(price, discount_percent):
    """Calculate discounted price.
    
    Args:
        price: Original price (must be positive)
        discount_percent: Discount percentage (must be 0-100)
    
    Returns:
        Discounted price
    
    Raises:
        ValueError: If inputs are invalid
    """
    if price < 0:
        raise ValueError("Price cannot be negative!")
    
    if discount_percent < 0 or discount_percent > 100:
        raise ValueError("Discount must be between 0 and 100!")
    
    discount_amount = price * (discount_percent / 100)
    return price - discount_amount
 
# Using the function
try:
    final_price = calculate_discount(100, 20)
    print(f"Final price: ${final_price}")
except ValueError as error:
    print(f"Error: {error}")

Final price: $80.0

# Invalid price
try:
    final_price = calculate_discount(-50, 20)
    print(f"Final price: ${final_price}")
except ValueError as error:
    print(f"Error: {error}")

Error: Price cannot be negative!

# Invalid discount
try:
    final_price = calculate_discount(100, 150)
    print(f"Final price: ${final_price}")
except ValueError as error:
    print(f"Error: {error}")

Error: Discount must be between 0 and 100!

# 적절한 예외 타입 사용하기
def get_student_grade(grades, student_name):
    """Get a student's grade from the grades dictionary.
    
    Args:
        grades: Dictionary mapping student names to grades
        student_name: Name of the student
    
    Returns:
        The student's grade
    
    Raises:
        TypeError: If grades is not a dictionary
        KeyError: If student_name is not in grades
        ValueError: If the grade is invalid
    """
    if not isinstance(grades, dict):
        raise TypeError("Grades must be a dictionary!")
    
    if student_name not in grades:
        raise KeyError(f"Student '{student_name}' not found!")
    
    grade = grades[student_name]
    
    if not (0 <= grade <= 100):
        raise ValueError(f"Invalid grade: {grade} (must be 0-100)")
    
    return grade
 
# Test with valid data
grades = {"Alice": 95, "Bob": 87, "Carol": 92}
 
try:
    grade = get_student_grade(grades, "Alice")
    print(f"Alice's grade: {grade}")
except (TypeError, KeyError, ValueError) as error:
    print(f"Error: {error}")

Alice's grade: 95

# Test with missing student
try:
    grade = get_student_grade(grades, "David")
    print(f"David's grade: {grade}")
except (TypeError, KeyError, ValueError) as error:
    print(f"Error: {error}")

Error: Student 'David' not found!

# Test with wrong type
try:
    grade = get_student_grade("not a dict", "Alice")
    print(f"Alice's grade: {grade}")
except (TypeError, KeyError, ValueError) as error:
    print(f"Error: {error}")

Error: Grades must be a dictionary!

# 로깅 후 예외를 다시 발생시키기
def divide_numbers(a, b):
    """Divide two numbers with error logging."""
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        print("ERROR LOG: Division by zero attempted")
        print(f"  Numerator: {a}, Denominator: {b}")
        raise  # 같은 예외를 다시 발생시킴
 
# Using the function
try:
    result = divide_numbers(10, 0)
    print(f"Result: {result}")
except ZeroDivisionError:
    print("Cannot divide by zero!")

ERROR LOG: Division by zero attempted
  Numerator: 10, Denominator: 0
Cannot divide by zero!

# 기존 예외로부터 새 예외를 발생시키기
def load_config(config_dict, key):
    """Load configuration value from dictionary."""
    try:
        config_value = config_dict[key]
        
        # 정수로 파싱 시도
        parsed_value = int(config_value)
        return parsed_value
        
    except KeyError as error:
        raise RuntimeError(f"Configuration key missing: {key}") from error
    except ValueError as error:
        raise RuntimeError(f"Invalid configuration format for {key}") from error
 
# Using the function
config = {"timeout": "30", "retries": "5"}
 
try:
    value = load_config(config, "timeout")
    print(f"Config value: {value}")
except RuntimeError as error:
    print(f"Configuration error: {error}")
    print(f"Original cause: {error.__cause__}")

Config value: 30

try:
    value = load_config(config, "missing_key")
    print(f"Config value: {value}")
except RuntimeError as error:
    print(f"Configuration error: {error}")
    print(f"Original cause: {error.__cause__}")

Configuration error: Configuration key missing: missing_key
Original cause: 'missing_key'