Python设计模式大全

简介

Python 是一种高级、高性能、动态编程语言，因其简单易读和灵活性而受到广泛的欢迎。在 Python 中，设计模式是解决问题或问题系列的经验总结。对于初学者，学习设计模式对于提高代码的效率和准确性非常重要。在这里，我们将介绍 Python 的一些最流行的设计模式，这些设计模式对于 Python 程序员来说是必须要学习的。

设计模式分类

Python设计模式通常可以分为三类:

1. 创建型设计模式: 处理对象的创建机制，封装了对象的创建过程，从而增强了对象的灵活性与可配置性。
2. 行为型设计模式: 关注对象之间的通信和相互作用，以及在不同的对象间接收处理消息的方式。
3. 结构型设计模式: 处理对象在应用内组合的方式，从而可以组合出更加复杂的结构。

创建型设计模式

工厂模式

工厂模式是一种创建对象的方法，这种方法将对象的创建委托给工厂类，而不是直接在代码中创建对象。这种方式可以隐藏对象的创建细节，从而简化了代码逻辑。

示例：

我们有一个动物园，里面有不同种类的鸟类。我们需要编写代码，例如：当我们调用这个 BirdFactory 的时候，它将对应的鸟类实例化并返回：

from abc import ABCMeta, abstractmethod
class Bird(metaclass=ABCMeta):
    """
    Abstract class of Bird
    """
    @abstractmethod
    def fly(self):
        pass
class Pigeon(Bird):
    """
    Class of Pigeon
    """
    def fly(self):
        print("Pigeon can fly")
class Sparrow(Bird):
    """
    Class of Sparrow
    """
    def fly(self):
        print("Sparrow can fly")
class BirdFactory:
    @staticmethod
    def create_bird(bird_type):
        """
        create bird method
        """
        if bird_type == 'Pigeon':
            return Pigeon()
        elif bird_type == 'Sparrow':
            return Sparrow()
        else:
            return None
bird_factory = BirdFactory()
pigeon = bird_factory.create_bird('Pigeon')
pigeon.fly()

运行上述代码将会输出: "Pigeon can fly"。

单例模式

单例模式保证了一个类只能有一个实例。这种方式非常适用于管理资源，例如线程池、数据库连接等。单例模式可以保证程序中只有一个实例，从而提高了资源的利用效率。

示例：

我们有一个日志类，我们确信在代码中只要有一个日志对象即可。

class Logger:
    __instance = None
    def __init__(self):
        if Logger.__instance != None:
            raise Exception("You cannot create more than one instance")
        else:
            Logger.__instance = self
    @staticmethod 
    def get_instance():
        if Logger.__instance == None:
            Logger()
        return Logger.__instance
logger1 = Logger.get_instance()
logger2 = Logger.get_instance()
print(logger1)
print(logger2)

运行上述代码将会输出相同的内存地址。

行为型设计模式

观察者模式

观察者模式是一种常用的行为模式。在这种模式中，当一个对象的状态发生变化时，依赖它的所有对象都将自动得到通知。观察者模式下，一个被观察的主题被观察者观察，当主题变化时，观察者将会收到通知并做出相应的更新。这种模式可以降低主题和观察者之间的耦合度。

示例：

我们有一组股票，需要在股票价格变化时通知其它的观察者。

from abc import ABCMeta, abstractmethod
class Subject(object):
    def __init__(self):
        self.observers = []
    def attach(self, observer):
        self.observers.append(observer)
    def detach(self, observer):
        self.observers.remove(observer)
    def notify(self, **kwargs):
        for observer in self.observers:
            observer.update(**kwargs)
class Stock(Subject):
    def __init__(self):
        super().__init__()
        self._name = None
        self._price = None
    def set_price(self, name, price):
        self._name = name
        self._price = price
        self.notify(name=name, price=price)
class Observer(metaclass=ABCMeta):
    @abstractmethod
    def update(self, **kwargs):
        pass 
class InvestorA(Observer):
    def __init__(self, name):
        self._name = name
    def update(self, **kwargs):
        print('Investor A: %s price is %s' %
              (kwargs['name'], kwargs['price']))
class InvestorB(Observer):
    def __init__(self, name):
        self._name = name
    def update(self, **kwargs):
        print('Investor B: %s price is %s' %
              (kwargs['name'], kwargs['price']))
stock = Stock()
investora = InvestorA('InvestorA')
investorb = InvestorB('InvestorB')
stock.attach(investora)
stock.attach(investorb)
stock.set_price('GOOG', 200)
stock.set_price('AAPL', 250)

运行上述代码将会输出：Investor A: GOOG price is 200、Investor B: GOOG price is 200、Investor A: AAPL price is 250、Investor B: AAPL price is 250。

结构型设计模式

代理模式

代理模式是一种常用的设计模式，它可以为其他对象提供一种代理以控制对这个对象的访问。代理类负责客户端请求，同时隐藏被代理对象的实现细节。

示例：

我们有一个爬虫类（Spider），因为安全问题，我们不能让所有用户都可以直接访问该类。因此我们创建一个代理类（ProxySpider），只有使用许可的用户才可以访问 Spider 类。

class ISpider(metaclass=ABCMeta):
    @abstractmethod
    def crawl(self):
        pass 
class Spider(ISpider):
    def __init__(self):
        pass 
    def crawl(self):
        print('Spider is crawling')
class ProxySpider(ISpider):
    def __init__(self):
        self.spider = Spider()
    def crawl(self):
        secret = [0, 1, 2]
        if int(str(time.time()).split('.')[0][-1]) in secret:
            self.spider.crawl()
        else:
            print('您无权访问该资源')
p = ProxySpider()
p.crawl()

当 print('您无权访问该资源') 出现时，表示访问被限制;否则，输出 Spider is crawling。