40. 깔끔하고 읽기 쉬운 코드 작성하기

# 경고: 나쁜 스타일 - 시연용으로만 사용
def c(l):
    t=0
    for i in l:
        t=t+i
    return t/len(l)
 
data=[85,92,78,90,88]
result=c(data)
print(result)  # Output: 86.6

def calculate_average(numbers):
    """숫자 리스트의 산술 평균을 계산합니다."""
    total = 0
    for number in numbers:
        total = total + number
    return total / len(numbers)
 
test_scores = [85, 92, 78, 90, 88]
average_score = calculate_average(test_scores)
print(average_score)  # Output: 86.6

# 디버그하기 어려움 - 이 변수들이 무엇을 나타내나?
# WARNING: Poor style - for demonstration only
def process(x, y):
    if x > y:
        return x * (1 - y)
    return x
 
result = process(100, 0.1)

# 디버그하기 쉬움 - 무슨 일이 일어나는지 명확
def apply_discount(price, discount_rate):
    """할인율(0.0 to 1.0) 적용 후 가격을 계산합니다."""
    discount_amount = price * discount_rate
    final_price = price - discount_amount
    return final_price
 
original_price = 100
discount = 0.1  # 10% 할인
final_price = apply_discount(original_price, discount)
print(f"Final price: ${final_price}")
# Output: Final price: $90.0

# 나쁜 이름 - 무엇을 의미하는지 불명확함
# 경고: 나쁜 스타일 - 시연용으로만 사용
# 'n'이 무엇인가? 숫자(number)? 이름(name)? 노드(node)?
# 'd'가 무엇인가? 날짜(date)? 거리(distance)? 기간(duration)?
# 'l'이 무엇인가? 숫자 1처럼 보임!
n = "Alice"
d = 25
l = [1, 2, 3]
calc = lambda x: x * 2
 
# 좋은 이름 - 명확하고 설명적임
student_name = "Alice"
age_in_years = 25
test_scores = [1, 2, 3]
double_value = lambda x: x * 2

# 허용 가능: 매우 짧고, 맥락이 명확
for i in range(10):
    print(i)
 
for x, y in coordinates:
    distance = (x**2 + y**2) ** 0.5
 
# 하지만 명확성을 위해 설명적 이름이 더 좋음
for student_index in range(len(students)):
    print(students[student_index])
 
for point_x, point_y in coordinates:
    distance = (point_x**2 + point_y**2) ** 0.5

# Variables
user_name = "Bob"
total_price = 99.99
is_valid = True
max_retry_count = 3
 
# Functions
def calculate_tax(amount, rate):
    """주어진 금액에 대한 세금을 계산합니다."""
    return amount * rate
 
def send_email_notification(recipient, message):
    """지정된 수신자에게 이메일을 보냅니다."""
    print(f"Sending to {recipient}: {message}")
 
# Using the functions
tax_amount = calculate_tax(100, 0.08)
send_email_notification("user@example.com", "Welcome!")

# Constants at module level
MAX_LOGIN_ATTEMPTS = 3
DEFAULT_TIMEOUT_SECONDS = 30
PI = 3.14159
DATABASE_URL = "postgresql://localhost/mydb"
 
def validate_password_length(password):
    """password가 최소 길이 요구사항을 만족하는지 확인합니다."""
    MIN_PASSWORD_LENGTH = 8  # 함수 내부의 상수
    return len(password) >= MIN_PASSWORD_LENGTH
 
# Using constants
if login_attempts > MAX_LOGIN_ATTEMPTS:
    print("Account locked")

# Python에는 상수 문법이 없음 - 이것은 그냥 일반 변수
MAX_LOGIN_ATTEMPTS = 3
 
# Python은 수정을 막지 않음
MAX_LOGIN_ATTEMPTS = 5  # ❌ 기술적으로 작동하지만, 규칙 위반
 
# 이름 짓기 규칙은 의도에 대한 신호:
# "대문자로 이름을 지어서 변경하지 않겠다는 의도를 보여줌"

# 이 값은 변경될 것 - 소문자 사용
max_login_attempts = 3
max_login_attempts = 5  # ✅ 괜찮음 - 이름이 변경 가능함을 나타냄
 
# 이 값은 절대 변경되지 않아야 함 - 대문자 사용
MAX_LOGIN_ATTEMPTS = 3
# 나중에 코드에서 재할당하지 마세요

