Python 디자인패턴 완전 정리

Python code

from contextvars import ContextVar
from typing import Optional
import asyncio

# ContextVar — 코루틴/스레드마다 독립적인 값
current_user: ContextVar[Optional[str]] = ContextVar(
    "current_user", default=None
)
request_id: ContextVar[str] = ContextVar("request_id")

async def handle_request(user: str, req_id: str):
    current_user.set(user)
    request_id.set(req_id)
    await process()

async def process():
    user = current_user.get()
    rid  = request_id.get()
    print(f"[{rid}] {user} 처리 중")
    await asyncio.sleep(0.01)

# 의존성 주입 — 간단한 컨테이너
class Container:
    _services = {}

    @classmethod
    def register(cls, name: str, factory):
        cls._services[name] = factory

    @classmethod
    def resolve(cls, name: str):
        return cls._services[name]()

# 등록
Container.register("db", lambda: {"connected": True})
Container.register("cache", lambda: {})

# 사용
db    = Container.resolve("db")
cache = Container.resolve("cache")

async def main():
    await asyncio.gather(
        handle_request("Alice", "req-001"),
        handle_request("Bob",   "req-002"),
    )

asyncio.run(main())

Python code

from typing import Protocol, runtime_checkable
from pathlib import Path

# 플러그인 인터페이스 정의
@runtime_checkable
class Exporter(Protocol):
    def export(self, data: list, path: Path) -> None: ...
    def extension(self) -> str: ...

# 구현체들 (Exporter를 명시적으로 상속하지 않음)
class CsvExporter:
    def export(self, data: list, path: Path) -> None:
        import csv
        with open(path, "w", newline="") as f:
            if data:
                writer = csv.DictWriter(f, fieldnames=data[0])
                writer.writeheader()
                writer.writerows(data)

    def extension(self) -> str:
        return ".csv"

class JsonExporter:
    def export(self, data: list, path: Path) -> None:
        import json
        path.write_text(json.dumps(data, indent=2, ensure_ascii=False))

    def extension(self) -> str:
        return ".json"

# 팩토리
_exporters: dict[str, Exporter] = {
    "csv":  CsvExporter(),
    "json": JsonExporter(),
}

def get_exporter(fmt: str) -> Exporter:
    if fmt not in _exporters:
        raise ValueError(f"지원하지 않는 포맷: {fmt}")
    return _exporters[fmt]

# 사용
data = [{"name": "Alice", "score": 95}]
for fmt in ["csv", "json"]:
    exp = get_exporter(fmt)
    print(isinstance(exp, Exporter))  # True

Python code

<span class="cm">// ExceptionGroup 실전 활용 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("ExceptionGroup 실전 활용") }

Python code

from contextlib import contextmanager
import time

# 1. 클래스 기반 컨텍스트 매니저
class Timer:
    def __enter__(self):
        self.start = time.perf_counter()
        return self  # with ... as 변수에 바인딩

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.elapsed = time.perf_counter() - self.start
        print(f"경과 시간: {self.elapsed:.4f}초")
        return False  # True면 예외를 억제

# 2. 제너레이터 기반 컨텍스트 매니저
@contextmanager
def managed_resource(name):
    print(f"[{name}] 리소스 획득")
    try:
        yield name  # with ... as 변수에 전달
    except Exception as e:
        print(f"[{name}] 예외 발생: {e}")
        raise
    finally:
        print(f"[{name}] 리소스 해제")

# 3. 다중 컨텍스트 매니저
with Timer() as t:
    total = sum(range(1_000_000))
    print(f"합계: {total}")

with managed_resource("DB") as db:
    print(f"  {db} 연결로 작업 수행 중...")

# Python 3.10+ 괄호로 여러 개 관리
# with (
#     managed_resource("DB") as db,
#     managed_resource("Cache") as cache,
# ):
#     print(f"  {db}와 {cache} 동시 사용")

Python code

from pydantic import BaseModel, Field, field_validator, model_validator
from pydantic import EmailStr  # pip install pydantic[email]
from datetime import datetime
from typing import Optional

