전략(Strategy) 패턴The Strategy Pattern

The Strategy Pattern

The Strategy Pattern is a behavioral pattern. It defines a family of similar behaviors, encapsulates each one, and makes them interchangeable. It lets you choose and swap algorithms while the program is running.

Use Cases

• Payment systems: Various payment methods such as credit card, cash, and points
• File compression: Various compression algorithms such as ZIP and RAR
• Game characters: Various ways of moving, such as walking and running

Character Movement

Here, we’ll learn about the Strategy pattern by implementing ‘character movement’ (walking, running, and so on) for a game character.

The Situation

Let’s make a game character move. The character can walk, run, and so on. These movements need to be freely changeable during gameplay, and it should be easy to add new ones.

Structure

The Strategy pattern separates its components as follows.

• Context: The object that uses a strategy.
• Strategy: A class that implements the actual algorithm.

Here, the character class that uses a movement strategy is the context, and the classes that implement the actual movement algorithms are the strategies.

The Interface

First, we define the interface that every movement strategy must follow.

from abc import ABC, abstractmethod

class MovementStrategy(ABC):
    @abstractmethod
    def move(self):
        pass

Strategy Classes

Next, we implement the concrete movement strategies. Each strategy implements its own way of moving.

class WalkStrategy(MovementStrategy):
    def move(self):
        print("The character walks. Speed: 5")

class RunStrategy(MovementStrategy):
    def move(self):
        print("The character runs. Speed: 10")

class CrawlStrategy(MovementStrategy):
    def move(self):
        print("The character crawls. Speed: 2")

The Character

Now we create the character class that uses a movement strategy. The character moves according to the currently set strategy. It also has a setter method, set_movement, so the movement can be changed.

class Character:
    def __init__(self, strategy: MovementStrategy):
        self.strategy = strategy
    
    def move(self):
        return self.strategy.move()
    
    def set_movement(self, strategy: MovementStrategy):
        self.strategy = strategy

Running It

Let’s actually create a character and test out various movements.

You can see that the same move behaves differently depending on the strategy the character holds. And through the setter method, you can switch to any other strategy you like.

# Create a character (initial strategy: walk)
character = Character(WalkStrategy())

# Walk
character.move()  # Output: The character walks. Speed: 5

# Switch the strategy to run
character.set_movement(RunStrategy())
character.move()  # Output: The character runs. Speed: 10

# Switch the strategy to crawl
character.set_movement(CrawlStrategy())
character.move()  # Output: The character crawls. Speed: 2

Class Diagram

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'primaryColor': '#2a3844',
      'lineColor': '#fff',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#fff'
    }
  }
}%%
classDiagram
    direction LR

    class MovementStrategy {
        <<interface>>
        +move()
    }
    
    class WalkStrategy {
        +move()
    }
    
    class RunStrategy {
        +move()
    }
    
    class CrawlStrategy {
        +move()
    }
    
    class Character {
        -strategy: MovementStrategy
        +\_\_init\_\_(strategy: MovementStrategy)
        +move()
        +set_movement(strategy: MovementStrategy)
    }
    
    MovementStrategy <|.. WalkStrategy
    MovementStrategy <|.. RunStrategy
    MovementStrategy <|.. CrawlStrategy
    Character o-- MovementStrategy

Benefits of the Strategy Pattern

Using the Strategy pattern gives you these benefits.

• You can add new strategies without modifying existing code.
• You can freely change strategies while the program is running.
• Each strategy is encapsulated independently, which makes the code easier to manage.

Caveats When Using the Strategy Pattern

The Strategy pattern also has caveats to keep in mind. Using many strategy objects is fine, but creating strategy objects carelessly can cause performance problems.

Caveat: Memory Management

class Character:
    def __init__(self):
        self._current_strategy = WalkStrategy()

    def set_movement(self, movement_type: str):
        # Creating a new strategy object every time
        match movement_type 
            case "walk":
                self._current_strategy = WalkStrategy()  # Object creation cost
            case "run":
                self._current_strategy = RunStrategy()   # Object creation cost

Solution: Use the Singleton Pattern

With the Singleton pattern, you can make sure each strategy object is created only once and then reused. As shown below, you can manage object creation by combining the Singleton pattern with the Factory pattern.

class MovementStrategyFactory:
    _strategies = {}  # Cache strategy objects in a class variable
    
    @classmethod
    def get_strategy(cls, movement_type: str) -> MovementStrategy:
        # Reuse the strategy if it has already been created
        if movement_type not in cls._strategies:
            # Create the strategy object only on the first request (lazy initialization)
            match movement_type 
                case "walk":
                    cls._strategies[movement_type] = WalkStrategy()
                case "run":
                    cls._strategies[movement_type] = RunStrategy()
                case "crawl":
                    cls._strategies[movement_type] = CrawlStrategy()
        return cls._strategies[movement_type]
# Usage example
class Character:
    def __init__(self):
        # Get the strategy through the Factory at initialization
        self._current_strategy = MovementStrategyFactory.get_strategy("walk")
    
    def set_movement(self, movement_type: str):
        # Reuse through the Factory when changing strategies, too
        self._current_strategy = MovementStrategyFactory.get_strategy(movement_type)

Wrapping Up

The Strategy pattern is a useful design pattern when algorithms are frequently swapped or extended. In particular, it follows the Open-Closed Principle (OCP) well and is worth considering when designing extensible systems.

1. When there’s a family of algorithms that play similar roles
2. When you need to choose and swap algorithms at runtime
3. When variations of an algorithm come up often

You can use it in many situations, such as different sorting algorithms, file compression methods, and discount policies. 😊