聊聊 Python 面试最常被问到的几种设计模式（下）

原创 星安果 AirPython 昨天
来自专辑
综合技能
点击上方“AirPython”，选择“加为星标”
第一时间关注 Python 技术干货！
设计模式（下） - 图1

1. 前言

上篇文章 写到了 Python 最常用的 2 种设计模式，单例模式和工厂模式
本篇文章我们继续聊聊面试中，Python 面试经常被问到的设计模式，即：

  • 构建者模式
  • 代理模式

  • 观察者模式

    2. 构建者模式

    构建者模式，是将一个复杂对象的构造与表现进行分离，利用多个步骤进行创建，同一个构建过程可用于创建多个不同的表现
    简单来说，就是将一个复杂对象实例化的过程，按照自己的想法，一步步设置参数，定制一个我们需要的对象
    构建者模式一般由 Director（指挥官）和 Builder（建设者）构成
    其中：
    Builder 用于定义目标对象部件的方法和参数
    Director 用于构造一个 Builder 的接口，由 Director 去指导 Builder 生成一个复杂的对象
    以购买一辆车（ 包含：准备钱、看车、试驾、购买 4 个步骤）为例
    首先，定义一个车的实体，并定义属性变量
    class Car(object):
    def init(self):
    # 准备的钱
    self.money = None

    1.   # 去哪里看车<br />        self.address = None
    3.   # 试驾什么车<br />        self.car_name = None
    5.   # 购买时间是<br />        self.buy_time = None

    def str(self):
    return “准备了：%s,去%s看车，试驾了%s,下单了，购买时间是：%s” % (self.money, self.address, self.carname, self.buytime)
    然后，创建一个 Builder，实例化一个 Car 对象；针对上面 4 个步骤，通过定义 4 个方法
    分别是：准备多少钱、去哪里看车、试驾什么车、下单购买的时间
    # 创建者
    class CarBuilder(object):
    def __init    (self):
    self.car = Car()

    def ready_money(self, money):
    “””
    准备的金额
    :param money:
    :return:
    """
    self.car.money = money
    sleep(0.5)
    return self

    def see_car(self, address):
    “””
    去哪里看车
    :param address:
    :return:
    """
    self.car.address = address
    sleep(0.5)
    return self

    def test_drive(self, car_name):
    “””
    试驾了什么车
    :param car_name:
    :return:
    """
    self.car.car_name = car_name
    sleep(0.5)
    return self

    def buycar(self, buytime):
    “””
    下单时间
    :param buy_time:
    :return:
    """
    self.car.buy_time = buy_time
    sleep(0.5)
    return self
    接着，创建 Director，创建 build 方法，使用 Builder 一步步构建一个车对象并返回
    class Director(object):
    def __init    (self):
    self.builder = None

    def build(self, builder):
    self.builder = builder
    self.builder. \
    ready_money(“100万”). \
    see_car(“4S店”). \
    test_drive(“奥迪Q7”). \
    buy_car(“2020年8月1日”)

    1.   # 返回构建的对象<br />        return self.builder.car<br />最后使用的时候，只需要实例化一个 Builder 对象和 Director 对象，然后通过 Director 对象构建一个车对象即可<br />if __name__ == '__main__':<br />    # 实例化一个构建者对象<br />    car_builder = CarBuilder()<br />    # 实例化一个负责人<br />    director = Director()

    构建的对象
    car = director.build(car_builder)

    print(car)

    3. 代理模式

    代理模式，会引入一个代理对象以代替真实的对象，解耦调用方和被调用方之间的联系
    Python 中的实现方式也简单易懂
    首先，我们定义一个真实对象实体类，并定义一个方法
    class RealObject(object):
    “””
    实际对象
    """
    def init(self, arg):
    self.arg = arg

    def foo(self):
    print(‘参数值为:’, self.arg)
    然后，创建一个代理对象，在初始化函数 init 中拿到真实对象的实例，定义一个相同的方法，并调用真实对象的方法
    class ProxyObject(object):
    “””
    代理对象
    """
    def init(self, real_object):
    self.real_object = real_object

    def foo(self):
    # 实际对象调用
    self.realobject.foo()
    最后的使用方式如下：
    if name == ‘_main    ‘:
    # 实例化代理对象
    proxy_object = ProxyObject(RealObject(‘AirPython’))
    # 调用方法
    proxy_object.foo()
    如此，就实现了代理替换真实对象的目的

    4. 观察者模式

    观察者模式在 Python 中很常见，会定义了对象之间的一对多依赖关系，当被观察者（也称为主体对象）改变状态时，其他所有观察者都会收到事件并处理预定的事情
    首先，我们创建一个观察者，在初始化函数中注册到被观察对象上，并且自定义一个更新函数 ```python

    观察者

    class Observer(object): def init(self, subject):

    1.   # 初始化观察者，并注册
    2.   subject.register(self)

    def update(self, arg1):

    1.   """获取通知"""
    2.   print('观察者收到监听消息，参数为：', arg1)

然后，新建一个被观察对象，创建注册观察者、注销观察者方法

class Subject(object): def init(self):

  1.     # 所有的观察者
  2.     self.observers = []
  3.     self.foo = None
  4. def register(self, observer):
  5.     """添加观察者"""
  6.     if observer not in self.observers:
  7.         self.observers.append(observer)
  8.     else:
  9.         print('已经存在，添加失败！')
  10. def unregister(self, observer):
  11.     """注销观察者"""
  12.     try:
  13.         self.observers.remove(observer)
  14.     except ValueError:
  15.         print('注销观察者失败')

接着，通过模拟修改变量的值，通知给所有的观察者

def notify(self): “””通知所有的观察者””” for item in self.observers: item.update(self.foo)

def modify_value(self): “”” 修改变量的值 :return: “”” self.foo = “公众号：AirPython”

修改后，通知所有观察者

self.notify()

最后的使用方式如下：

if name == ‘main‘:

  1. # 主体对象
  2. subject = Subject()
  3. # 观察者
  4. observer = Observer(subject)
  5. # 测试
  6. subject.modify_value()

```

5. 最后

这两篇一共介绍了 5 种设计模式，它们在 Python 的各领域中被广泛使用，也是面试中最常被问到的几种设计模式
我已经将文中全部源码上传到后台，关注公众号后回复「 设计模式 」即可获得全部源码
如果你觉得文章还不错，请大家 点赞、分享、留言下，因为这将是我持续输出更多优质文章的最强动力！