Pandaconda

【新人系列】Python 入门（二十六）：常见设计模式

✍ 个人博客：https://blog.csdn.net/Newin2020?type=blog
专栏地址：https://blog.csdn.net/newin2020/category_12801353.html
专栏定位：为 0 基础刚入门 Python 的小伙伴提供详细的讲解，也欢迎大佬们一起交流~
专栏简介：在这个专栏，我将带着大家从 0 开始入门 Python 的学习。在这个 Python 的新人系列专栏下，将会总结 Python 入门基础的一些知识点，方便大家快速入门学习~
❤️ 如果有收获的话，欢迎点赞收藏关注，您的支持就是我创作的最大动力

1. 设计模式

1.1 介绍

设计模式是一种解决特定问题的经验、一种通用的解决方案，它有如下优点：

提高代码可重用性（重点）
提供代码的扩展性（重点）
提高可读性
提高软件的性能、效率
提高代码的维护性

1.2 设计模式分类

设计模式通常根据其目的和用途进行分类，常见的分类包括：

创建型模式：工厂方法模式、抽象工厂模式、单例模式等
结构型模式：适配器模式、桥接模式、装饰器模式等
行为型模式：策略模式、观察者模式、责任链模式等

2. 单例模式

单例模式是一种设计模式，它的核心是确保一个类只有一个实例存在。

单例模式的主要应用场景包括：

资源共享：例如数据库连接、文件系统等，只需要一个共享的资源控制实例。
全局状态管理：需要一个统一的地方来管理全局状态。

通过单例设计模式，可以避免多个对象创建导致的性能开销、防止多线程带来的多实例化问题，也可以针对一些敏感的资源做访问限制。

2.1 使用模块实现

最简单的方式就是通过模块实现单例模式的功能，因为从其它地方导入模块，这个模块肯定只有一个来源。

2.1.1 my_test.py

class Singleton:
    def __init__(self, name):
        self.name = name

    def do(self):
        pass

a = Singleton("张三")

2.1.2 app.py

from my_test import a

2.2 使用装饰器实现

上述实现方法过于简单，没有什么含金量，一般面试的时候也肯定是想问如何用装饰器的方式来实现。因此，下面来看看装饰器是如何实现的，下述代码中：

singleton 是一个装饰器函数，它维护了一个字典 instances 来存储已经创建的类实例。
当每次调用被装饰的类时，如果该类的实例还不存在，就创建一个新的实例并存储在 instances 中；如果已经存在，就直接返回已有的实例。

这样就保证了 MySingleton 类始终只有一个实例被创建和使用。

def singleton(cls):
    instances = {}    # 创建一个空字典
    def get_instance(*args, **kwargs):
        """
        判断空字典中是否已经存在cls类：
        - 如果不存在，就新创建一个类对象，并存放到字典中
        - 如果存在，直接返回存在字典中的类对象
        """
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class MySingleton:
    def __init__(self):
        self.data = "This is a singleton instance"

instance1 = MySingleton()
instance2 = MySingleton()

print(instance1 is instance2)  # True

2.3 使用 new 方法实现

另外，new 的实现方法也和装饰器有异曲同工之处，下述代码中：

首先定义了一个类属性 _instance ，初始值为 None ，用于存储单例对象的引用。
new 是一个特殊的方法，用于控制对象的创建过程。而在 new 方法中，如果 _instance 为 None ，就通过 super().new(cls) 创建一个新的对象，并将其赋值给 _instance 。
后续再次调用创建对象时，直接返回已经创建好的 _instance ，从而保证始终只有一个实例存在。

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

s1 = Singleton()
s2 = Singleton()

print(s1 is s2)    # True

3. 工厂模式

工厂模式也是常用的设计模式之一，它是一种创建对象的设计模式。它的核心思想是将对象的创建与使用分离，通过一个工厂类来负责创建对象，即将实例化对象的过程封装起来，而客户端就不需要知道具体的创建细节。

工厂模式主要有三种形式：简单工厂模式、工厂方法模式和抽象工厂模式。

3.1 简单工厂模式

3.1.1 特点

定义一个工厂类，具有一个创建对象的方法。
根据传入的参数决定创建哪种具体的产品对象。

3.1.2 优缺点

