🐍 Python 기본 가이드

name = "AI DevOps"
score = 87
active = True

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "C"

for index in range(3):
    print(index, name, grade)

def format_user(name: str, score: int) -> str:
    return f"{name}: {score}점"

print(format_user(name, score))

users = [
    {"id": 1, "name": "Ada", "role": "admin"},
    {"id": 2, "name": "Linus", "role": "developer"},
    {"id": 3, "name": "Grace", "role": "developer"},
]

names = [user["name"] for user in users]
developers = [u for u in users if u["role"] == "developer"]
user_by_id = {user["id"]: user for user in users}
roles = {user["role"] for user in users}

print(names)
print(user_by_id[2]["name"])
print(sorted(roles))

# list/dict/set 컴프리헨션 — 즉시 전체를 메모리에 생성
squares = [n * n for n in range(10)]
even_squares = {n: n * n for n in range(10) if n % 2 == 0}

# 제너레이터 함수 — yield를 만날 때마다 하나씩 반환하고 멈춤
def read_large_file(path: str):
    with open(path, encoding="utf-8") as f:
        for line in f:
            yield line.strip()

# 제너레이터 표현식 — []대신 ()를 쓰면 지연 생성
total = sum(n * n for n in range(1_000_000))  # 리스트를 만들지 않고 즉시 합산

# itertools로 무한/대용량 스트림 다루기
from itertools import islice

def counter():
    n = 0
    while True:
        yield n
        n += 1

first_five = list(islice(counter(), 5))
print(first_five)

from dataclasses import dataclass

@dataclass
class Order:
    id: int
    amount: float
    paid: bool = False

def total_paid(orders: list[Order]) -> float:
    return sum(order.amount for order in orders if order.paid)

def normalize_name(value: str) -> str:
    return value.strip().title()

orders = [Order(1, 12000, True), Order(2, 8000, False)]
print(total_paid(orders))

import time
import functools