# 1. 기본 모델 정의
class Address(BaseModel):
    street: str
    city: str
    zip_code: str = Field(pattern=r"^\d{5}$")

class User(BaseModel):
    name: str = Field(min_length=2, max_length=50)
    email: str  # EmailStr로 변경 가능
    age: int = Field(ge=0, le=150)
    address: Optional[Address] = None
    tags: list[str] = []
    created_at: datetime = Field(default_factory=datetime.now)

    # 필드 레벨 검증
    @field_validator('name')
    @classmethod
    def name_must_not_be_empty(cls, v):
        if not v.strip():
            raise ValueError('이름은 공백만으로 구성할 수 없습니다')
        return v.strip()

    # 모델 레벨 검증
    @model_validator(mode='after')
    def check_consistency(self):
        if self.age < 14 and self.tags and 'admin' in self.tags:
            raise ValueError('14세 미만은 관리자가 될 수 없습니다')
        return self

# 2. 유효한 데이터
user = User(
    name="홍길동",
    email="hong@example.com",
    age=25,
    address={"street": "세종대로 1", "city": "서울", "zip_code": "04524"},
    tags=["developer"],
)
print(f"사용자: {user.name}, {user.age}세")
print(f"주소: {user.address.city} {user.address.street}")
print(f"JSON: {user.model_dump_json(indent=2)}")

# 3. 유효하지 않은 데이터 → 자동 에러
from pydantic import ValidationError
try:
    bad_user = User(name="", email="invalid", age=-5)
except ValidationError as e:
    print(f"\n검증 에러 {e.error_count()}개:")
    for err in e.errors():
        print(f"  {err['loc']}: {err['msg']}")

Python code

from dataclasses import dataclass, field

# Model: 데이터와 비즈니스 로직
@dataclass
class UserModel:
    users: list[dict] = field(default_factory=list)

    def add(self, name: str, email: str):
        user = {"id": len(self.users) + 1, "name": name, "email": email}
        self.users.append(user)
        return user

    def get_all(self) -> list[dict]:
        return self.users.copy()

    def find(self, user_id: int) -> dict | None:
        return next((u for u in self.users if u["id"] == user_id), None)

# View: 표시 로직
class UserView:
    @staticmethod
    def display_users(users: list[dict]):
        print("=== 사용자 목록 ===")
        for u in users:
            print(f"  [{u['id']}] {u['name']} ({u['email']})")

    @staticmethod
    def display_message(msg: str):
        print(f">> {msg}")

# Controller: Model과 View 연결
class UserController:
    def __init__(self):
        self.model = UserModel()
        self.view = UserView()

    def create_user(self, name: str, email: str):
        user = self.model.add(name, email)
        self.view.display_message(f"{user['name']} 생성됨")

    def list_users(self):
        self.view.display_users(self.model.get_all())

# 사용
ctrl = UserController()
ctrl.create_user("Alice", "alice@test.com")
ctrl.create_user("Bob", "bob@test.com")
ctrl.list_users()

Python code

from abc import ABC, abstractmethod
from dataclasses import dataclass

@dataclass
class User:
    id: int
    name: str
    email: str

class UserRepository(ABC):
    @abstractmethod
    def find_by_id(self, user_id: int) -> User | None: ...
    @abstractmethod
    def find_all(self) -> list[User]: ...
    @abstractmethod
    def save(self, user: User) -> User: ...
    @abstractmethod
    def delete(self, user_id: int) -> bool: ...

class InMemoryUserRepository(UserRepository):
    def __init__(self):
        self._store: dict[int, User] = {}
        self._next_id = 1

    def find_by_id(self, user_id: int) -> User | None:
        return self._store.get(user_id)

    def find_all(self) -> list[User]:
        return list(self._store.values())

    def save(self, user: User) -> User:
        if user.id == 0:
            user = User(self._next_id, user.name, user.email)
            self._next_id += 1
        self._store[user.id] = user
        return user

    def delete(self, user_id: int) -> bool:
        return self._store.pop(user_id, None) is not None

