Summary - Design patterns

Combine Singleton, Factory and Strategy to write a payment system.

Summary - Design patterns

In this group you learned five core design patterns. Singleton gives a single instance, Factory picks a class, Strategy is a callable algorithm, Observer is subscription notification, Decorator is wrapper extension.

# Singleton + Factory + Strategy combined
reg = Config()  # Singleton
strategy = payment_factory("credit")  # Factory
print(strategy(100))  # Strategy called

In the final step you will combine three patterns to write a payment system.

Exercise Payment system

Define class Config: (Singleton pattern): add _instance = None, method def __new__(cls): does if cls._instance is None: cls._instance = super().__new__(cls) and return cls._instance. Function def credit_pay(amount): does return f"kredi: {amount}". Function def debit_pay(amount): does return f"banka: {amount}". Function def payment_factory(name): does if name == "credit": return credit_pay, if name == "debit": return debit_pay. Get an instance with cfg = Config(). Pick a strategy with strategy = payment_factory("credit"). Print the payment with print(strategy(100)).

Show example solution

class Config:
    _instance = None
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

def credit_pay(amount):
    return f"kredi: {amount}"

def debit_pay(amount):
    return f"banka: {amount}"

def payment_factory(name):
    if name == "credit":
        return credit_pay
    if name == "debit":
        return debit_pay

cfg = Config()
strategy = payment_factory("credit")
print(strategy(100))

Test yourself

Which one guarantees a single instance?
- Factory
- Singleton
- Strategy
- Observer
Show answer

Singleton — Singleton ensures a class has only one instance.
Match the group tools

Singleton

Single instance
Factory

Class pick
Strategy

Callable algorithm
Observer

Subscription

Next lesson: logging.getLogger

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies