Implementing the Strategy Design Pattern in Python

Implementing the Strategy Design Pattern in Python

As a software developer, it’s crucial to have a firm understanding of design patterns to write clean and maintainable code. One popular design pattern is the Strategy pattern, which allows for dynamic selection of algorithms at runtime. In this blog post, we’ll explore how to implement the Strategy design pattern in Python.

What is the Strategy Design Pattern?

The Strategy design pattern defines a family of interchangeable algorithms and encapsulates each one as a separate class. The pattern enables the algorithms to be selected and used interchangeably based on a specific context or runtime condition.

Implementing the Strategy Design Pattern

Let’s imagine we are building a payment processing system that needs to support multiple payment methods, such as credit card and PayPal. We can use the Strategy design pattern to handle the various payment options flexibly.

class PaymentStrategy:
    def pay(self, amount):

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        # Implement credit card payment logic here
        print(f"Paying ${amount} with Credit Card.")

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        # Implement PayPal payment logic here
        print(f"Paying ${amount} with PayPal.")

class PaymentProcessor:
    def __init__(self, strategy):
        self.strategy = strategy

    def process_payment(self, amount):

In the code snippet shown above, we define an abstract PaymentStrategy class. This class provides a common interface for all payment strategies by exposing a pay method.

Next, we create concrete payment strategies, such as CreditCardPayment and PayPalPayment, by subclassing the PaymentStrategy class. Each concrete strategy class overrides the pay method to implement the payment logic specific to that strategy.

Finally, we create a PaymentProcessor class that takes a payment strategy as a parameter in its constructor. The process_payment method of PaymentProcessor then invokes the pay method of the injected strategy, allowing for dynamic selection and execution of the payment logic.

Usage Example

To demonstrate the usage of our implementation, consider the following code snippet:

credit_card_strategy = CreditCardPayment()
payment_processor = PaymentProcessor(credit_card_strategy)
payment_processor.process_payment(100.00)  # Output: Paying $100.0 with Credit Card.

paypal_strategy = PayPalPayment()
payment_processor = PaymentProcessor(paypal_strategy)
payment_processor.process_payment(50.00)  # Output: Paying $50.0 with PayPal.

In the example above, we first create an instance of CreditCardPayment and pass it to a new instance of PaymentProcessor. We then invoke process_payment on the payment_processor object with the amount to be paid as a parameter. This results in the associated payment strategy being executed.

Similarly, we create an instance of PayPalPayment and pass it to a new instance of PaymentProcessor. Again, invoking process_payment on the payment_processor object triggers the payment strategy specific to PayPal.


The Strategy design pattern provides an elegant solution for managing interchangeable algorithms. By implementing the Strategy pattern, we achieve flexibility and maintainability in our codebase, especially when dealing with multiple variants of a specific behavior.

In this blog post, we explored how to implement the Strategy design pattern in Python. We learned the core concepts behind the pattern and examined a practical example involving payment processing.

Remember, design patterns serve as guidelines for solving common programming problems. Understanding and utilizing patterns like Strategy can significantly enhance your software development skills. Happy coding!

comments powered by Disqus