def retry(times: int = 3):
    """인자를 받는 데코레이터는 함수를 한 겹 더 감싼 팩토리 구조입니다."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_error: Exception | None = None
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as exc:
                    last_error = exc
                    print(f"[재시도 {attempt}/{times}] {func.__name__} 실패: {exc}")
            raise last_error
        return wrapper
    return decorator

@retry(times=3)
def call_flaky_api() -> str:
    if time.time() % 2 < 1:
        raise ConnectionError("일시적 네트워크 오류")
    return "ok"

# 내장 데코레이터
class Circle:
    def __init__(self, radius: float) -> None:
        self._radius = radius

    @property
    def area(self) -> float:
        return 3.14159 * self._radius ** 2

    @staticmethod
    def unit() -> "Circle":
        return Circle(1)

@functools.lru_cache(maxsize=None)
def fibonacci(n: int) -> int:
    return n if n < 2 else fibonacci(n - 1) + fibonacci(n - 2)

from app.calculator import add

def main() -> None:
    print(add(2, 3))

if __name__ == "__main__":
    main()

from pathlib import Path
import json

data_dir = Path("data")
data_dir.mkdir(exist_ok=True)

users = [{"id": 1, "name": "Ada"}, {"id": 2, "name": "Linus"}]
path = data_dir / "users.json"

path.write_text(json.dumps(users, ensure_ascii=False, indent=2), encoding="utf-8")
loaded = json.loads(path.read_text(encoding="utf-8"))

for user in loaded:
    print(user["id"], user["name"])

import time
from contextlib import contextmanager

# 1) 클래스 기반 컨텍스트 매니저
class Timer:
    def __enter__(self):
        self._start = time.perf_counter()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        elapsed = time.perf_counter() - self._start
        print(f"소요 시간: {elapsed:.3f}s")
        return False  # 예외를 삼키지 않고 그대로 전파

with Timer():
    time.sleep(0.1)

# 2) 제너레이터 기반 컨텍스트 매니저 — 훨씬 짧게 같은 역할 구현
@contextmanager
def timer():
    start = time.perf_counter()
    try:
        yield
    finally:
        print(f"소요 시간: {time.perf_counter() - start:.3f}s")

with timer():
    time.sleep(0.1)

# 3) 여러 자원을 동시에 정리
with open("in.txt", encoding="utf-8") as src, open("out.txt", "w", encoding="utf-8") as dst:
    dst.write(src.read().upper())

from pathlib import Path

def read_config(path: str) -> dict[str, str]:
    file = Path(path)
    if not file.exists():
        raise FileNotFoundError(f"config not found: {path}")

    result: dict[str, str] = {}
    for line in file.read_text(encoding="utf-8").splitlines():
        if not line.strip() or line.startswith("#"):
            continue
        key, value = line.split("=", 1)
        result[key.strip()] = value.strip()
    return result

try:
    config = read_config("app.env")
except FileNotFoundError as exc:
    print(f"설정 오류: {exc}")

from dataclasses import dataclass

@dataclass
class Account:
    owner: str
    balance: int = 0

    def deposit(self, amount: int) -> None:
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount

    def withdraw(self, amount: int) -> None:
        if amount > self.balance:
            raise ValueError("insufficient balance")
        self.balance -= amount

account = Account("Ada")
account.deposit(10000)
account.withdraw(3000)
print(account.balance)

from typing import TypedDict, Protocol, Literal

# 값이 없을 수도 있음을 명시 (Python 3.10+에서는 Optional[str] 대신 str | None)
def find_user(user_id: int) -> str | None:
    return "Ada" if user_id == 1 else None

# 여러 타입 중 하나
def parse_amount(value: int | str) -> float:
    return float(value)

# JSON처럼 구조가 정해진 dict 타입
class UserPayload(TypedDict):
    id: int
    name: str
    role: Literal["admin", "developer", "viewer"]

def greet(user: UserPayload) -> str:
    return f"{user['name']}({user['role']})님 환영합니다"

# 상속 없이 "이 메서드가 있으면 된다"는 구조적 타이핑
class SupportsTotal(Protocol):
    def total(self) -> float: ...

def print_total(item: SupportsTotal) -> None:
    print(f"합계: {item.total()}")

import argparse
import csv
import logging
from pathlib import Path

logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")

parser = argparse.ArgumentParser()
parser.add_argument("--file", default="orders.csv")
args = parser.parse_args()

path = Path(args.file)
total = 0

with path.open(encoding="utf-8", newline="") as f:
    for row in csv.DictReader(f):
        total += int(row["amount"])

logging.info("total amount: %s", total)

import asyncio
import time
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

# I/O bound: 동시에 여러 스레드로 대기
def download(url: str) -> str:
    time.sleep(0.5)  # 네트워크 대기를 흉내
    return f"downloaded: {url}"

with ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(download, ["a.com", "b.com", "c.com"]))

# CPU bound: 여러 프로세스로 진짜 병렬 계산
def heavy_square(n: int) -> int:
    return sum(i * i for i in range(n))

with ProcessPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(heavy_square, [10_000_000] * 4))

# asyncio: 단일 스레드에서 수많은 대기를 동시에 처리
async def fetch(session_id: int) -> str:
    await asyncio.sleep(0.5)  # 반드시 asyncio용 sleep — time.sleep은 이벤트 루프를 멈춤
    return f"session {session_id} done"

async def main() -> None:
    results = await asyncio.gather(*(fetch(i) for i in range(10)))
    print(results)

asyncio.run(main())

[project]
name = "python-basic"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
    "requests>=2.32",
]

[dependency-groups]
dev = ["pytest>=8.0"]

import pytest
from app.calculator import add

def test_add():
    assert add(2, 3) == 5

@pytest.mark.parametrize("a,b,expected", [
    (1, 2, 3),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add_cases(a: int, b: int, expected: int):
    assert add(a, b) == expected

import pytest
from app.weather import WeatherClient

@pytest.fixture
def client() -> WeatherClient:
    # 각 테스트마다 새로 생성되는 재사용 가능한 준비물
    return WeatherClient(api_key="test-key")

def test_parses_temperature(client: WeatherClient, monkeypatch: pytest.MonkeyPatch):
    def fake_get(url: str) -> dict:
        return {"temp": 21.5}

    # 실제 네트워크 호출 대신 가짜 함수로 대체
    monkeypatch.setattr(client, "_get", fake_get)

    assert client.current_temperature("Seoul") == 21.5