# Class definitions
class Student:
    """이름과 성적을 가진 학생을 나타냅니다."""
    def __init__(self, name):
        self.name = name
        self.grades = []
 
class ShoppingCart:
    """쇼핑 카트의 아이템을 관리합니다."""
    def __init__(self):
        self.items = []
    
    def add_item(self, item):
        """카트에 아이템을 추가합니다."""
        self.items.append(item)
 
class DatabaseConnection:
    """데이터베이스 연결과 쿼리를 처리합니다."""
    def __init__(self, url):
        self.url = url
 
# Creating instances (note: instances use snake_case variable names)
student = Student("Alice")
shopping_cart = ShoppingCart()
db_connection = DatabaseConnection("localhost")

class BankAccount:
    """잔액 추적 기능이 있는 은행 계좌를 나타냅니다."""
    
    def __init__(self, account_number, initial_balance):
        self.account_number = account_number
        self._balance = initial_balance  # 내부 속성
    
    def deposit(self, amount):
        """계좌에 돈을 입금합니다."""
        if self._validate_amount(amount):  # 내부 메서드
            self._balance += amount
    
    def _validate_amount(self, amount):
        """거래 금액을 검증하는 내부 헬퍼입니다."""
        return amount > 0
    
    def get_balance(self):
        """현재 잔액을 반환합니다."""
        return self._balance
 
# Using the class
account = BankAccount("12345", 1000)
account.deposit(500)
print(account.get_balance())  # Output: 1500
 
# 기술적으로 작동하지만, 규칙 위반
print(account._balance)
# Output: 1500 (작동하지만, 이렇게 하면 안 됩니다!)
 
# 기술적으로 작동하지만, 규칙 위반
result = account._validate_amount(100)
# Output: True (작동하지만, 이렇게 하면 안 됩니다!)

class Point:
    """2차원 점을 나타냅니다."""
    
    def __init__(self, x, y):  # 특수 메서드: 초기화
        self.x = x
        self.y = y
    
    def __str__(self):  # 특수 메서드: 문자열 표현
        return f"Point({self.x}, {self.y})"
    
    def __add__(self, other):  # 특수 메서드: 덧셈 연산자
        return Point(self.x + other.x, self.y + other.y)
 
p1 = Point(1, 2)
p2 = Point(3, 4)
print(p1)  # Output: Point(1, 2)
print(p1 + p2)  # Output: Point(4, 6)

def calculate_grade(score):
    """숫자 점수로부터 문자 등급을 결정합니다."""
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    else:
        return "F"
 
# 중첩 들여쓰기: 레벨마다 공백 4칸
def process_students(students):
    """학생 레코드 리스트를 처리합니다."""
    for student in students:
        if student["active"]:
            grade = calculate_grade(student["score"])
            print(f"{student['name']}: {grade}")
 
students = [
    {"name": "Alice", "score": 92, "active": True},
    {"name": "Bob", "score": 78, "active": True}
]
process_students(students)
# Output:
# Alice: A
# Bob: C

# 너무 김 - 읽기 어려움
# 경고: 나쁜 스타일 - 시연용으로만 사용
def calculate_monthly_payment(principal, annual_rate, years):
    return principal * (annual_rate / 12) * (1 + annual_rate / 12) ** (years * 12) / ((1 + annual_rate / 12) ** (years * 12) - 1)
 
# 더 나음 - 읽기 쉬운 줄로 분리
def calculate_monthly_payment(principal, annual_rate, years):
    """상환 공식(amortization formula)을 사용해 월 상환금을 계산합니다."""
    monthly_rate = annual_rate / 12
    num_payments = years * 12
    
    numerator = principal * monthly_rate * (1 + monthly_rate) ** num_payments
    denominator = (1 + monthly_rate) ** num_payments - 1
    
    return numerator / denominator
 
payment = calculate_monthly_payment(200000, 0.045, 30)
print(f"Monthly payment: ${payment:.2f}")  # Output: Monthly payment: $1013.37

# 긴 함수 호출
result = some_function(
    first_argument,
    second_argument,
    third_argument,
    fourth_argument
)
 
# 긴 리스트
colors = [
    "red", "green", "blue",
    "yellow", "orange", "purple",
    "pink", "brown", "gray"
]
 
