python中的设计模式

代码环境：python3.6

单例模式

单例模式，能够确保某个类只有一个实例存在。

from threading import Thread, Lock


class Singleton:
    """线程安全的单例模式"""
    _instance_lock = Lock()
    _init_lock = Lock()

    def __new__(cls, *args, **kwargs):
        # 确保只有一个实例
        with Singleton._instance_lock:
            if not hasattr(Singleton, '_instance'):
                print('first new')
                Singleton._instance = object.__new__(cls)
        return Singleton._instance

    def __init__(self):
        # 只运行一次init
        with Singleton._init_lock:
            if not hasattr(Singleton, '_first_init'):
                print('first init')
                Singleton._first_init = True


def task(i):
    obj = Singleton()
    print(f'Thread-{i}: {obj}')


if __name__ == "__main__":
    for i in range(10):
        t = Thread(target=task, args=(i, ))
        t.start()

装饰器模式

咱们给一个对象扩展附加功能有多种方式，装饰器模式就是其中一种。

不少编程语言中，装饰器模式经过继承实现，在 python 中可使用内置的装饰器功能。

须要注意的是，实现装饰器模式只是 python 装饰器的其中一个用法，python 装饰器实际上能作的事情比装饰器模式多得多。

对于 python 装饰器的更多介绍，有兴趣的朋友能够看我另外一篇文章：python中的装饰器

工厂模式

工厂模式，就是咱们能够经过一个指定的“工厂”得到须要的“产品”。在这种模式中，用户只需经过固定的接口而不是直接去调用类的实例化方法来得到一个对象实例，隐藏了实例建立过程的复杂度，解耦了生产实例和使用实例的代码，下降了维护的复杂性。

1. 简单工厂模式

假如咱们有一个简单的汽车工厂，只生产两种汽车，奔驰和宝马：

class Benz:
    """奔驰"""
    def __repr__(self):
        return 'This is Benz'


class BMW:
    """宝马"""
    def __repr__(self):
        return 'This is BMW'


class CarFactory:
    """简单工厂，根据类型生产汽车"""
    def produce_car(self, typename):
        if typename == 'benz':
            return Benz()
        elif typename == 'bmw':
            return BMW()


def main():
    """
    有了上面的简单工厂类，咱们能够经过向固定的接口传入参数得到想要的汽车对象
    """
    car_factory = CarFactory()
    car1 = car_factory.produce_car('benz')
    car2 = car_factory.produce_car('bmw')
    print(f'car1: {car1}')
    print(f'car2: {car2}')


if __name__ == "__main__":
    main()

2. 工厂方法模式

上面咱们有了一个简单的工厂，但若是咱们要新增一个产品奥迪汽车，除了要新增长一个Audi类以外，还要修改CarFactory中的produce_car方法，这样不利于之后的扩展。

因此咱们在简单工厂的基础上，抽象出不一样的工厂，每一个工厂对应生产本身的产品，这就是工厂方法。

class Benz:
    """奔驰"""
    def __repr__(self):
        return 'This is Benz'


class BMW:
    """宝马"""
    def __repr__(self):
        return 'This is BMW'


class AbsFactory:
    """抽象工厂"""
    def produce_car(self):
        # 只定义了方法，并无实现，具体功能在子类中实现
        pass


class BenzFactory(AbsFactory):
    """奔驰工厂"""
    def produce_car(self):
        return Benz()


class BMWFactory(AbsFactory):
    """宝马工厂"""
    def produce_car(self):
        return BMW()


def main():
    """
    咱们能够经过特定的工厂来得到特定的产品
    """
    car1 = BenzFactory().produce_car()
    car2 = BMWFactory().produce_car()
    print(f'car1: {car1}')
    print(f'car2: {car2}')


if __name__ == "__main__":
    main()

原型模式

原型模式有助于咱们建立一个对象的克隆。在最简单的版本中，原型模式只是一个接受对象做为入参并返回这个对象克隆的clone函数。

在 python 中并无提到原型模式，由于已经内置了copy.deepcopy函数实现了。