# 비즈니스 로직은 추상 인터페이스에만 의존
def register_user(repo: UserRepository, name: str, email: str):
    user = repo.save(User(0, name, email))
    print(f"등록: {user}")
    return user

repo = InMemoryUserRepository()
register_user(repo, "Alice", "alice@test.com")
register_user(repo, "Bob", "bob@test.com")
print(f"전체: {repo.find_all()}")

Python code

from dataclasses import dataclass

@dataclass
class Order:
    id: int
    user_id: int
    items: list[str]
    total: float
    status: str = "pending"

class OrderRepository:
    def __init__(self):
        self._orders: dict[int, Order] = {}
        self._next_id = 1

    def save(self, order: Order) -> Order:
        if order.id == 0:
            order.id = self._next_id
            self._next_id += 1
        self._orders[order.id] = order
        return order

    def find_by_user(self, user_id: int) -> list[Order]:
        return [o for o in self._orders.values() if o.user_id == user_id]

class OrderService:
    """비즈니스 로직을 캡슐화"""
    def __init__(self, repo: OrderRepository):
        self._repo = repo

    def place_order(self, user_id: int, items: list[str]) -> Order:
        if not items:
            raise ValueError("주문 항목이 비어있습니다")
        total = len(items) * 10000  # 간단한 가격 계산
        order = self._repo.save(
            Order(0, user_id, items, total)
        )
        print(f"주문 생성: #{order.id} (총 {order.total:,.0f}원)")
        return order

    def get_user_orders(self, user_id: int) -> list[Order]:
        return self._repo.find_by_user(user_id)

# 사용
repo = OrderRepository()
service = OrderService(repo)
service.place_order(1, ["노트북", "마우스"])
service.place_order(1, ["키보드"])
orders = service.get_user_orders(1)
for o in orders:
    print(f"  #{o.id}: {o.items} → {o.total:,.0f}원")

Python code

from abc import ABC, abstractmethod

# 인터페이스 정의
class EmailSender(ABC):
    @abstractmethod
    def send(self, to: str, subject: str, body: str) -> bool: ...

class Logger(ABC):
    @abstractmethod
    def log(self, message: str) -> None: ...

# 구현체
class SMTPSender(EmailSender):
    def send(self, to, subject, body):
        print(f"  [SMTP] {to}: {subject}")
        return True

class ConsoleLogger(Logger):
    def log(self, message):
        print(f"  [LOG] {message}")

# DI를 받는 서비스
class NotificationService:
    def __init__(self, sender: EmailSender, logger: Logger):
        self._sender = sender
        self._logger = logger

    def notify(self, user_email: str, message: str):
        self._logger.log(f"알림 전송: {user_email}")
        success = self._sender.send(user_email, "알림", message)
        self._logger.log(f"결과: {'성공' if success else '실패'}")

# 프로덕션
service = NotificationService(SMTPSender(), ConsoleLogger())
service.notify("user@test.com", "주문이 접수되었습니다")

# 테스트용 Mock
class MockSender(EmailSender):
    def __init__(self):
        self.sent = []
    def send(self, to, subject, body):
        self.sent.append((to, subject))
        return True

mock = MockSender()
test_service = NotificationService(mock, ConsoleLogger())
test_service.notify("test@test.com", "테스트")
print(f"전송 기록: {mock.sent}")

Python code

from collections import defaultdict
from dataclasses import dataclass, field
from typing import Callable, Any
from datetime import datetime

@dataclass
class Event:
    name: str
    data: dict
    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())

class EventBus:
    def __init__(self):
        self._handlers: dict[str, list[Callable]] = defaultdict(list)
        self._history: list[Event] = []

    def subscribe(self, event_name: str, handler: Callable):
        self._handlers[event_name].append(handler)

    def publish(self, event_name: str, **data):
        event = Event(event_name, data)
        self._history.append(event)
        for handler in self._handlers.get(event_name, []):
            handler(event)

    def get_history(self) -> list[Event]:
        return self._history.copy()

