设计模式-行为型模式（模板方法、策略、观察者、迭代器、责任链、命令、状态、备忘录、访问者、中介者、解释器）

一路向东_

已于 2023-06-07 00:47:03 修改

阅读量677

点赞数 1

分类专栏：设计模式文章标签：设计模式

于 2023-06-06 15:50:26 首次发布

本文链接：https://blog.csdn.net/lxd_max/article/details/131057032

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

行为型模式：专注于对象之间的协作及如何通过彼此之间的交互来完成任务。行为型模式通常集中在描述对象之间的责任分配和通信机制，并提供了一些优雅解决特定问题的方案。

模板方法模式(Template Method Pattern)
策略模式(Strategy Pattern)
观察者模式(Observer Pattern)
迭代器模式(Iterator Pattern)
责任链模式(Chain of Responsibility Pattern)
命令模式(Command Pattern)
状态模式(State Pattern)
备忘录模式(Memento Pattern)
访问者模式(Visitor Pattern)
中介者模式(Mediator Pattern)
解释器模式(Interpreter Pattern)

模板方法模式(Template Method Pattern)

模板方法模式定义了一个算法骨架，将一些步骤延迟到子类中实现。这个模式使得子类可以不改变一个算法的结构即可重定义该算法的某些步骤。

from abc import ABC, abstractmethod


class Algorithm(ABC):
    def process_data(self, data):
        self.load_data(data)
        self.analyze_data()
        self.visualize_data()

    @abstractmethod
    def load_data(self, data):
        pass

    @abstractmethod
    def analyze_data(self):
        pass

    @abstractmethod
    def visualize_data(self):
        pass


class AudioProcessing(Algorithm):
    def load_data(self, data):
        print("Loading audio data...")

    def analyze_data(self):
        print("Analyzing audio data...")

    def visualize_data(self):
        print("Visualizing audio data...")


class ImageProcessing(Algorithm):
    def load_data(self, data):
        print("Loading image data...")

    def analyze_data(self):
        print("Analyzing image data...")

    def visualize_data(self):
        print("Visualizing image data...")


audio_processing = AudioProcessing()
image_processing = ImageProcessing()
audio_processing.process_data("Audio data")
image_processing.process_data("Image data")
"""
Loading audio data...
Analyzing audio data...
Visualizing audio data...
Loading image data...
Analyzing image data...
Visualizing image data...
"""

策略模式(Strategy Pattern)

策略模式定义了一系列算法，并将每个算法封装起来，再一个对外使用的类使得它们可以相互替换。

from abc import ABC, abstractmethod


class SortingStrategy(ABC):
    @abstractmethod
    def sort(self, data):
        pass


class MergeSort(SortingStrategy):
    def sort(self, data):
        print("Sorting data using merge sort...")


class QuickSort(SortingStrategy):
    def sort(self, data):
        print("Sorting data using quick sort...")


class BubbleSort(SortingStrategy):
    def sort(self, data):
        print("Sorting data using bubble sort...")


class Sorter:
    def __init__(self, sorting_strategy):
        self.sorting_strategy = sorting_strategy

    def set_sorting_strategy(self, sorting_strategy):
        self.sorting_strategy = sorting_strategy

    def sort_data(self, data):
        self.sorting_strategy.sort(data)


data = [5, 2, 4, 1, 3]
merge_sort = MergeSort()
quick_sort = QuickSort()
bubble_sort = BubbleSort()

sorter = Sorter(merge_sort)
sorter.sort_data(data)

sorter.set_sorting_strategy(quick_sort)
sorter.sort_data(data)

sorter.set_sorting_strategy(bubble_sort)
sorter.sort_data(data)
"""
Sorting data using merge sort...
Sorting data using quick sort...
Sorting data using bubble sort...
"""

观察者模式(Observer Pattern)

定义一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，并在主题对象变化时得到通知。这个模式使主题对象和观察者对象可以相互独立变化。

