Pythonの多重継承とMixin入門：実務で使えるベストプラクティス10選

class A:
    def greet(self) -> None:
        # Aクラス特有の挨拶
        print("Hello from A")

class B:
    def farewell(self) -> None:
        # Bクラス特有のお別れメッセージ
        print("Goodbye from B")

class C(A, B):
    # AとBの両方を継承したクラス
    def intro(self) -> None:
        print("I am C")

c = C()
c.greet()      # Aクラス由来のメソッド
c.farewell()   # Bクラス由来のメソッド
c.intro()      # C自身のメソッド

class LoggingMixin:
    # ログ出力専用のMixin
    def log(self, message: str) -> None:
        print(f"[LOG] {message}")

class Service(LoggingMixin):
    def process(self) -> None:
        self.log("Start processing")
        print("Doing main work...")
        self.log("End processing")

service = Service()
service.process()

class A:
    def hello(self) -> None:
        print("A.hello")

class B(A):
    def hello(self) -> None:
        print("B.hello")
        super().hello()  # 次のクラスへ委譲

class C(A):
    def hello(self) -> None:
        print("C.hello")
        super().hello()

class D(B, C):
    pass

d = D()
d.hello()

# 実際のMROを確認
print(D.mro())

class LoggingMixin:
    """ログ出力だけを担当するMixin"""
    def log_info(self, message: str) -> None:
        print(f"[INFO] {message}")

    def log_error(self, message: str) -> None:
        print(f"[ERROR] {message}")

class LoggingCachePermissionMixin:
    """責務を詰め込みすぎたアンチパターン例"""
    def log(self, message: str) -> None:
        print(f"[LOG] {message}")

    def get_from_cache(self, key: str) -> str | None:
        # 擬似的なキャッシュ取得処理
        return None

    def has_permission(self, user: str, action: str) -> bool:
        # 擬似的な権限チェック
        return True

class StrReprMixin:
    """__str__と__repr__の共通実装を提供するMixin"""

    def __str__(self) -> str:
        return f"{self.__class__.__name__}({self.__dict__})"

    __repr__ = __str__

class CounterMixin:
    """状態を持つ危険なMixinの例"""
    def __init__(self) -> None:
        # どのタイミングで初期化されるかが不透明
        self._counter = 0

    def increment(self) -> None:
        self._counter += 1

class DangerousPermissionMixin:
    """self.userやself.roleに依存している危険な例"""

    def has_admin_permission(self) -> bool:
        # user属性とrole属性がある前提で実装されている
        return self.user.is_active and self.role == "admin"

class PermissionCheckMixin:
    """ユーザ情報を引数で受け取ることで依存を小さくした例"""

    def has_permission(self, user: "User", required_role: str) -> bool:
        # userオブジェクトの公開インターフェースにだけ依存
        return user.is_active and required_role in user.roles

class A:
    def hello(self) -> None:
        print("A")

class B(A):
    def hello(self) -> None:
        print("B")
        super().hello()

class C(A):
    def hello(self) -> None:
        print("C")
        super().hello()

class D(B, C):
    pass

d = D()
d.hello()
print(D.mro())

class Base:
    def process(self) -> None:
        print("Base.process")

class LoggingMixin(Base):
    def process(self) -> None:
        print("LoggingMixin.before")
        super().process()
        print("LoggingMixin.after")

class ValidationMixin(Base):
    def process(self) -> None:
        print("ValidationMixin.before")
        super().process()
        print("ValidationMixin.after")

class Service(ValidationMixin, LoggingMixin, Base):
    pass

s = Service()
s.process()
print(Service.mro())

from abc import ABC, abstractmethod

class Repository(ABC):
    """データ保存のインターフェースを定義するABC"""

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

    @abstractmethod
    def get(self, key: str) -> dict | None:
        ...

class LoggingMixin:
    """保存・取得処理にログを追加するMixin"""

    def save(self, data: dict) -> None:  # type: ignore[override]
        print(f"[LOG] Saving: {data}")
        # super()で次の実装へ委譲
        super().save(data)

    def get(self, key: str) -> dict | None:  # type: ignore[override]
        print(f"[LOG] Getting key: {key}")
        return super().get(key)

class InMemoryRepository(LoggingMixin, Repository):
    def __init__(self) -> None:
        self._store: dict[str, dict] = {}

    def save(self, data: dict) -> None:
        key = data["id"]
        self._store[key] = data

    def get(self, key: str) -> dict | None:
        return self._store.get(key)

repo: Repository = InMemoryRepository()
repo.save({"id": "1", "name": "Alice"})
print(repo.get("1"))

# util_json.py
import json
from typing import Any

def to_json(data: Any) -> str:
    return json.dumps(data, ensure_ascii=False)

from typing import Protocol

class CanLog(Protocol):
    def log(self, message: str) -> None:
        ...

class LoggingMixin:
    def log(self, message: str) -> None:
        print(f"[LOG] {message}")

class Service(LoggingMixin):
    def do(self) -> None:
        self.log("doing something")

def run(service: CanLog) -> None:
    service.log("start")

s = Service()
run(s)

import datetime as _dt
from typing import Any