# 이벤트 핸들러들
bus = EventBus()

bus.subscribe("user.created", lambda e:
    print(f"  [이메일] {e.data['name']}님 환영 메일 발송"))
bus.subscribe("user.created", lambda e:
    print(f"  [분석] 신규 가입 기록"))
bus.subscribe("order.placed", lambda e:
    print(f"  [재고] {e.data['item']} 재고 차감"))
bus.subscribe("order.placed", lambda e:
    print(f"  [알림] 주문 확인 알림"))

# 이벤트 발행
print("=== 사용자 생성 ===")
bus.publish("user.created", name="Alice", email="alice@test.com")
print("\n=== 주문 생성 ===")
bus.publish("order.placed", item="노트북", qty=1)

print(f"\n이벤트 히스토리: {len(bus.get_history())}건")

Python code

from collections import defaultdict
from typing import Callable
import re

class PubSub:
    def __init__(self):
        self._exact: dict[str, list[Callable]] = defaultdict(list)
        self._patterns: list[tuple[str, Callable]] = []

    def subscribe(self, topic: str, callback: Callable):
        if "*" in topic:
            pattern = topic.replace(".", "\.").replace("*", ".*")
            self._patterns.append((pattern, callback))
        else:
            self._exact[topic].append(callback)

    def publish(self, topic: str, message: dict):
        # 정확한 매칭
        for cb in self._exact.get(topic, []):
            cb(topic, message)
        # 패턴 매칭
        for pattern, cb in self._patterns:
            if re.match(pattern, topic):
                cb(topic, message)

# 사용
ps = PubSub()

# 구체적 구독
ps.subscribe("order.created",
    lambda t, m: print(f"  [주문] 새 주문: {m}"))
ps.subscribe("order.paid",
    lambda t, m: print(f"  [결제] 결제 완료: {m}"))

# 와일드카드 구독
ps.subscribe("order.*",
    lambda t, m: print(f"  [감사] {t}: {m}"))
ps.subscribe("*",
    lambda t, m: print(f"  [로그] {t}"))

print("=== 주문 생성 ===")
ps.publish("order.created", {"id": 1, "item": "노트북"})
print("\n=== 결제 ===")
ps.publish("order.paid", {"id": 1, "amount": 1500000})

Python code

from abc import ABC, abstractmethod

class Command(ABC):
    @abstractmethod
    def execute(self) -> None: ...
    @abstractmethod
    def undo(self) -> None: ...

class TextEditor:
    def __init__(self):
        self.content = ""

    def __repr__(self):
        return f'TextEditor("{self.content}")'

class InsertCommand(Command):
    def __init__(self, editor: TextEditor, text: str):
        self.editor = editor
        self.text = text

    def execute(self):
        self.editor.content += self.text

    def undo(self):
        self.editor.content = self.editor.content[:-len(self.text)]

class DeleteCommand(Command):
    def __init__(self, editor: TextEditor, count: int):
        self.editor = editor
        self.count = count
        self.deleted = ""

    def execute(self):
        self.deleted = self.editor.content[-self.count:]
        self.editor.content = self.editor.content[:-self.count]

    def undo(self):
        self.editor.content += self.deleted

class CommandHistory:
    def __init__(self):
        self._history: list[Command] = []

    def execute(self, cmd: Command):
        cmd.execute()
        self._history.append(cmd)

    def undo(self):
        if self._history:
            cmd = self._history.pop()
            cmd.undo()

editor = TextEditor()
history = CommandHistory()

history.execute(InsertCommand(editor, "Hello"))
history.execute(InsertCommand(editor, " World"))
print(editor)  # "Hello World"
history.execute(DeleteCommand(editor, 6))
print(editor)  # "Hello"
history.undo()
print(editor)  # "Hello World"
history.undo()
print(editor)  # "Hello"

Python code

from abc import ABC, abstractmethod

class DataSource(ABC):
    @abstractmethod
    def write(self, data: str) -> None: ...
    @abstractmethod
    def read(self) -> str: ...

