设计模式-结构型模式（适配器、桥、组合、装饰器、外观、亨元、代理）

结构型模式

Structural Pattern

适配器模式

Adapter Pattern

适配器模式(Adapter Pattern)：用于将一个类的接口转换成客户端期望的另一种接口。

该模式可让原本由于接口不兼容而不能一起工作的类能协同工作。
如，定义了一个英文翻译类，现需适配成中文翻译类，那么就可以使用适配器模式，在构造方法中构造英文类，再去实现中文方法

class EnglishSpeaker:
    def say_hello(self):
        print("Hello!")


class ChineseTranslator:
    def __init__(self, english_speaker):
        self.english_speaker = english_speaker

    def speak_chinese(self):
        print("你好！")

    def translate(self):
        self.speak_chinese()  # "你好！"
        self.english_speaker.say_hello()  # "Hello!"


english_speaker = EnglishSpeaker()
chinese_translator = ChineseTranslator(english_speaker)
chinese_translator.translate()  # 你好！ Hello!

桥模式

Bridge Pattern

桥接模式(Bridge Pattern)：将抽象部分和实现部分分离开，以便它们可以独立地变化。
例如，在游戏中有多种武器和角色，我们可以使用桥接模式将武器和角色分离开来，从而可自由地组合它们。

class Weapon:
    def __init__(self, name):
        self.name = name


class Sword(Weapon):
    def attack(self):
        print(f"{self.name} is attacking with sword!")


class Bow(Weapon):
    def attack(self):
        print(f"{self.name} is attacking with bow!")


class Character:
    def __init__(self, name, weapon):
        self.name = name
        self.weapon = weapon

    def attack(self):
        self.weapon.attack()


class Warrior(Character):
    pass


class Mage(Character):
    pass


sword = Sword("Excalibur")
bow = Bow("Robin Hood's Bow")
warrior = Warrior("Arthur", sword)
mage = Mage("Merlin", bow)

warrior.attack()  # Arthur is attacking with sword!
mage.attack()  # Merlin is attacking with bow!

组合模式

Composite Pattern

组合模式(Composite Pattern): 将对象组合成树形结构以表示“整体-部分”层次结构。
如，在一个文件系统中，一个文件夹可以包含多个文件和子文件夹，可用组合模式来表示这个文件系统的结构。

class File:
    def __init__(self, name):
        self.name = name

    def display(self, indent=''):
        print(f"{indent}- {self.name}")


class Folder:
    def __init__(self, name):
        self.name = name
        self.children = []

    def add(self, child):
        self.children.append(child)

    def remove(self, child):
        self.children.remove(child)

    def display(self, indent=''):
        print(f"{indent}+ {self.name}")
        for child in self.children:
            child.display(indent + '  ')


folder1 = Folder("Folder 1")
folder2 = Folder("Folder 2")
file1 = File("File 1")
file2 = File("File 2")
file3 = File("File 3")

folder1.add(file1)
folder1.add(folder2)
folder2.add(file2)
folder2.add(file3)

folder1.display()
'''
+ Folder 1
  - File 1
  + Folder 2
    - File 2
    - File 3
'''

装饰器模式

Decorator Pattern

装饰器模式(Decorator Pattern): 用于动态地给一个对象添加一些新功能，同时不影响对象。

如，一个文本编辑器中，可以来给文本添粗、斜体等样式。

def decorator(func):
    def wrapper(*args, **kwargs):
        print("Before function call")
        result = func(*args, **kwargs)
        print("After function call")
        return result

    return wrapper


@decorator
def some_function():
    print("Function called")


some_function()
'''
Before function call
Function called
After function call
'''

外观模式

Facade Pattern
 

提供一个简单的接口，用于访问底层复杂系统的一些功能。相当于向上屏蔽。

class SubsystemA:
    def operation_a(self):
        pass


class SubsystemB:
    def operation_b(self):
        pass


class Facade:
    def __init__(self):
        self._subsystem_a = SubsystemA()
        self._subsystem_b = SubsystemB()

    def operation(self):
        self._subsystem_a.operation_a()
        self._subsystem_b.operation_b()


facade = Facade()
facade.operation()

亨元模式

Flyweight Pattern

 允许将对象共享以节省内存和提高性能。Python 中，可使用缓存实现享元模式。

class Flyweight:
    def __init__(self, shared_state):
        self._shared_state = shared_state

    def operation(self, unique_state):
        s = f"shared ({self._shared_state}) and unique ({unique_state})"
        print(s)


class FlyweightFactory:
    _flyweights = {}

    def get_flyweight(self, shared_state):
        if shared_state not in self._flyweights:
            self._flyweights[shared_state] = Flyweight(
                shared_state)
        return self._flyweights[shared_state]


factory = FlyweightFactory()
flyweight1 = factory.get_flyweight("state1")
flyweight2 = factory.get_flyweight("state1")
flyweight3 = factory.get_flyweight("state2")
flyweight4 = factory.get_flyweight("state2")

flyweight1.operation("unique1")
flyweight2.operation("unique2")
flyweight3.operation("unique3")
flyweight4.operation("unique4")
"""
shared (state1) and unique (unique1)
shared (state1) and unique (unique2)
shared (state2) and unique (unique3)
shared (state2) and unique (unique4)
"""

代理模式

Proxy Pattern

允许你提供一个代理对象作为另一个对象的接口。控制着对原始对象的访问，并允许创建一些附加行为，例如记录请求日志、缓存数据等。


Subject 是抽象类或接口，定义了 request() 方法的基本契约。RealSubject 实现了 Subject 接口，并实现了具体的 request() 方法。
Proxy 也实现了 Subject 接口，并包含一个 RealSubject 对象的引用。在执行请求之前，Proxy 首先检查用户的访问权限，
然后将请求转发给 RealSubject。通过使用 Proxy 对象，我们可以附加一些额外的功能，例如记录请求日志或缓存数据，而不改变 RealSubject 的代码。

class Subject:
    def request(self):
        pass


class RealSubject(Subject):
    def request(self):
        print("RealSubject: Handling request.")


class Proxy(Subject):
    def __init__(self, real_subject: RealSubject):
        self._real_subject = real_subject

    def request(self):
        if self.check_access():
            self._real_subject.request()

    def check_access(self):
        print("Checking access prior to executing the request.")
        return True


real_subject = RealSubject()
proxy = Proxy(real_subject)

proxy.request()  
# "Checking access prior to executing the request."