# 긴 문자열
message = (
    "This is a very long message that needs to be broken "
    "across multiple lines for readability. Python automatically "
    "concatenates adjacent string literals."
)
print(message)
# Output: This is a very long message that needs to be broken across multiple lines for readability. Python automatically concatenates adjacent string literals.

# 나쁜 공백 - 답답하고 읽기 어려움
# 경고: 나쁜 스타일 - 시연용으로만 사용
x=5
y=x*2+3
result=calculate_tax(100,0.08)
data=[1,2,3,4,5]
 
# 좋은 공백 - 명확하고 읽기 쉬움
x = 5
y = x * 2 + 3
result = calculate_tax(100, 0.08)
data = [1, 2, 3, 4, 5]
 
# 표현식에서의 공백
total = (price * quantity) + shipping_cost
is_valid = (age >= 18) and (has_license == True)
 
# 함수 정의에서의 공백
def calculate_discount(price, discount_rate, minimum_purchase=0):
    """최소 구매 금액을 만족하면 할인된 가격을 계산합니다."""
    if price >= minimum_purchase:
        return price * (1 - discount_rate)
    return price

# 키워드 인자의 올바른 공백
result = calculate_discount(price=100, discount_rate=0.1, minimum_purchase=50)
 
# 기본 매개변수의 올바른 공백
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

def first_function():
    """첫 번째 함수."""
    pass
 
 
def second_function():
    """두 번째 함수."""
    pass
 
 
class MyClass:
    """클래스 정의."""
    pass

class Student:
    """성적을 가진 학생을 나타냅니다."""
    
    def __init__(self, name):
        self.name = name
        self.grades = []
    
    def add_grade(self, grade):
        """학생 기록에 성적을 추가합니다."""
        self.grades.append(grade)
    
    def get_average(self):
        """학생의 평균 성적을 계산합니다."""
        if not self.grades:
            return 0
        return sum(self.grades) / len(self.grades)

def process_order(order_items, customer):
    """고객 주문을 처리하고 총액을 계산합니다."""
    
    # 소계 계산
    subtotal = 0
    for item in order_items:
        subtotal += item["price"] * item["quantity"]
    
    # 고객 할인 적용
    discount = 0
    if customer["is_premium"]:
        discount = subtotal * 0.1
    
    # 세금 계산
    tax = (subtotal - discount) * 0.08
    
    # 최종 합계 계산
    total = subtotal - discount + tax
    
    return {
        "subtotal": subtotal,
        "discount": discount,
        "tax": tax,
        "total": total
    }

# 나쁨 - 보이지 않는 줄 끝 공백(설명을 위해 ·로 표시)
# 경고: 나쁜 스타일 - 시연용으로만 사용
def calculate(x):···
    return x * 2···
 
# 좋음 - 줄 끝 공백 없음
def calculate(x):
    return x * 2

# 나쁜 주석 - 뻔한 내용을 말함
# 경고: 나쁜 스타일 - 시연용으로만 사용
x = x + 1  # x에 1을 더함
 
# 좋은 주석 - 이유를 설명함
x = x + 1  # 0부터 시작하는 인덱싱에 맞추기 위해 조정
 
# 나쁜 주석 - 코드와 중복됨
# 경고: 나쁜 스타일 - 시연용으로만 사용
# age가 18보다 크거나 같은지 확인
if age >= 18:
    print("Adult")
 
# 좋은 주석 - 비즈니스 로직을 설명함
# 미국의 법적 음주 가능 연령
if age >= 21:
    print("Can purchase alcohol")

def binary_search(sorted_list, target):
    """이진 탐색을 사용해 정렬된 리스트에서 target을 찾습니다."""
    left = 0
    right = len(sorted_list) - 1
    
    while left <= right:
        # 정수 오버플로를 피하면서 중간 지점을 계산
        # (right + left) // 2는 인덱스가 매우 클 때 오버플로가 날 수 있음
        mid = left + (right - left) // 2
        
        if sorted_list[mid] == target:
            return mid
        elif sorted_list[mid] < target:
            left = mid + 1  # target은 오른쪽 절반에 있음
        else:
            right = mid - 1  # target은 왼쪽 절반에 있음
    
    return -1  # target을 찾지 못함