class Subject:
    def __init__(self):
        self.observers = []

    def add_observer(self, observer):
        self.observers.append(observer)

    def remove_observer(self, observer):
        self.observers.remove(observer)

    def notify_observers(self, data):
        for observer in self.observers:
            observer.update(data)


class Observer:
    def update(self, data):
        pass


class Sensor(Subject):
    def read_sensor_data(self):
        data = 42  # read sensor data here
        self.notify_observers(data)


class Display(Observer):
    def update(self, data):
        print(f"Displaying sensor data: {data}")


class Logging(Observer):
    def update(self, data):
        print(f"Logging sensor data: {data}")


sensor = Sensor()
display = Display()
logging = Logging()

sensor.add_observer(display)
sensor.add_observer(logging)

sensor.read_sensor_data()
"""
Displaying sensor data: 42
Logging sensor data: 42
"""

迭代器模式(Iterator Pattern)

提供一种方法来访问一个聚合对象中各个元素，而不需暴露该对象的内部表示。这个模式使得我们可以遍历一个聚合对象，而不用关心其内部结构。

class MyList:
    def __init__(self):
        self.data = []

    def add_item(self, item):
        self.data.append(item)

    def __iter__(self):
        return MyListIterator(self)


class MyListIterator:
    def __init__(self, my_list):
        self.my_list = my_list
        self.index = 0

    def __next__(self):
        if self.index >= len(self.my_list.data):
            raise StopIteration
        else:
            item = self.my_list.data[self.index]
            self.index += 1
            return item


my_list = MyList()
my_list.add_item("a")
my_list.add_item("b")
my_list.add_item("c")

for item in my_list:
    print(item)
'''
a
b
c
'''

责任链模式(Chain of Responsibility Pattern)

将请求的发送者和接收者解耦，使得多个对象都有机会处理这个请求。这个模式将这些对象组成一条链，并沿着该链传递该请求，直到有一个对象处理它为止。

from abc import ABC, abstractmethod


class Handler(ABC):
    def __init__(self, successor=None):
        self.successor = successor

    def handle_request(self, request):
        if self.can_handle_request(request):
            self.process_request(request)
        elif self.successor is not None:
            self.successor.handle_request(request)

    @abstractmethod
    def can_handle_request(self, request):
        pass

    @abstractmethod
    def process_request(self, request):
        pass


class ConcreteHandlerA(Handler):
    def can_handle_request(self, request):
        return request >= 0 and request < 3

    def process_request(self, request):
        print(f"Request {request} handled by ConcreteHandlerA")


class ConcreteHandlerB(Handler):
    def can_handle_request(self, request):
        return request >= 3 and request < 6

    def process_request(self, request):
        print(f"Request {request} handled by ConcreteHandlerB")


class ConcreteHandlerC(Handler):
    def can_handle_request(self, request):
        return request >= 6 and request < 9

    def process_request(self, request):
        print(f"Request {request} handled by ConcreteHandlerC")


handler_a = ConcreteHandlerA()
handler_b = ConcreteHandlerB()
handler_c = ConcreteHandlerC()

handler_a.successor = handler_b
handler_b.successor = handler_c

for request in range(1, 10):
    handler_a.handle_request(request)
"""
Request 1 handled by ConcreteHandlerA
Request 2 handled by ConcreteHandlerA
Request 3 handled by ConcreteHandlerB
Request 4 handled by ConcreteHandlerB
Request 5 handled by ConcreteHandlerB
Request 6 handled by ConcreteHandlerC
Request 7 handled by ConcreteHandlerC
Request 8 handled by ConcreteHandlerC
"""

命令模式(Command Pattern)

一个请求封装成一个对象，从而可将请求的发送者和接收者解耦。这个模式允许使用不同的请求来参数化对象，将请求排队或记录请求日志，以及支持可撤销的操作。

from abc import ABC, abstractmethod


