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

1. 前言

上篇文章 写到了 Python 最常用的 2 种设计模式,单例模式和工厂模式

本篇文章我们继续聊聊面试中,Python 面试经常被问到的设计模式,即:

  • 构建者模式

  • 代理模式

  • 观察者模式

2. 构建者模式

构建者模式,是将一个复杂对象的构造与表现进行分离,利用多个步骤进行创建,同一个构建过程可用于创建多个不同的表现

简单来说,就是将一个复杂对象实例化的过程,按照自己的想法,一步步设置参数,定制一个我们需要的对象

构建者模式一般由 Director(指挥官)和 Builder(建设者)构成

其中:

Builder 用于定义目标对象部件的方法和参数

Director 用于构造一个 Builder 的接口,由 Director 去指导 Builder 生成一个复杂的对象

以购买一辆车( 包含:准备钱、看车、试驾、购买 4 个步骤)为例

首先,定义一个车的实体,并定义属性变量

class Car(object):
    def __init__(self):
        # 准备的钱
        self.money = None

# 去哪里看车
        self.address = None

# 试驾什么车
        self.car_name = None

# 购买时间是
        self.buy_time = None

def __str__(self):
        return "准备了:%s,去%s看车,试驾了%s,下单了,购买时间是:%s" % (self.money, self.address, self.car_name, self.buy_time)

然后,创建一个 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 buy_car(self, buy_time):
        """
        下单时间
        :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日")

# 返回构建的对象
        return self.builder.car

最后使用的时候,只需要实例化一个 Builder 对象和 Director 对象,然后通过 Director 对象构建一个车对象即可

if __name__ == '__main__':
    # 实例化一个构建者对象
    car_builder = CarBuilder()
    # 实例化一个负责人
    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.real_object.foo()

最后的使用方式如下:
if __name__ == '__main__':
    # 实例化代理对象
    proxy_object = ProxyObject(RealObject('AirPython'))
    # 调用方法
    proxy_object.foo()
如此,就实现了代理替换真实对象的目的

4. 观察者模式

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

def __init__(self, subject):
        # 初始化观察者,并注册
        subject.register(self)

def update(self, arg1):
        """获取通知"""
        print('观察者收到监听消息,参数为:', arg1)

然后,新建一个被观察对象,创建注册观察者、注销观察者方法
class Subject(object):

def __init__(self):
        # 所有的观察者
        self.observers = []
        self.foo = None

def register(self, observer):
        """添加观察者"""
        if observer not in self.observers:
            self.observers.append(observer)
        else:
            print('已经存在,添加失败!')

def unregister(self, observer):
        """注销观察者"""
        try:
            self.observers.remove(observer)
        except ValueError:
            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__':
    # 主体对象
    subject = Subject()
    # 观察者
    observer = Observer(subject)

# 测试
    subject.modify_value()

5. 最后

这两篇一共介绍了 5 种设计模式,它们在 Python 的各领域中被广泛使用,也是面试中最常被问到的几种设计模式

(0)

相关推荐