The Strategy & Dispatch Patterns

Replace growing if/elif chains with strategy registries (dicts of callables) or functools.singledispatch for type-based dispatch. Both keep open/closed design: add a new variant without editing the dispatcher core.

Recipe

Quick-reference recipe card - copy-paste ready.

from functools import singledispatch
 
STRATEGIES = {
    "email": lambda user: f"email:{user['email']}",
    "sms": lambda user: f"sms:{user['phone']}",
}
 
def notify(user: dict, channel: str) -> str:
    return STRATEGIES[channel](user)
 
@singledispatch
def serialize(obj) -> str:
    raise TypeError(type(obj))
 
@serialize.register(int)
def _(obj: int) -> str:
    return str(obj)

When to reach for this:

• Strategy dict when behavior varies by string/enum key (payment method, export format)
• singledispatch when behavior varies by argument type
• Registry pattern when plugins register handlers at import time
• Replacing 5+ elif branches that only differ by which function runs
• Testability when each strategy is a small, pure function

Working Example

Notification strategies plus singledispatch for API response shaping.

from dataclasses import dataclass
from functools import singledispatch
from typing import Callable
 
@dataclass(frozen=True)
class User:
    name: str
    email: str
    phone: str
 
Notifier = Callable[[User, str], None]
 
def log_notify(user: User, message: str) -> None:
    print(f"[log] {user.name}: {message}")
 
def email_notify(user: User, message: str) -> None:
    print(f"[email] to {user.email}: {message}")
 
CHANNELS: dict[str, Notifier] = {
    "log": log_notify,
    "email": email_notify,
}
 
def dispatch_notify(channel: str, user: User, message: str) -> None:
    try:
        handler = CHANNELS[channel]
    except KeyError as exc:
        raise ValueError(f"unknown channel: {channel}") from exc
    handler(user, message)
 
@singledispatch
def to_json(obj) -> dict:
    raise TypeError(f"unsupported: {type(obj)!r}")
 
@to_json.register(User)
def _(user: User) -> dict:
    return {"name": user.name, "email": user.email}
 
@to_json.register(int)
def _(value: int) -> dict:
    return {"type": "int", "value": value}
 
ada = User("Ada", "ada@example.com", "+15551234")
dispatch_notify("email", ada, "hello")
print(to_json(ada))
print(to_json(42))

What this demonstrates:

• Dict lookup replaces elif on channel strings
• Unknown keys raise clear ValueError with chaining
• singledispatch adds types without touching the base function
• Callable typing documents the strategy signature

Deep Dive

How It Works

• Strategy pattern: select an algorithm at runtime via a map or object attribute
• singledispatch stores registered implementations keyed by type
• MRO resolution picks the most specific registered type
• Registries can be populated at module import or via decorator plugins
• Both patterns localize change: new variant = new entry, not edited dispatcher

Strategy vs singledispatch

Python Notes

from enum import StrEnum
 
class Format(StrEnum):
    JSON = "json"
    CSV = "csv"
 
EXPORTERS: dict[Format, Callable] = {
    Format.JSON: export_json,
    Format.CSV: export_csv,
}

Gotchas

• Mutable default registries - shared dict mutated at runtime leaks state across tests. Fix: copy registries or use immutable mappings (MappingProxyType).
• KeyError vs explicit error - raw dict access gives vague errors. Fix: wrap with helpful ValueError messages.
• singledispatch on methods - registering on methods is awkward; use standalone functions or singledispatchmethod.
• elif still growing elsewhere - dispatch only helps at one boundary; duplicate branches in callers mean wrong abstraction level. Fix: dispatch once at the facade.
• Untested default branch - singledispatch base that always raises hides missing registrations until runtime. Fix: test each registered type.

Alternatives

FAQs

Related

• Factory & Builder Patterns - constructing strategy objects
• Observer & Pub/Sub - event dispatch
• Dependency Injection in Python - inject strategies
• Common Anti-Patterns - elif sprawl

External Related Links

• Python Standard Library Reference - Complete documentation for built-in modules and functions.
• Real Python - In-depth tutorials, courses, and practical guides.
• Official Python Documentation - The definitive source (Tutorial, Library Reference, Language Reference, HOWTOs).
• Fluent Python (2nd Edition) - Intermediate to advanced Python idioms (Luciano Ramalho).
• The Quick Python Book (4th Edition) - Concise Python overview (Naomi Ceder).

Stack versions: This page was written for Python 3.14.0 (stable 3.14, maintenance 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, and uv 0.6+.

WTI5a1pXZDFhV1JsY3k1cGIzeGpaMmx2TnpRNGZESXdNall3Tnc9PQ==