class Command(ABC):
    @abstractmethod
    def execute(self):
        pass

    @abstractmethod
    def undo(self):
        pass


class Light:
    def on(self):
        print("Light is on")

    def off(self):
        print("Light is off")


class LightOnCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.on()

    def undo(self):
        self.light.off()


class LightOffCommand(Command):
    def __init__(self, light):
        self.light = light

    def execute(self):
        self.light.off()

    def undo(self):
        self.light.on()


class RemoteControl:
    def __init__(self):
        self.commands = []

    def add_command(self, command):
        self.commands.append(command)

    def execute_commands(self):
        for command in self.commands:
            command.execute()


light = Light()
light_on_command = LightOnCommand(light)
light_off_command = LightOffCommand(light)

remote_control = RemoteControl()
remote_control.add_command(light_on_command)
remote_control.add_command(light_off_command)

remote_control.execute_commands()
"""
Light is on
Light is off
"""

状态模式(State Pattern)

允许对象在其内部状态发生改变时改变它的行为。这个模式将一个对象的状态从该对象中移出来，并将其封装到不同的状态对象中。

from abc import ABC, abstractmethod


class State(ABC):
    @abstractmethod
    def handle(self):
        pass


class ConcreteStateA(State):
    def handle(self):
        print("Handling state A")
        return ConcreteStateB()


class ConcreteStateB(State):
    def handle(self):
        print("Handling state B")
        return ConcreteStateC()


class ConcreteStateC(State):
    def handle(self):
        print("Handling state C")
        return ConcreteStateA()


class Context:
    def __init__(self, initial_state):
        self.state = initial_state

    def request(self):
        self.state = self.state.handle()


context = Context(ConcreteStateA())
context.request()
context.request()
context.request()
"""
Handling state A
Handling state B
Handling state C
"""

备忘录模式(Memento Pattern)

允许在不破坏封装性的前提下，捕获并保存一个对象的内部状态，以便可以将该对象恢复到原先保存的状态。这个模式通常用于需要撤销操作的场景。

class Memento:  # 一个类记录状态返回状态
    def __init__(self, state):
        self.state = state

    def get_state(self):
        return self.state


class Originator:
    def __init__(self, state):
        self.state = state

    def create_memento(self):
        return Memento(self.state)

    def restore_memento(self, memento):
        self.state = memento.get_state()

    def set_state(self, state):
        self.state = state

    def get_state(self):
        return self.state


class Caretaker:
    def __init__(self, originator):
        self.mementos = []
        self.originator = originator

    def save_state(self):
        memento = self.originator.create_memento()
        self.mementos.append(memento)

    def restore_last_state(self):
        if len(self.mementos) > 0:
            memento = self.mementos.pop()
            self.originator.restore_memento(memento)


originator = Originator("State A")
caretaker = Caretaker(originator)

print(originator.get_state())
caretaker.save_state()

originator.set_state("State B")
print(originator.get_state())

caretaker.save_state()
originator.set_state("State C")
print(originator.get_state())

caretaker.restore_last_state()
print(originator.get_state())

caretaker.restore_last_state()
print(originator.get_state())
"""
State A
State B
State C
State B
State A
"""

访问者模式(Visitor Pattern)

定义了一种新的操作方式，可在不改变一个对象的类的前提下，向该对象添加新的操作。这个模式通常用于需对一个复杂的对象结构进行处理的场景。

from abc import ABC, abstractmethod


class Visitor(ABC):
    @abstractmethod
    def visit_element_a(self, element_a):
        pass

    @abstractmethod
    def visit_element_b(self, element_b):
        pass


class Element(ABC):
    @abstractmethod
    def accept(self, visitor):
        pass


class ConcreteElementA(Element):  # 新操作
    def accept(self, visitor):
        visitor.visit_element_a(self)


class ConcreteElementB(Element):  # 新操作
    def accept(self, visitor):
        visitor.visit_element_b(self)


