23种设计模式python实现（2-结构型模式 ）

在这里，结构型模式包括：
适配器模式、桥接模式、组合模式、修饰器模式、外观模式、享元模式、代理模式。

1 适配器模式

作用：接口的适配
场景：手机充电，我们国家民用电是交流22V，而手机充电时弱电直流5V。需要手机适配器，将220V交流电接口转换为5V直流电接口。
python实现：
建立220V交流电的类：

class AC220V:
    # s输出220V交流电
    def out(self):
        print("220V交流电...")

建立5V直流电的类：

class DC5V(metaclass=ABCMeta):

    # 输出5V直流电
    @abstractmethod
    def out(self):
        print('5V直流电...')

适配器类Adapter的实现

class Adapter(DC5V):
    def out(self):
        print('适配器输入:')
        # 实例220V交流电
        ac220v = AC220V()
        ac220v.out()

        print('适配器输出:')
        super(Adapter, self).out()

2 桥接模式

作用：分离抽象与实现
需求场景：打开灯照亮，进入办公室、回家都需要开灯；
Python实现：
先定义一个抽象的灯：

class Light(metaclass=ABCMeta):

    @abstractmethod
    def turn_on(self):
        pass

    @abstractmethod
    def turn_off(self):
        pass

定义办公室的灯：

class OfficeLight(Light):
    def turn_on(self):
        print('打开办公室的灯:')
        pass

    def turn_off(self):
        print('关闭办公室的灯:')
        pass

定义回家的灯：

class FamilyLight(Light):
    def turn_on(self):
        print('打开家里的灯:')
        pass

    def turn_off(self):
        print('关闭家里的灯:')
        pass

定义回家停电手电筒的灯：

class FlashLight(Light):
    def turn_on(self):
        print('打开家里的灯:')
        pass

    def turn_off(self):
        print('关闭家里的灯:')
        pass

定义一个桥接器的类，可以打开不同的灯：

class Bridge:
    light = None

    def turn_on_flash_light(self):
        self.light = FlashLight()
        self.light.turn_on()

    def turn_on_family_light(self):
        self.light = FamilyLight()
        self.light.turn_on()

    def turn_on_office_light(self):
        self.light = OfficeLight()
        self.light.turn_on()

3 组合模式

作用：整体-部分 树形结构来组合对象
需求场景：公司的组织架构，公司从上到下，每一个员工又包含管理多个员工
Python实现：
定义员工的类：

class Employee:
    name = None  # 姓名
    position = None  # 职位
    level = None  # 级别
    subordinates = []  # 管理的员工数

    def add_employee(self, employee):
        self.subordinates.append(employee)

    def remove_employee(self, employee):
        self.subordinates.remove(employee)

    def get_subordinates(self):
        return self.subordinates

    def set_name(self, name):
        self.name = name

    def get_name(self):
        return self.name

    def set_position(self, position):
        self.position = position

    def get_position(self):
        return self.position

    def set_level(self, level):
        self.level = level

    def get_level(self):
        return self.level

定义组合类，实现员工的创建和遍历：

class Composite:

    def create(self):
        ceo = Employee()
        ceo.set_name('刘备')
        ceo.set_position('祖公')
        ceo.set_level(1)

        general_1 = Employee()
        general_1.set_name('关羽')
        general_1.set_position('将军')
        general_1.set_level(2)
        ceo.add_employee(general_1)

        general_2 = Employee()
        general_2.set_name('张飞')
        general_2.set_position('将军')
        general_2.set_level(2)
        ceo.add_employee(general_2)

        soldier_1 = Employee()
        soldier_1.set_name('李思')
        soldier_1.set_position('士兵')
        soldier_1.set_level(3)
        general_1.add_employee(soldier_1)

        soldier_2 = Employee()
        soldier_2.set_name('王武')
        soldier_2.set_position('士兵')
        soldier_2.set_level(3)
        general_2.add_employee(soldier_2)
        return ceo

    def out(ceo):
        # 对象中list包含下一级list的访问
        print('公司的所有的员工：')
        print(ceo.get_name(), end=" ")
        print(ceo.get_position(), end=" ")
        print(ceo.get_level())
        general_len = len(ceo.get_subordinates())

        for i in range(general_len):
            manager = ceo.get_subordinates().__getitem__(i)
            print(manager.get_name(), end=" ")
            print(manager.get_position(), end=" ")
            print(manager.get_level())