优点
- 实现了对象创建和使用功能的分离，客户端不需要知道对象是如何创建的，只需要使用工厂提供的方法获取对象即可。
- 集中了对象的创建逻辑，使得代码更具可读性和可维护性。
缺点
- 不符合开闭原则，即当需要添加新的产品时，需要修改工厂类的创建逻辑。
- 工厂类的职责过重，可能会变得复杂和难以维护，如果产品种类过多，工厂类可能会变得庞大。

3.1.3 示例代码

假设我们有一个生产不同类型汽车的场景，有 “经济型轿车” 和 “豪华型轿车” 两种类型。在下述代码中：

Car 是一个抽象的基类，EconomyCar 和 LuxuryCar 是具体的汽车类型，它们继承自 Car 类并实现了 drive 方法。
CarFactory 是工厂类，它的 create_car 方法根据传入的参数创建相应类型的汽车对象。

from abc import ABC, abstractmethod

# 抽象类
class Car(ABC):
    @abstractmethod
    def drive(self):
        pass

class EconomyCar(Car):
    def drive(self):
        print("Driving an economy car")

class LuxuryCar(Car):
    def drive(self):
        print("Driving a luxury car")

class CarFactory:
    def create_car(self, car_type):
        if car_type == 'economy':
            return EconomyCar()
        elif car_type == 'luxury':
            return LuxuryCar()


# 客户端代码     
factory = CarFactory()

economy_car = factory.create_car('economy')
economy_car.drive()

luxury_car = factory.create_car('luxury')
luxury_car.drive()

Tips：抽象类
如果一个类继承自 ABC，且其中的方法加上了 @abstractmethod 的标签，那么这个类就是抽象类，它只能被其它类继承且其中的方法不能被实例化。

3.2 工厂方法模式

3.2.1 特点

在工厂方法模式中，不再由一个单一的工厂类来创建所有的产品对象，而是为每种产品都提供一个具体的工厂类，这些工厂类都有一个共同的父类（抽象工厂类），其中定义了一个抽象的工厂方法。
每个具体的工厂类负责创建一种特定类型的产品对象。

3.2.2 优点

符合开闭原则：当需要添加新的产品时，不需要修改现有的工厂类，只需要添加一个新的具体工厂类和对应的产品类即可。
解耦了产品的创建和使用：客户端只需要知道抽象工厂和抽象产品的接口，而不需要关心具体的产品创建细节。

3.2.3 示例代码

在下述示例中：

Product 是抽象产品类，ConcreteProduct1 和 ConcreteProduct2 是具体的产品类。
Factory 是抽象工厂类，定义了抽象的创建产品的方法 create_product 。
ConcreteFactory1 和 ConcreteFactory2 是具体的工厂类，分别负责创建对应的具体产品。

from abc import ABC, abstractmethod

# 抽象产品类
class Product(ABC):
    @abstractmethod
    def show(self):
        pass

# 具体产品类 1
class ConcreteProduct1(Product):
    def show(self):
        print("This is ConcreteProduct1")

# 具体产品类 2
class ConcreteProduct2(Product):
    def show(self):
        print("This is ConcreteProduct2")

# 抽象工厂类
class Factory(ABC):
    @abstractmethod
    def create_product(self):
        pass

# 具体工厂类 1
class ConcreteFactory1(Factory):
    def create_product(self):
        return ConcreteProduct1()

# 具体工厂类 2
class ConcreteFactory2(Factory):
    def create_product(self):
        return ConcreteProduct2()


# 客户端代码
factory1 = ConcreteFactory1()
product1 = factory1.create_product()
product1.show()

factory2 = ConcreteFactory2()
product2 = factory2.create_product()
product2.show()

Tips：

ABC 是 Abstract Base Class 的缩写，用于定义抽象基类。
abstractmethod 装饰器用于将一个方法标记为抽象方法。抽象方法是没有实现的方法，子类必须实现这些抽象方法，否则子类也会被视为抽象类，无法实例化。

3.3 抽象工厂模式

3.3.1 特点

抽象工厂定义了多个产品族的创建接口，每个产品族通常包含多个相关的产品对象。
具体的工厂类实现抽象工厂的接口，负责创建属于特定产品族的产品对象。
客户端通过抽象工厂的接口来获取产品族中的对象，而不关心具体的产品类和创建细节。

3.3.2 优点

易于交换产品系列：当需要切换到不同的产品系列时，只需要更改使用的具体工厂类。
有利于产品的一致性：确保属于同一个产品族的对象能够相互配合和协作。
解耦了客户端与具体产品类的创建逻辑。

3.3.3 示例代码