class FileDataSource(DataSource):
    def __init__(self):
        self._data = ""
    def write(self, data: str):
        self._data = data
    def read(self) -> str:
        return self._data

class DataSourceDecorator(DataSource):
    def __init__(self, source: DataSource):
        self._source = source
    def write(self, data: str):
        self._source.write(data)
    def read(self) -> str:
        return self._source.read()

class EncryptionDecorator(DataSourceDecorator):
    def write(self, data: str):
        encrypted = data[::-1]  # 간단한 암호화 시뮬레이션
        print(f"  [암호화] {data[:20]}...")
        super().write(encrypted)
    def read(self) -> str:
        return super().read()[::-1]

class CompressionDecorator(DataSourceDecorator):
    def write(self, data: str):
        compressed = data.replace("  ", " ")
        print(f"  [압축] {len(data)} → {len(compressed)} chars")
        super().write(compressed)
    def read(self) -> str:
        return super().read()

# 데코레이터 조합
source = FileDataSource()
encrypted = EncryptionDecorator(source)
compressed = CompressionDecorator(encrypted)

compressed.write("Hello  World  Python  Programming")
result = compressed.read()
print(f"읽기: {result}")

Python code

from abc import ABC, abstractmethod
import time

class Database(ABC):
    @abstractmethod
    def query(self, sql: str) -> list: ...

class RealDatabase(Database):
    def __init__(self):
        print("  [DB] 무거운 연결 수립 중...")
        time.sleep(0.01)
        self._connected = True

    def query(self, sql: str) -> list:
        return [{"result": f"데이터: {sql}"}]

# 지연 로딩 프록시
class LazyDatabaseProxy(Database):
    def __init__(self):
        self._db: RealDatabase | None = None

    def _get_db(self) -> RealDatabase:
        if self._db is None:
            self._db = RealDatabase()
        return self._db

    def query(self, sql: str) -> list:
        return self._get_db().query(sql)

# 캐싱 프록시
class CachingProxy(Database):
    def __init__(self, db: Database):
        self._db = db
        self._cache: dict[str, list] = {}

    def query(self, sql: str) -> list:
        if sql not in self._cache:
            print(f"  [캐시 MISS] {sql}")
            self._cache[sql] = self._db.query(sql)
        else:
            print(f"  [캐시 HIT] {sql}")
        return self._cache[sql]

# 사용
print("=== 지연 로딩 ===")
db = LazyDatabaseProxy()
print("DB 객체 생성 (아직 연결 안 됨)")
print(db.query("SELECT 1"))  # 이 시점에 연결

print("\n=== 캐싱 ===")
cached = CachingProxy(LazyDatabaseProxy())
cached.query("SELECT * FROM users")  # MISS
cached.query("SELECT * FROM users")  # HIT
cached.query("SELECT * FROM orders") # MISS

Python code

# 기존 XML 라이브러리 (변경 불가)
class XMLParser:
    def parse_xml(self, xml_string: str) -> dict:
        # XML 파싱 시뮬레이션
        return {"format": "xml", "data": xml_string[:30]}

# 기존 CSV 라이브러리 (변경 불가)
class CSVParser:
    def read_csv(self, csv_string: str) -> list:
        return [row.split(",") for row in csv_string.strip().split("\n")]

# 통합 인터페이스
class DataParser:
    def parse(self, data: str) -> dict:
        raise NotImplementedError

# 어댑터들
class XMLAdapter(DataParser):
    def __init__(self):
        self._parser = XMLParser()

    def parse(self, data: str) -> dict:
        result = self._parser.parse_xml(data)
        return {"source": "xml", "content": result}

class CSVAdapter(DataParser):
    def __init__(self):
        self._parser = CSVParser()

    def parse(self, data: str) -> dict:
        rows = self._parser.read_csv(data)
        return {"source": "csv", "rows": len(rows), "content": rows}

# 팩토리로 어댑터 선택
def get_parser(format_type: str) -> DataParser:
    parsers = {"xml": XMLAdapter, "csv": CSVAdapter}
    return parsers[format_type]()