class LoggingMixin:
    """簡易的なログ出力を提供するMixin"""

    def log(self, level: str, message: str, **context: Any) -> None:
        timestamp = _dt.datetime.now().isoformat(timespec="seconds")
        ctx = " ".join(f"{k}={v}" for k, v in context.items())
        print(f"{timestamp} [{level}] {self.__class__.__name__}: {message} {ctx}")

    def log_info(self, message: str, **context: Any) -> None:
        self.log("INFO", message, **context)

    def log_error(self, message: str, **context: Any) -> None:
        self.log("ERROR", message, **context)

class OrderService(LoggingMixin):
    def create_order(self, user_id: str, amount: int) -> None:
        self.log_info("Creating order", user_id=user_id, amount=amount)
        # ここで注文作成処理を行う
        self.log_info("Order created", user_id=user_id, amount=amount)

service = OrderService()
service.create_order("u-123", 5000)

from collections.abc import Callable
from functools import wraps
from typing import ParamSpec, TypeVar

P = ParamSpec("P")
R = TypeVar("R")

class CacheMixin:
    """簡易インメモリキャッシュを提供するMixin"""

    def __init__(self) -> None:
        # Mixinで状態を持つ例だが、__init__とsuper()をきちんと扱う前提
        self._cache: dict[str, object] = {}  # key -> value

    def cached(self, key_func: Callable[P, str]) -> Callable[[Callable[P, R]], Callable[P, R]]:
        """デコレータとして使用し、結果をキャッシュする"""

        def decorator(func: Callable[P, R]) -> Callable[P, R]:
            @wraps(func)
            def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
                key = key_func(*args, **kwargs)
                if key in self._cache:
                    # キャッシュヒット
                    return self._cache[key]  # type: ignore[return-value]
                result = func(*args, **kwargs)
                self._cache[key] = result  # type: ignore[assignment]
                return result
            return wrapper
        return decorator

class PriceService(CacheMixin):
    def __init__(self) -> None:
        super().__init__()

        # デコレータをインスタンスメソッドに適用
        self.get_price = self.cached(lambda product_id: product_id)(self.get_price)  # type: ignore[method-assign]

    def get_price(self, product_id: str) -> int:
        print(f"Fetching price for {product_id} from external API...")
        return 100  # 擬似的な価格

svc = PriceService()
print(svc.get_price("p-001"))
print(svc.get_price("p-001"))  # 2回目はキャッシュヒット

class PermissionError(Exception):
    """権限不足を表す例外"""
    pass

class PermissionMixin:
    """簡易的な権限チェックを提供するMixin"""

    def check_permission(self, user_roles: list[str], required_role: str) -> None:
        if required_role not in user_roles:
            raise PermissionError(f"Required role '{required_role}' is missing")

class ReportService(PermissionMixin):
    def generate_report(self, user_roles: list[str]) -> str:
        # 管理者権限が必要
        self.check_permission(user_roles, "admin")
        return "report-content"

service = ReportService()

try:
    print(service.generate_report(["user"]))
except PermissionError as e:
    print("Error:", e)

print(service.generate_report(["user", "admin"]))

import json
from typing import Any

class SerializerMixin:
    """オブジェクトを辞書およびJSONへシリアライズするMixin"""

    def to_dict(self) -> dict[str, Any]:
        # __dict__をベースに、先頭が_の属性は除外する
        return {
            k: v
            for k, v in self.__dict__.items()
            if not k.startswith("_")
        }

    def to_json(self, **json_kwargs: Any) -> str:
        return json.dumps(self.to_dict(), ensure_ascii=False, **json_kwargs)

class User(SerializerMixin):
    def __init__(self, user_id: str, name: str, password_hash: str) -> None:
        self.user_id = user_id
        self.name = name
        self._password_hash = password_hash  # シリアライズ対象外

u = User("u-1", "Alice", "xxx123")
print(u.to_dict())
print(u.to_json())

import asyncio
from concurrent.futures import ThreadPoolExecutor
from typing import Callable, TypeVar

T = TypeVar("T")

class AsyncMixin:
    """同期関数を別スレッドで実行し、asyncメソッドとして扱うMixin"""

    _executor: ThreadPoolExecutor | None = None

    @classmethod
    def _get_executor(cls) -> ThreadPoolExecutor:
        if cls._executor is None:
            cls._executor = ThreadPoolExecutor(max_workers=4)
        return cls._executor

    async def run_in_thread(self, func: Callable[[], T]) -> T:
        loop = asyncio.get_running_loop()
        return await loop.run_in_executor(self._get_executor(), func)

class ReportGenerator(AsyncMixin):
    def generate_sync(self) -> str:
        # 時間のかかる処理をシミュレート
        import time
        time.sleep(1)
        return "sync-report"

    async def generate_async(self) -> str:
        # generate_syncを別スレッドで実行
        return await self.run_in_thread(self.generate_sync)

async def main() -> None:
    gen = ReportGenerator()
    print(await gen.generate_async())

if __name__ == "__main__":
    asyncio.run(main())

class A:
    def __init__(self, *args, **kwargs) -> None:
        print("A.__init__")
        super().__init__(*args, **kwargs)

class B:
    def __init__(self, *args, **kwargs) -> None:
        print("B.__init__")
        super().__init__(*args, **kwargs)

class C(A, B):
    def __init__(self, *args, **kwargs) -> None:
        print("C.__init__")
        super().__init__(*args, **kwargs)

c = C()
print(C.mro())