【Python高阶技巧】设计模式（单例模式、工厂模式）

一、设计模式
二、单例模式
三、工厂模式
点击跳转
点击跳转
点击跳转

跳转到此处
跳转到此处
跳转到此处

一、设计模式

设计模式是一种编程套路，可以极大的方便程序的开发。
最常见、最经典的设计模式，就是我们所学习的面向对象了。

除了面向对象外，在编程中也有很多既定的套路可以方便开发，我们称之为设计模式：

• 单例、工厂模式
• 建造者、责任链、状态、备忘录、解释器、访问者、观察者、中介、模板、代理模式
• 等等模式

设计模式非常多。

设计模式

设计模式是计算机科学中常用的一些设计范例，它们通过提供一套可重用的解决方案来解决特定类型的问题。这些设计模式可以帮助开发人员编写更易于理解、可维护和可扩展的代码。
一些常见的设计模式：

1. 单例模式（Singleton Pattern）：
   保证一个类只有一个实例，并提供一个全局访问点。

2. 工厂模式（Factory Pattern）：
   定义一个创建对象的接口，但由子类决定实例化哪个类。工厂方法模式将类的实例化延迟到子类。

3. 建造者模式（Builder Pattern）：
   将一个复杂对象的构建和表示分离，使得同样的构建过程可以创建不同的表示。

4. 责任链模式（Chain of Responsibility Pattern）：
   使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

5. 状态模式（State Pattern）：
   允许对象在其内部状态改变时改变它的行为。

6. 备忘录模式（Memento Pattern）：
   在不破坏封装性的前提下，捕获一个对象的内部状态，以便以后恢复到这个状态。

7. 解释器模式（Interpreter Pattern）：
   提供了一个解释器，它解释语言中的句子。

8. 访问者模式（Visitor Pattern）：
   表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

9. 观察者模式（Observer Pattern）：
   定义对象间的一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。

10. 中介者模式（Mediator Pattern）：
    用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显示地相互引用，从而使其耦合松散。

11. 模板方法模式（Template Method Pattern）：
    定义一个算法的骨架，但将一些步骤延迟到子类中。使得子类在不改变算法结构的情况下重新定义该算法的某些步骤。

12. 代理模式（Proxy Pattern）：
    为其他对象提供一种代理以控制对这个对象的访问。

这些设计模式提供了在不同情境下解决问题的通用方法。在软件工程中，了解和应用这些设计模式有助于编写更具健壮性、可维护性和可扩展性的代码。

二、单例模式

单例模式是一种创建型设计模式，其主要目的是确保一个类只有一个实例，并提供一个全局访问点。这样的实例对于某些任务来说是唯一的，例如数据库连接、日志记录器或线程池等。

在实现单例模式时，通常会通过以下几个步骤：

1. 私有化构造函数： 将类的构造函数私有化，以防止外部直接实例化类的对象。

2. 静态变量持有唯一实例： 在类的内部创建一个静态变量，用于持有唯一的实例。

3. 提供访问点： 提供一个静态方法或属性，使得其他类可以获取该唯一实例。

下面是一个简单的单例模式的例子，使用 Python 实现：

class Singleton:
    _instance = None  # 保存唯一实例的变量

    def __new__(cls):
        if not cls._instance:
            # 如果实例不存在，则创建一个新实例
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# 使用单例模式
obj1 = Singleton()
obj2 = Singleton()

print(obj1 is obj2)  # 输出: True，因为 obj1 和 obj2 引用同一个实例

在这个例子中，__new__ 方法用于创建类的实例。在创建实例之前，会检查 _instance 是否为 None，如果是，则创建新的实例，否则返回已经存在的实例。

需要注意的是，单例模式的实现方式有很多种，上述只是其中一种简单的方式。在多线程环境中，可能需要考虑线程安全性，例如使用锁机制确保只创建一个实例。

单例模式的作用和写法

代码

非单例测试

"""
演示非单例模式的效果
"""

class StrTools:
    pass

s1 = StrTools()
s2 = StrTools()
print(id(s1))
print(id(s2))

单例模式

str_tools_py.py

class StrTools:
    pass

str_tool = StrTools()

test.py

from str_tools_py import str_tool

s1 = str_tool
s2 = str_tool

print(id(s1))
print(id(s2))

三、工厂模式

工厂模式是一种创建型设计模式，其目的是通过提供一个创建对象的接口，让其子类决定实例化哪个类。这样的设计模式提供了一种将对象的实例化过程推迟到子类的方法，以便子类可以根据需要实例化适当的类。

在工厂模式中，有两个主要角色：

1. 工厂接口（Factory Interface）： 定义了创建对象的接口，通常包括一个或多个工厂方法。

2. 具体工厂（Concrete Factory）： 实现了工厂接口，负责创建具体的产品对象。

3. 产品接口（Product Interface）： 定义了产品对象的接口。

4. 具体产品（Concrete Product）： 实现了产品接口，是工厂创建的对象。

以下是一个简单的工厂模式的例子，使用 Python 实现：

from abc import ABC, abstractmethod

# 产品接口
class Product(ABC):
    @abstractmethod
    def operation(self):
        pass

# 具体产品 A
class ConcreteProductA(Product):
    def operation(self):
        return "ConcreteProductA operation"

# 具体产品 B
class ConcreteProductB(Product):
    def operation(self):
        return "ConcreteProductB operation"

# 工厂接口
class Factory(ABC):
    @abstractmethod
    def create_product(self):
        pass

# 具体工厂 A
class ConcreteFactoryA(Factory):
    def create_product(self):
        return ConcreteProductA()

# 具体工厂 B
class ConcreteFactoryB(Factory):
    def create_product(self):
        return ConcreteProductB()

# 使用工厂模式
factory_a = ConcreteFactoryA()
product_a = factory_a.create_product()
print(product_a.operation())  # 输出: ConcreteProductA operation

factory_b = ConcreteFactoryB()
product_b = factory_b.create_product()
print(product_b.operation())  # 输出: ConcreteProductB operation

在这个例子中，Product 是产品接口，定义了产品对象的通用操作。ConcreteProductA 和 ConcreteProductB 是具体产品，实现了产品接口。

Factory 是工厂接口，定义了创建产品对象的方法。ConcreteFactoryA 和 ConcreteFactoryB 是具体工厂，实现了工厂接口，并负责创建具体的产品对象。

通过这样的设计，可以轻松地扩展系统，添加新的产品和工厂，而无需修改现有代码。

工厂模式的作用和写法

代码

"""
演示设计模式之工厂模式
"""

class Person:
    pass

class Worker(Person):
    pass

class Student(Person):
    pass

class Teacher(Person):
    pass


class PersonFactory:
    def get_person(self, p_type):
        if p_type == 'w':
            return Worker()
        elif p_type == 's':
            return Student()
        else:
            return Teacher()

pf = PersonFactory()
worker = pf.get_person('w')
stu = pf.get_person('s')
teacher = pf.get_person('t')

总结

1. 什么是设计模式
   设计模式就是一种编程套路。
   使用特定的套路得到特定的效果
2. 什么是单例设计模式
   单例模式就是对一个类，只获取其唯一的类实例对象，持续复用它。
   • 节省内存
   • 节省创建对象的开销
3. 什么是工厂模式
   将对象的创建由使用原生类本身创建，转换到由特定的工厂方法来创建
4. 用工厂模式好处
   • 大批量创建对象的时候有统一的入口，易于代码维护
   • 当发生修改，仅修改工厂类的创建方法即可
   • 符合现实世界的模式，即由工厂来制作产品(对象)