Strategy Pattern

Behavioral Patterns

Definition

“Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This pattern lets the algorithm vary independently of the clients that use it”

Explanation

You design a common Strategy interface (for example, CompressionStrategy) and implement multiple concrete strategies (e.g. ZipCompression, RarCompression). A context class holds a reference to a strategy and delegates to it. At runtime the client picks and switches strategies as needed, without changing the context’s code.

Code

In the code below, Context uses different sorting strategies (ConcreteStrategyA and ConcreteStrategyB) to sort data.

from abc import ABC, abstractmethod

class Context:
    def __init__(self, strategy: "Strategy") -> None:
        self._strategy = strategy

    @property
    def strategy(self) -> "Strategy":
        return self._strategy

    @strategy.setter
    def strategy(self, strategy: "Strategy") -> None:
        self._strategy = strategy

    def do_some_business_logic(self) -> None:
        print("Context: Sorting data using the strategy")
        result = self._strategy.do_algorithm(["a", "b", "c", "d", "e"])
        print(",".join(result))

class Strategy(ABC):
    @abstractmethod
    def do_algorithm(self, data: list) -> list:
        pass

class ConcreteStrategyA(Strategy):
    def do_algorithm(self, data: list) -> list:
        return sorted(data)

class ConcreteStrategyB(Strategy):
    def do_algorithm(self, data: list) -> list:
        return list(reversed(sorted(data)))

def main():
    context = Context(ConcreteStrategyA())
    print("Client: Strategy is set to normal sorting.")
    context.do_some_business_logic()

    print("\nClient: Strategy is set to reverse sorting.")
    context.strategy = ConcreteStrategyB()
    context.do_some_business_logic()

if __name__ == "__main__":
    main()

Analogy

A food cart where you can choose how to cook. E.g., making a burger with different patties: you change the cooking algorithm (grill vs fry vs veggie) but the steps (assemble bun, toppings) remain the same. Another example is choosing an encryption algorithm: the same plaintext, different ciphers.

Interview Insights

Common uses: When multiple ways exist to do a task (sorting, compression, encryption) and you want to switch among them dynamically. Used in UI (different rendering modes), data processing (choosing filters), AI (choosing heuristic at runtime) etc.
Advantages: Promotes open/closed principle: new strategies can be added without changing existing code. Eliminates conditional statements for choosing algorithms. Achieves loose coupling between context and algorithm
Disadvantages: May introduce many small classes for each strategy. Clients must be aware of all strategy options and choose appropriately. Can be overkill if only one or two strategies exist.\

When to use Strategy vs. State?

How to implement adding new strategies (e.g. with factory or registry)?

Advantages over using if/else or switch?

Aspect	If-Else	Strategy Pattern
Scalability	Hard to scale — adding new conditions requires editing the method	Easy to scale — add a new strategy class without touching existing code
Open/Closed Principle	❌ Violates it — must modify code for new logic	✅ Obeys it — extend by adding new strategies
Code Organization	Logic is tangled and grows linearly	Logic is decoupled into separate classes
Testing	Harder to unit test specific branches	Easier — test each strategy in isolation
Maintenance	Prone to bugs as conditions grow	Cleaner and maintainable
Reusability	Logic is hardcoded in one place	Strategies are reusable across contexts

Show how you’d code a strategy in your language (e.g. duck flying behaviors)