# 사용: 동일한 인터페이스로 다른 형식 처리
for fmt, data in [("xml", "<root>데이터</root>"),
                   ("csv", "이름,나이\nAlice,30\nBob,25")]:
    parser = get_parser(fmt)
    result = parser.parse(data)
    print(f"  [{fmt}] {result}")

Python code

# 복잡한 서브시스템들
class AuthService:
    def verify_token(self, token: str) -> dict:
        return {"user_id": 1, "role": "admin"}

class UserService:
    def get_profile(self, user_id: int) -> dict:
        return {"name": "Alice", "email": "alice@test.com"}

class PermissionService:
    def check_access(self, role: str, resource: str) -> bool:
        return role in ("admin", "editor")

class AuditService:
    def log_access(self, user_id: int, resource: str):
        print(f"  [감사] 사용자 {user_id}이 {resource} 접근")

# 파사드: 복잡한 워크플로를 단순화
class APIFacade:
    def __init__(self):
        self._auth = AuthService()
        self._user = UserService()
        self._perm = PermissionService()
        self._audit = AuditService()

    def get_resource(self, token: str, resource: str) -> dict:
        # 1. 인증
        auth = self._auth.verify_token(token)
        # 2. 프로필 조회
        profile = self._user.get_profile(auth["user_id"])
        # 3. 권한 확인
        if not self._perm.check_access(auth["role"], resource):
            raise PermissionError("접근 거부")
        # 4. 감사 로그
        self._audit.log_access(auth["user_id"], resource)
        return {"user": profile, "resource": resource, "data": "..."}

# 클라이언트는 하나의 메서드만 호출
api = APIFacade()
result = api.get_resource("token123", "/api/data")
print(f"결과: {result['user']['name']}이 {result['resource']} 접근")

Python code

from abc import ABC, abstractmethod

class DataProcessor(ABC):
    """알고리즘 골격 정의"""
    def process(self, data: str) -> str:
        parsed = self.parse(data)
        validated = self.validate(parsed)
        transformed = self.transform(validated)
        return self.format_output(transformed)

    @abstractmethod
    def parse(self, raw: str) -> list: ...

    @abstractmethod
    def validate(self, data: list) -> list: ...

    def transform(self, data: list) -> list:
        """기본 구현 (오버라이드 가능)"""
        return data

    @abstractmethod
    def format_output(self, data: list) -> str: ...

class CSVProcessor(DataProcessor):
    def parse(self, raw: str) -> list:
        return [line.split(",") for line in raw.strip().split("\n")]

    def validate(self, data: list) -> list:
        return [row for row in data if len(row) >= 2]

    def transform(self, data: list) -> list:
        return [[col.strip().upper() for col in row] for row in data]

    def format_output(self, data: list) -> str:
        return "\n".join(" | ".join(row) for row in data)

class JSONProcessor(DataProcessor):
    def parse(self, raw: str) -> list:
        import json
        return json.loads(raw)

    def validate(self, data: list) -> list:
        return [d for d in data if "name" in d]

    def format_output(self, data: list) -> str:
        return ", ".join(d.get("name", "?") for d in data)

csv_proc = CSVProcessor()
print(csv_proc.process("Alice, 30\nBob, 25\n, "))

json_proc = JSONProcessor()
print(json_proc.process('[{"name":"Alice"},{"age":30},{"name":"Bob"}]'))

Python code

from dataclasses import dataclass, field

@dataclass
class HttpRequest:
    method: str = "GET"
    url: str = ""
    headers: dict = field(default_factory=dict)
    params: dict = field(default_factory=dict)
    body: str | None = None
    timeout: int = 30