class ConcreteVisitor1(Visitor):
    def visit_element_a(self, element_a):
        print("ConcreteVisitor1 visiting ConcreteElementA")

    def visit_element_b(self, element_b):
        print("ConcreteVisitor1 visiting ConcreteElementB")


class ConcreteVisitor2(Visitor):
    def visit_element_a(self, element_a):
        print("ConcreteVisitor2 visiting ConcreteElementA")

    def visit_element_b(self, element_b):
        print("ConcreteVisitor2 visiting ConcreteElementB")


elements = [ConcreteElementA(), ConcreteElementB()]
visitors = [ConcreteVisitor1(), ConcreteVisitor2()]

for element in elements:
    for visitor in visitors:
        element.accept(visitor)
'''
ConcreteVisitor1 visiting ConcreteElementA
ConcreteVisitor2 visiting ConcreteElementA
ConcreteVisitor1 visiting ConcreteElementB
ConcreteVisitor2 visiting ConcreteElementB
'''

中介者模式(Mediator Pattern)

定义了一个中介对象来封装一系列对象之间的交互。这个模式使得各对象之间不需要显式地相互引用，从而使其耦合度降低，同时也有助于复杂系统的维护。

from abc import ABC, abstractmethod


class Colleague(ABC):
    def __init__(self, mediator):
        self.mediator = mediator

    @abstractmethod
    def send(self, message):
        pass

    @abstractmethod
    def receive(self, message):
        pass


class ConcreteColleagueA(Colleague):
    def send(self, message):
        self.mediator.send_message(message, self)

    def receive(self, message):
        print(f"ConcreteColleagueA received message: {message}")


class ConcreteColleagueB(Colleague):
    def send(self, message):
        self.mediator.send_message(message, self)

    def receive(self, message):
        print(f"ConcreteColleagueB received message: {message}")


class Mediator:
    def __init__(self):
        self.colleagues = []

    def add_colleague(self, colleague):
        self.colleagues.append(colleague)

    def send_message(self, message, sender):
        for colleague in self.colleagues:
            if colleague != sender:
                colleague.receive(message)


mediator = Mediator()
# 创建
colleague_a = ConcreteColleagueA(mediator)
colleague_b = ConcreteColleagueB(mediator)
# 注册
mediator.add_colleague(colleague_a)
mediator.add_colleague(colleague_b)
# 通过中介对象
colleague_a.send("Hello, colleague B")
colleague_b.send("Hi, colleague A")
"""
ConcreteColleagueB received message: Hello, colleague B
ConcreteColleagueA received message: Hi, colleague A
"""

解释器模式(Interpreter Pattern)

定义了一个语言的文法，且建立一个解释器来解释该语言中的句子。这个模式常用于需对一些特定语言进行处理或解析的场景。

from abc import ABC, abstractmethod


class Expression(ABC):
    @abstractmethod
    def interpret(self):
        pass


class NumberExpression(Expression):
    def __init__(self, number):
        self.number = number

    def interpret(self):
        return self.number


class PlusExpression(Expression):
    def __init__(self, expression1, expression2):
        self.expression1 = expression1
        self.expression2 = expression2

    def interpret(self):
        return self.expression1.interpret() + self.expression2.interpret()


class MinusExpression(Expression):
    def __init__(self, expression1, expression2):
        self.expression1 = expression1
        self.expression2 = expression2

    def interpret(self):
        return self.expression1.interpret() - self.expression2.interpret()


expression = MinusExpression(
    PlusExpression(NumberExpression(5), NumberExpression(3)),
    NumberExpression(2)
)

print(expression.interpret())  # 6

一路向东_

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
设计模式-行为型模式（模板方法、策略、观察者、迭代器、责任链、命令、状态、备忘录、访问者、中介者、解释器）

行为型模式：专注于对象之间的及如何通过彼此之间的交互来完成任务。行为型模式通常集中在描述对象之间的分配和机制，并提供了一些优雅解决特定问题的方案。
复制链接

扫一扫