def calculate_shipping_cost(weight, distance):
    """무게와 거리를 기반으로 배송 비용을 계산합니다."""
    base_cost = 5.00
    
    # 무거운 물품에 대한 무료 배송 프로모션 (2024년 기준 회사 정책)
    # 대량 주문을 장려하고 단위당 배송 비용을 줄이기 위함
    if weight > 50:
        return 0
    
    # 표준 요금: 파운드당 $0.50 + 마일당 $0.10
    # 2024년 1분기에 협상된 운송업체 계약 기반
    return base_cost + (weight * 0.50) + (distance * 0.10)

def process_data(data):
    """들어오는 데이터 레코드를 처리합니다."""
    # TODO: 잘못된 형식의 레코드에 대한 임시 수정입니다
    # 상위에서 데이터 검증이 구현되면 제거하세요
    if not isinstance(data, list):
        data = [data]
    
    for record in data:
        # 각 레코드를 처리
        pass

def calculate_bmi(weight_kg, height_m):
    """
    체질량지수(BMI)를 계산합니다.
    
    BMI는 킬로그램 단위의 체중을 미터 단위 키의 제곱으로 나누어 계산합니다.
    
    Args:
        weight_kg: 체중(킬로그램, float 또는 int)
        height_m: 키(미터, float 또는 int)
    
    Returns:
        float: 계산된 BMI 값
    
    Example:
        >>> calculate_bmi(70, 1.75)
        22.857142857142858
    """
    return weight_kg / (height_m ** 2)
 
# 독스트링 접근하기
print(calculate_bmi.__doc__)
# Output:
#     체질량지수(BMI)를 계산합니다.
#     
#     BMI는 킬로그램 단위의 체중을 미터 단위 키의 제곱으로 나누어 계산합니다.
#     ...

def square(x):
    """x의 제곱을 반환합니다."""
    return x * x
 
def is_even(n):
    """n이 짝수면 True, 아니면 False를 반환합니다."""
    return n % 2 == 0

def find_prime_factors(n):
    """
    양의 정수의 모든 소인수를 찾습니다.
    
    이 함수는 곱하면 입력값이 되는 소수들의 리스트를 반환합니다.
    인수는 오름차순으로 반환됩니다.
    
    Args:
        n: 1보다 큰 양의 정수
    
    Returns:
        list: 오름차순의 소인수
    
    Raises:
        ValueError: n이 2보다 작을 때
    
    Example:
        >>> find_prime_factors(12)
        [2, 2, 3]
        >>> find_prime_factors(17)
        [17]
    """
    if n < 2:
        raise ValueError("n must be at least 2")
    
    factors = []
    divisor = 2
    
    while n > 1:
        while n % divisor == 0:
            factors.append(divisor)
            n = n // divisor
        divisor += 1
    
    return factors

class BankAccount:
    """
    입금 및 출금 작업을 지원하는 은행 계좌를 나타냅니다.
    
    이 클래스는 계좌 잔액을 유지하고 입금 및 출금 메서드를 제공합니다.
    모든 거래는 음수 잔액을 방지하기 위해 검증됩니다.
    
    Attributes:
        account_number: 계좌의 고유 식별자
        balance: 달러 기준 현재 계좌 잔액
    """
    
    def __init__(self, account_number, initial_balance=0):
        """
        새 은행 계좌를 초기화합니다.
        
        Args:
            account_number: 고유 계좌 식별자(문자열)
            initial_balance: 시작 잔액(기본값: 0)
        """
        self.account_number = account_number
        self.balance = initial_balance
    
    def deposit(self, amount):
        """
        계좌에 돈을 추가합니다.
        
        Args:
            amount: 입금할 금액(양수여야 함)
        
        Raises:
            ValueError: amount가 양수가 아닐 때
        """
        if amount <= 0:
            raise ValueError("Deposit amount must be positive")
        self.balance += amount

def calculate_compound_interest(principal, rate, time, compounds_per_year=1):
    """
    투자에 대한 복리 이자를 계산합니다.
    
    복리 공식 A = P(1 + r/n)^(nt)를 사용합니다.
    여기서 A는 최종 금액, P는 원금, r은 연 이자율,
    n은 연 복리 횟수, t는 연 단위 기간입니다.
    
    Args:
        principal: 초기 투자 금액(float)
        rate: 소수로 표현한 연 이자율(예: 5%는 0.05)
        time: 투자 기간(년 단위, float)
        compounds_per_year: 연간 복리 계산 횟수
                           (기본값: 연 1회 복리)
    
    Returns:
        float: 복리 이자 적용 후 최종 금액
    
    Example:
        >>> calculate_compound_interest(1000, 0.05, 10, 12)
        1647.0095
    """
    return principal * (1 + rate / compounds_per_year) ** (compounds_per_year * time)