class RequestBuilder:
    def __init__(self, url: str):
        self._request = HttpRequest(url=url)

    def method(self, method: str) -> "RequestBuilder":
        self._request.method = method
        return self

    def header(self, key: str, value: str) -> "RequestBuilder":
        self._request.headers[key] = value
        return self

    def param(self, key: str, value: str) -> "RequestBuilder":
        self._request.params[key] = value
        return self

    def body(self, data: str) -> "RequestBuilder":
        self._request.body = data
        return self

    def timeout(self, seconds: int) -> "RequestBuilder":
        self._request.timeout = seconds
        return self

    def build(self) -> HttpRequest:
        if not self._request.url:
            raise ValueError("URL은 필수입니다")
        return self._request

# 메서드 체이닝으로 가독성 높은 구성
request = (
    RequestBuilder("https://api.example.com/users")
    .method("POST")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer token123")
    .param("page", "1")
    .body('{"name": "Alice"}')
    .timeout(10)
    .build()
)
print(f"{request.method} {request.url}")
print(f"헤더: {request.headers}")
print(f"본문: {request.body}")

Python code

from abc import ABC, abstractmethod
from dataclasses import dataclass

class DiscountStrategy(ABC):
    @abstractmethod
    def calculate(self, price: float) -> float: ...

class NoDiscount(DiscountStrategy):
    def calculate(self, price: float) -> float:
        return price

class PercentDiscount(DiscountStrategy):
    def __init__(self, percent: float):
        self.percent = percent
    def calculate(self, price: float) -> float:
        return price * (1 - self.percent / 100)

class FixedDiscount(DiscountStrategy):
    def __init__(self, amount: float):
        self.amount = amount
    def calculate(self, price: float) -> float:
        return max(0, price - self.amount)

class BuyNGetFree(DiscountStrategy):
    def __init__(self, buy: int, free: int):
        self.buy = buy
        self.free = free
    def calculate(self, price: float) -> float:
        ratio = self.buy / (self.buy + self.free)
        return price * ratio

@dataclass
class Order:
    items: list[tuple[str, float]]
    discount: DiscountStrategy = None

    def total(self) -> float:
        subtotal = sum(price for _, price in self.items)
        if self.discount:
            return self.discount.calculate(subtotal)
        return subtotal

# 런타임에 전략 교체
order = Order([("노트북", 1500000), ("마우스", 50000)])
print(f"정가: {order.total():,.0f}원")

order.discount = PercentDiscount(10)
print(f"10% 할인: {order.total():,.0f}원")

order.discount = FixedDiscount(100000)
print(f"10만원 할인: {order.total():,.0f}원")

Python code

from abc import ABC, abstractmethod
from typing import Type

class Plugin(ABC):
    @property
    @abstractmethod
    def name(self) -> str: ...

    @abstractmethod
    def execute(self, data: dict) -> dict: ...

class PluginManager:
    def __init__(self):
        self._plugins: dict[str, Plugin] = {}

    def register(self, plugin: Plugin):
        self._plugins[plugin.name] = plugin
        print(f"  플러그인 등록: {plugin.name}")

    def unregister(self, name: str):
        self._plugins.pop(name, None)

    def execute_all(self, data: dict) -> dict:
        result = data.copy()
        for name, plugin in self._plugins.items():
            result = plugin.execute(result)
        return result

    def list_plugins(self) -> list[str]:
        return list(self._plugins.keys())

# 플러그인 구현
class UpperCasePlugin(Plugin):
    @property
    def name(self): return "uppercase"
    def execute(self, data):
        if "text" in data:
            data["text"] = data["text"].upper()
        return data

class TimestampPlugin(Plugin):
    @property
    def name(self): return "timestamp"
    def execute(self, data):
        from datetime import datetime
        data["processed_at"] = datetime.now().isoformat()
        return data

class ValidatorPlugin(Plugin):
    @property
    def name(self): return "validator"
    def execute(self, data):
        data["is_valid"] = bool(data.get("text"))
        return data

# 사용
manager = PluginManager()
manager.register(ValidatorPlugin())
manager.register(UpperCasePlugin())
manager.register(TimestampPlugin())

result = manager.execute_all({"text": "hello world"})
print(f"결과: {result}")
print(f"플러그인 목록: {manager.list_plugins()}")