4 修饰器模式

作用：扩展对象的功能
需求场景：软件产品界面刚开始需要一个按钮，实现基本功能就行；后来用户量上来了，需要部分界面的按钮颜色和样式美化一下。基于原来的按钮，扩展两个属性
Python实现：
定义按钮的类：

class Button:
    def __init__(self):
        self.name = 'ok'

定义一个装饰后的按钮：

class DecoratorButton:

    def __init__(self):
        self.button = Button()
        self.color = ''
        self.style = ''

可以测试扩展后按钮的属性：

    decorator_button = DecoratorButton()
    decorator_button.color = '黄色'
    decorator_button.style = '圆角'

    print('按钮的原有属性:')
    print("名称 ", decorator_button.button.name)

    print('按钮的扩展属性:')
    print("颜色 ", decorator_button.color)
    print("样式 ", decorator_button.style)

5 外观模式

作用：所有的功能提供统一对外接口
需求场景：人的嘴可以看做个体人对外的接口，负责呼吸、吃饭、说话。，
Python实现：
定义呼吸系统的类：

class HealthSystem:
    def health(self):
        print('呼吸...')

定义吃饭系统的类：

class EatSystem:
    def eat(self):
        print('吃饭...')

定义说话系统的类：

class SpeakSystem:
    def speak(self):
        print('说话...')

定义一个人，实现统一对外的接口：

class Person:

    def eat(self):
        eat_system = EatSystem()
        eat_system.eat()

    def speak(self):
        speak_system = SpeakSystem()
        speak_system.speak()

    def health(self):
        health_system = HealthSystem()
        health_system.health()

6 享元模式

作用：一个标识码对应一个对象，减少内存使用
需求场景：一个公司只有一个CEO，在多个公司举行论坛等活动登记时，可通过CEO的管理实现公司的管理。
Python实现：
定义CEO的类：

class CEO:
    name = None
    year = None
    sex = None
    company_name = None

    def set_name(self, name):
        self.name = name

    def get_name(self):
        return self.name

    def set_year(self, year):
        self.year = year

    def get_year(self):
        return self.year

    def set_sex(self, sex):
        self.sex = sex

    def get_sex(self):
        return self.sex

    def set_company_name(self, company_name):
        self.company_name = company_name

    def get_company_name(self):
        return self.company_name

定义CEO管理的类：

class CEOFactory:
    pool = dict()

    # 通过公司名称获取CEO
    @classmethod
    def __get_ceo__(cls, company_name):
        ceo = cls.pool.get(company_name)
        if not ceo:
            ceo = CEO.CEO()
            cls.pool.__setitem__(company_name, ceo)
            ceo.set_company_name(company_name)

        return ceo

实现CEO管理的测试：

    ceo = CEOFactory.__get_ceo__('google')
    ceo.name = '桑达尔·皮查伊（Sundar Pichai）'
    print('公司的名称：')
    print(CEOFactory.__get_ceo__('google').company_name)
    print('公司的CEO：')
    print(CEOFactory.__get_ceo__('google').name)

7 代理模式

作用：将复杂的或受保护的业务进行封装，提供统一的对外接口
需求场景：学生申请国外的留学生，办理出国手续，不知道需要哪些材料，如何办理？找到出国代理帮忙办理
Python实现：
定义出国代理的类：

class AbroadAgent:
    def student_abroad(self):
        print("代理:学生出国手续已办好...")

    def travel_abroad(self):
        print("代理:旅游出国手续已办好...")

    def work_abroad(self):
        print("代理:外派工作出国手续已办好...")

定义一个想申请出国留学的学生：

class Person:

    def abroad(self):
        abroad_agent = AbroadAgent()
        abroad_agent.student_abroad()

    # 显示个人的身份
    def show_identity(self):
        print('我是一名清华大学的学生，想申请哥伦比亚大学的博士生...')