def process_payment(amount, payment_method):
    """결제 트랜잭션을 처리합니다."""
    # TODO: 암호화폐 결제 지원 추가
    # TODO: 사기 탐지 검사 구현
    
    if payment_method == "credit_card":
        return process_credit_card(amount)
    elif payment_method == "paypal":
        return process_paypal(amount)
    else:
        raise ValueError(f"Unsupported payment method: {payment_method}")

"""
student_manager.py
 
성적 및 GPA 계산을 포함한 학생 기록을 관리합니다.
 
이 모듈은 학생 추가, 성적 기록,
평점 평균 계산을 위한 함수를 제공합니다.
"""
 
# 표준 라이브러리 import
import sys
from datetime import datetime
 
# 서드파티 import(있다면)
# import requests
 
# 로컬 import(있다면)
# from .database import save_student
 
# 상수
MAX_GRADE = 100
MIN_GRADE = 0
PASSING_GRADE = 60
 
# 함수
def calculate_gpa(grades):
    """
    숫자 성적 리스트에서 GPA를 계산합니다.
    
    Args:
        grades: 숫자 성적 리스트(0-100)
    
    Returns:
        float: 4.0 스케일의 GPA
    """
    if not grades:
        return 0.0
    
    average = sum(grades) / len(grades)
    
    # 4.0 스케일로 변환
    if average >= 90:
        return 4.0
    elif average >= 80:
        return 3.0
    elif average >= 70:
        return 2.0
    elif average >= 60:
        return 1.0
    else:
        return 0.0
 
def validate_grade(grade):
    """
    grade가 유효 범위 내에 있는지 확인합니다.
    
    Args:
        grade: 검증할 숫자 성적
    
    Returns:
        bool: grade가 유효하면 True, 아니면 False
    """
    return MIN_GRADE <= grade <= MAX_GRADE
 
# Main execution
if __name__ == "__main__":
    # 스크립트가 직접 실행될 때 동작하는 코드
    test_grades = [85, 92, 78, 88]
    gpa = calculate_gpa(test_grades)
    print(f"GPA: {gpa}")  # Output: GPA: 3.0

# 표준 라이브러리 import
import os
import sys
from datetime import datetime, timedelta
from pathlib import Path
 
# 서드파티 import
import requests
from flask import Flask, render_template
 
# 로컬 애플리케이션 import
from myapp.database import connect_db
from myapp.models import User, Product
from myapp.utils import format_currency

# 모듈 전체 import
import math
result = math.sqrt(16)  # Output: 4.0
 
# 특정 항목 import
from math import sqrt, pi
result = sqrt(16)  # Output: 4.0
 
# 별칭(alias)으로 import
import numpy as np
array = np.array([1, 2, 3])
 
# 여러 항목 import
from os import path, getcwd, listdir

# 나쁨 - sqrt가 어디서 왔는지 불명확함
# 경고: 나쁜 스타일 - 시연용으로만 사용
from math import *
result = sqrt(16)
 
# 좋음 - 명시적 import
from math import sqrt
result = sqrt(16)

"""애플리케이션의 설정 값."""
 
import os
 
# 애플리케이션 상수
APP_NAME = "Student Manager"
VERSION = "1.0.0"
DEBUG_MODE = True
 
# 데이터베이스 설정
DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///students.db")
MAX_CONNECTIONS = 10
 
# 비즈니스 규칙
MAX_STUDENTS_PER_CLASS = 30
PASSING_GRADE = 60
GRADE_WEIGHTS = {
    "homework": 0.3,
    "midterm": 0.3,
    "final": 0.4
}
 
def calculate_final_grade(homework, midterm, final):
    """가중치를 적용한 최종 성적을 계산합니다."""
    return (
        homework * GRADE_WEIGHTS["homework"] +
        midterm * GRADE_WEIGHTS["midterm"] +
        final * GRADE_WEIGHTS["final"]
    )

"""주문 처리 모듈."""
 
