Card 06/ 09
Strategy Classes vs Passing a Function in Python
When a strategy has one method, a function is the strategy.
In Python a function can be passed as an argument, so a strategy with one method can be the function itself, with no interface and no class. This card puts the shipping strategies in that form beside the class form, then sets out what each form gives up and a rule for choosing.
import math
from collections.abc import Callable
Shipping = Callable[[float], int]
def standard(weight_kg: float) -> int:
return 399 + 100 * math.ceil(weight_kg)
def express(weight_kg: float) -> int:
return 899 + 200 * math.ceil(weight_kg)
def total_pence(goods_pence: int, weight_kg: float, shipping: Shipping) -> int:
return goods_pence + shipping(weight_kg)
print(total_pence(4200, 2.5, standard))
print(total_pence(4200, 2.5, express))
print(total_pence(4200, 2.5, lambda weight_kg: 199))4899
5699
4399The totals match the class version, £48.99 and £56.99, and the lambda, a function written inline, prices the collection point at £1.99 without a definition of its own. Shipping is now a type alias, Callable[[float], int], which a type checker uses to refuse a function with the wrong signature. The context is a function too, so the whole pattern has become one parameter.
| Concern | A strategy class | A function |
|---|---|---|
| Code per strategy | A class and a method | One function or a lambda |
| Configuration | Held in fields, set in the constructor | Held in a closure, or bound with functools.partial |
| Several related operations | Several methods on one object, such as cost_pence and estimate | Several functions that must be passed together |
| Name in errors and logs | The class name | The function name, or <lambda> |
| Interface | An ABC or Protocol that a type checker enforces | A Callable alias that a type checker enforces |
The decision rule follows from the third row. Start with a function when the strategy is one operation, which covers key= arguments, callbacks and most pricing rules. Move to a class when the strategy needs a second method that must stay consistent with the first, or configuration worth a name of its own. A shipping option that must report both a cost and a delivery estimate is two operations, and a class keeps them together.
Either way the pattern is still there: the context delegates the varying part of its work to something the caller chose, and only the amount of code needed to say so has changed.
← → move through sections and cards