1. Responsibility chain model

        The content of the responsibility chain pattern: multiple objects have the opportunity to process the request, so as to avoid the coupling relationship between the sender and receiver of the request. Connect these objects into a chain and pass the request along the chain until an object processes it. The roles of responsibility chain include abstract handler, concrete handler and client.

from abc import ABCMeta, abstractmethod

# Abstract processor
class Handler(metaclass=ABCMeta):
    @abstractmethod
    def handle_leave(self, day):
        pass

# Specific handler
class GeneralManager(Handler):
    def handle_leave(self, day):
        if day <= 30:
            print('Leave granted by the general manager%d' % day)
        else:
            print('You can resign!')

# Specific handler
class DepartmentManager(Handler):
    def __init__(self):
        self.next = GeneralManager()

    def handle_leave(self, day):
        if day <= 7:
            print('Leave granted by project director%d' % day)
        else:
            print('Insufficient authority of Department Manager')
            self.next.handle_leave(day)

# Specific handler
class ProjectDirector(Handler):
    def __init__(self):
        self.next = DepartmentManager()

    def handle_leave(self, day):
        if day <= 3:
            print('Leave granted by project director%d' % day)
        else:
            print('Insufficient authority of project director')
            self.next.handle_leave(day)

day = 20
p = ProjectDirector()
p.handle_leave(day)
"""
Insufficient authority of project director
 Insufficient authority of Department Manager
 Leave granted by the general manager 20
"""

        Usage scenario: there are multiple objects that can process a request, and the processing of which object is determined by the runtime; Submit a request to one of multiple objects without specifying the recipient. The advantage is to reduce the degree of coupling. One object does not need to know which other object handles its request.

2. Observer mode

        Observer mode is widely used, also known as "publish subscribe" mode. It is used to define a one to many dependency between objects. When the state of an object changes, all objects that depend on it are notified and updated automatically. The roles of observer pattern are: abstract topic, concrete topic (publisher), abstract observer and concrete observer (subscriber).

from abc import ABCMeta, abstractmethod

# Abstract subscriber
class Observer(metaclass=ABCMeta):
    @abstractmethod
    def update(self, notice):
        """
        :param notice: Notice Object of class
        :return:
        """
        pass

# Abstract Publisher: it can be an interface. Subclasses do not need to be implemented, so there is no need to define abstract methods!
class Notice:
    def __init__(self):
        self.observers = []

    def attach(self, obs):
        self.observers.append(obs)

    def detach(self, obs):
        self.observers.remove(obs)

    def notify(self):
        """
        Push
        :return:
        """
        for obs in self.observers:
            obs.update(self)

# Specific publisher
class StaffNotice(Notice):
    def __init__(self, company_info):
        super().__init__()  # Call the parent class object to declare the observers property
        self.__company_info = company_info

    @property
    def company_info(self):
        return self.__company_info

    @company_info.setter
    def company_info(self, info):
        self.__company_info = info
        self.notify()

# Specific subscribers
class Staff(Observer):
    def __init__(self):
        self.company_info = None

    def update(self, notice):
        self.company_info = notice.company_info

staff_notice = StaffNotice('Initialize company information')
staff1 = Staff()
staff2 = Staff()
staff_notice.attach(staff1)
staff_notice.attach(staff2)
# print(staff1.company_info) None
# print(staff2.company_info) None
staff_notice.company_info = 'Holiday notice!'
print(staff1.company_info)
print(staff2.company_info)
staff_notice.detach(staff2)
staff_notice.company_info = 'Meeting tomorrow!'
print(staff1.company_info)
print(staff2.company_info)
"""
Holiday notice!
Holiday notice!
Meeting tomorrow!
Holiday notice!
"""

        Usage scenario: when an abstract model has two aspects, one of which depends on the other. Encapsulating the two in independent objects so that they can be changed and reused independently; When changing one object requires changing other objects at the same time, we don't know how many objects need to be changed; When an object must notify other objects, it cannot assume who the other objects are. In other words, you don't want these objects to be tightly coupled. Advantages: the abstract coupling between the target and the observer is minimal; Support broadcast communication.

3. Strategy mode

        Define algorithms, encapsulate them, and make them interchangeable. This pattern allows the algorithm to vary independently of the customers using it. Roles include: Abstract strategy, concrete strategy and context.

from abc import abstractmethod, ABCMeta
from datetime import datetime

# Abstract strategy
class Strategy(metaclass=ABCMeta):
    @abstractmethod
    def execute(self, data):
        pass

# Specific strategies
class FastStrategy(Strategy):
    def execute(self, data):
        print("Use faster policy processing%s" % data)

# Specific strategies
class SlowStrategy(Strategy):
    def execute(self, data):
        print("Use slower policy processing%s" % data)

# context
class Context:
    def __init__(self, strategy, data):
        self.data = data
        self.strategy = strategy
        # You can define things that users don't know
        self.date = datetime.now()

    def set_strategy(self, strategy):
        self.strategy = strategy

    def do_strategy(self):
        self.strategy.execute(self.data)

data = "Hello!"
# Use faster policy processing
fast_strategy = FastStrategy()
context = Context(fast_strategy, data)
context.do_strategy()
# Use slower policy processing
slow_strategy = SlowStrategy()
context = Context(slow_strategy, data)
context.do_strategy()
"""
Use faster policy processing Hello!
Use slower policy processing Hello!
"""

        Advantages: some reusable algorithms and behaviors are defined; Some conditional statements are eliminated; Different implementations of the same behavior can be provided; Disadvantages: customers must understand different strategies.

4. Template method mode

        Content: define the algorithm skeleton in an operation and delay some steps to subclasses. Template method allows subclasses to redefine some specific steps of an algorithm without changing the structure of the algorithm. Using template method requires two roles: abstract class and concrete class. Abstract classes are used to define abstract classes (hook operations) and implement a template method as the skeleton of the algorithm. The role of concrete classes is to realize atomic operations.

from abc import ABCMeta, abstractmethod
from time import sleep

# abstract class
class Window(metaclass=ABCMeta):
    @abstractmethod
    def start(self):  # Atomic operation / hook operation
        pass

    @abstractmethod
    def repaint(self):  # Atomic operation / hook operation
        pass

    @abstractmethod
    def stop(self):  # Atomic operation / hook operation
        pass

    def run(self):
        """
        Template method(Specific method)，This big logic doesn't need to be written by yourself
        :return:
        """
        self.start()
        while True:
            try:
                self.repaint()
                sleep(1)
            except KeyboardInterrupt:
                break
        self.stop()

# concrete class
class MyWindow(Window):
    def __init__(self, msg):
        self.msg = msg

    def start(self):
        print('The window starts running!')

    def stop(self):
        print('Window stop!')

    def repaint(self):
        print(self.msg)

MyWindow("Hello...").run()

        Applicable scenarios of template method: implement the invariant part of an algorithm at one time, and the public behaviors in each subclass should be extracted and concentrated in a common parent class to avoid code duplication; Control subclass extension.