# Public API functions
def process_order(order_items, customer):
    """
    고객 주문을 처리합니다.
    
    주문 처리를 위한 메인 엔트리 포인트입니다.
    """
    subtotal = _calculate_subtotal(order_items)
    discount = _calculate_discount(subtotal, customer)
    tax = _calculate_tax(subtotal - discount)
    total = subtotal - discount + tax
    
    return {
        "subtotal": subtotal,
        "discount": discount,
        "tax": tax,
        "total": total
    }
 
def validate_order(order_items):
    """주문이 유효한 아이템을 포함하는지 검증합니다."""
    if not order_items:
        return False
    
    for item in order_items:
        if not _validate_item(item):
            return False
    
    return True
 
# Internal helper functions
def _calculate_subtotal(items):
    """주문 소계를 계산합니다(내부 사용)."""
    total = 0
    for item in items:
        total += item["price"] * item["quantity"]
    return total
 
def _calculate_discount(subtotal, customer):
    """고객 할인을 계산합니다(내부 사용)."""
    if customer.get("is_premium"):
        return subtotal * 0.1
    return 0
 
def _calculate_tax(amount):
    """판매세를 계산합니다(내부 사용)."""
    TAX_RATE = 0.08
    return amount * TAX_RATE
 
def _validate_item(item):
    """단일 주문 아이템을 검증합니다(내부 사용)."""
    required_fields = ["name", "price", "quantity"]
    return all(field in item for field in required_fields)

"""사용자 관리 시스템."""
 
# 상수
DEFAULT_ROLE = "user"
ADMIN_ROLE = "admin"
 
# 기본 클래스는 먼저
class User:
    """기본 사용자 클래스."""
    
    def __init__(self, username, email):
        self.username = username
        self.email = email
        self.role = DEFAULT_ROLE
    
    def can_edit(self, resource):
        """사용자가 리소스를 편집할 수 있는지 확인합니다."""
        return resource.owner == self.username
 
# 파생 클래스는 기본 클래스 뒤에
class AdminUser(User):
    """권한이 강화된 관리자."""
    
    def __init__(self, username, email):
        super().__init__(username, email)
        self.role = ADMIN_ROLE
    
    def can_edit(self, resource):
        """관리자는 어떤 리소스든 편집할 수 있습니다."""
        return True
 
# 관련 클래스는 함께 그룹화
class Resource:
    """소유 및 편집될 수 있는 리소스를 나타냅니다."""
    
    def __init__(self, name, owner):
        self.name = name
        self.owner = owner
 
# 클래스와 관련된 유틸리티 함수
def create_user(username, email, is_admin=False):
    """적절한 사용자 타입을 생성하는 팩토리 함수입니다."""
    if is_admin:
        return AdminUser(username, email)
    return User(username, email)

"""math_utils.py - 수학 유틸리티 함수."""
 
def add(a, b):
    """두 수를 더합니다."""
    return a + b
 
def multiply(a, b):
    """두 수를 곱합니다."""
    return a * b
 
# 이 코드는 파일이 직접 실행될 때만 실행됩니다
if __name__ == "__main__":
    # 함수 테스트
    print(f"5 + 3 = {add(5, 3)}")  # Output: 5 + 3 = 8
    print(f"5 * 3 = {multiply(5, 3)}")  # Output: 5 * 3 = 15

# another_file.py
from math_utils import add, multiply
 
result = add(10, 20)
print(result)  # Output: 30
# math_utils.py의 테스트 코드는 실행되지 않습니다

"""temperature.py - 온도 변환 유틸리티."""
 
def celsius_to_fahrenheit(celsius):
    """섭씨를 화씨로 변환합니다."""
    return (celsius * 9/5) + 32
 
def fahrenheit_to_celsius(fahrenheit):
    """화씨를 섭씨로 변환합니다."""
    return (fahrenheit - 32) * 5/9
 
if __name__ == "__main__":
    # 함수 시연
    print("Temperature Conversion Examples:")
    print(f"0°C = {celsius_to_fahrenheit(0)}°F")  # Output: 0°C = 32.0°F
    print(f"100°C = {celsius_to_fahrenheit(100)}°F")  # Output: 100°C = 212.0°F
    print(f"32°F = {fahrenheit_to_celsius(32)}°C")  # Output: 32°F = 0.0°C

"""data_processor.py - 데이터 파일을 처리하고 분석합니다."""
 
import sys
 
def load_data(filename):
    """파일에서 데이터를 로드합니다."""
    with open(filename) as f:
        return [line.strip() for line in f]
 
def analyze_data(data):
    """데이터에 대한 분석을 수행합니다."""
    return {
        "count": len(data),
        "average_length": sum(len(item) for item in data) / len(data)
    }
 
if __name__ == "__main__":
    # 스크립트로 실행될 때는 커맨드라인 인자를 처리합니다
    if len(sys.argv) < 2:
        print("Usage: python data_processor.py <filename>")
        sys.exit(1)
    
    filename = sys.argv[1]
    data = load_data(filename)
    results = analyze_data(data)
    
    print(f"Processed {results['count']} items")
    print(f"Average length: {results['average_length']:.2f}")

$ python data_processor.py data.txt
Processed 42 items
Average length: 15.23

# my_analysis.py
from data_processor import load_data, analyze_data
 
my_data = load_data("myfile.txt")
results = analyze_data(my_data)
print(f"Found {results['count']} items")

"""calculator.py - 기본 계산기 연산."""
 
def add(a, b):
    """두 수를 더합니다."""
    return a + b
 
def subtract(a, b):
    """b를 a에서 뺍니다."""
    return a - b
 
if __name__ == "__main__":
    # 빠른 테스트
    assert add(2, 3) == 5
    assert subtract(10, 4) == 6
    print("All tests passed!")  # Output: All tests passed!

"""report_generator.py - 데이터로부터 보고서를 생성합니다."""
 
import sys
 
def load_data(filename):
    """파일에서 데이터를 로드합니다."""
    # Implementation here
    pass
 
def generate_report(data):
    """데이터로부터 보고서를 생성합니다."""
    # Implementation here
    pass
 
def save_report(report, output_file):
    """보고서를 파일로 저장합니다."""
    # Implementation here
    pass
 
def main():
    """스크립트의 메인 엔트리 포인트입니다."""
    if len(sys.argv) < 3:
        print("Usage: python report_generator.py <input> <output>")
        return 1
    
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    
    try:
        data = load_data(input_file)
        report = generate_report(data)
        save_report(report, output_file)
        print(f"Report saved to {output_file}")
        return 0
    except Exception as e:
        print(f"Error: {e}")
        return 1
 
if __name__ == "__main__":
    # main의 상태 코드로 종료 (0 = 성공, 1 = 오류)
    sys.exit(main())

# 나쁨 - 메인 블록에 복잡한 로직
# 경고: 나쁜 스타일 - 시연용으로만 사용
if __name__ == "__main__":
    data = []
    for i in range(100):
        if i % 2 == 0:
            data.append(i * 2)
    result = sum(data) / len(data)
    print(result)
 
# 좋음 - 로직은 함수에, 메인 블록은 조율만
def generate_even_doubles(limit):
    """limit까지의 짝수를 두 배한 값을 생성합니다."""
    return [i * 2 for i in range(limit) if i % 2 == 0]
 
def calculate_average(numbers):
    """numbers의 평균을 계산합니다."""
    return sum(numbers) / len(numbers)
 
if __name__ == "__main__":
    data = generate_even_doubles(100)
    result = calculate_average(data)
    print(result)  # Output: 99.0

"""
file_processor.py - 다양한 작업으로 텍스트 파일을 처리합니다.
 
Usage:
    python file_processor.py <input_file> <output_file> [--uppercase]
 
Arguments:
    input_file: 입력 파일 경로
    output_file: 출력 파일 경로
    --uppercase: 텍스트를 대문자로 변환(선택)
"""
 
import sys
 
def process_file(input_path, output_path, uppercase=False):
    """지정된 옵션으로 파일을 처리합니다."""
    with open(input_path) as f:
        content = f.read()
    
    if uppercase:
        content = content.upper()
    
    with open(output_path, 'w') as f:
        f.write(content)
 
if __name__ == "__main__":
    if len(sys.argv) < 3:
        print(__doc__)  # 모듈 독스트링 출력
        sys.exit(1)
    
    input_file = sys.argv[1]
    output_file = sys.argv[2]
    uppercase = "--uppercase" in sys.argv
    
    process_file(input_file, output_file, uppercase)
    print(f"Processed {input_file} -> {output_file}")