Python中的设计模式：来聊聊Singleton、Factory那些事儿

大家好，欢迎来到今天的Python设计模式讲座！今天我们要聊的是两个经典的设计模式：Singleton（单例模式） 和 Factory（工厂模式）。这两个模式在实际开发中非常常见，但有时候它们也会让人摸不着头脑。别担心，今天我会用轻松诙谐的语言和一些代码实例，带你一起搞懂它们。

---

一、什么是设计模式？

首先，我们先简单说说设计模式是什么。设计模式其实就像是编程界的“套路”。它是一些经过验证的解决方案，用来解决特定的软件设计问题。就像武侠小说里的招式一样，设计模式也有不同的流派和风格。

Python作为一种灵活的语言，支持多种设计模式的实现方式。今天我们聚焦于两个经典的“招式”：Singleton 和 Factory。

---

二、Singleton模式：让对象独一无二

1. Singleton是啥？

Singleton模式的核心思想就是：一个类只能有一个实例，并且提供一个全局访问点。换句话说，无论你创建多少次这个类的对象，最终都只会得到同一个实例。

举个例子，假设你在开发一个日志系统，希望所有的模块共享同一个日志记录器。这时候就可以用Singleton模式。

2. 实现Singleton的几种方法

方法1：使用类属性

这是最简单的实现方式之一。通过将实例存储为类的属性，确保每次调用时返回同一个对象。

class Logger:
    _instance = None  # 类属性

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

    def log(self, message):
        print(f"Logging: {message}")

# 测试
logger1 = Logger()
logger2 = Logger()

print(logger1 is logger2)  # 输出: True
logger1.log("Hello")  # 输出: Logging: Hello

方法2：使用装饰器

如果你觉得类属性的方式不够优雅，可以用装饰器来实现Singleton。

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Config:
    def __init__(self):
        self.settings = {"theme": "dark"}

# 测试
config1 = Config()
config2 = Config()

print(config1 is config2)  # 输出: True
config1.settings["theme"] = "light"
print(config2.settings)  # 输出: {'theme': 'light'}

方法3：使用元类

如果你是个追求极致的人，可以试试用元类来实现。这种方式虽然复杂，但更符合Python的哲学。

class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kwargs)
        return cls._instances[cls]

class Database(metaclass=SingletonMeta):
    def __init__(self):
        self.connection = "Connected to DB"

# 测试
db1 = Database()
db2 = Database()

print(db1 is db2)  # 输出: True
print(db1.connection)  # 输出: Connected to DB

---

三、Factory模式：制造对象的艺术

1. Factory是啥？

Factory模式的核心思想是：将对象的创建过程封装起来，使得客户端不需要知道具体的创建细节。简单来说，就是让某个类或函数负责生成其他类的实例。

Factory模式有多种形式，比如简单工厂、工厂方法和抽象工厂。今天我们主要聊聊简单工厂和工厂方法。

2. 简单工厂模式

简单工厂模式适用于场景较少的情况。假设我们有个需求：根据用户输入的不同类型，生成不同的动物对象。

class Dog:
    def speak(self):
        return "Woof!"

class Cat:
    def speak(self):
        return "Meow!"

class AnimalFactory:
    @staticmethod
    def get_animal(animal_type):
        if animal_type == "dog":
            return Dog()
        elif animal_type == "cat":
            return Cat()
        else:
            raise ValueError("Unknown animal type")

# 测试
animal = AnimalFactory.get_animal("dog")
print(animal.speak())  # 输出: Woof!

animal = AnimalFactory.get_animal("cat")
print(animal.speak())  # 输出: Meow!

3. 工厂方法模式

如果需要更多的灵活性，可以使用工厂方法模式。每个具体类都有自己的工厂方法。

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class AnimalFactory(ABC):
    @abstractmethod
    def create_animal(self):
        pass

class DogFactory(AnimalFactory):
    def create_animal(self):
        return Dog()

class CatFactory(AnimalFactory):
    def create_animal(self):
        return Cat()

# 测试
dog_factory = DogFactory()
dog = dog_factory.create_animal()
print(dog.speak())  # 输出: Woof!

cat_factory = CatFactory()
cat = cat_factory.create_animal()
print(cat.speak())  # 输出: Meow!

---

四、Singleton vs Factory：到底该用哪个？

特性	Singleton	Factory
主要用途	确保一个类只有一个实例	封装对象的创建过程
是否涉及继承	不涉及	可能涉及继承
使用场景	配置管理、日志系统、数据库连接池等	动态创建对象、解耦合

选择哪种模式取决于你的需求。如果需要全局唯一性，用Singleton；如果需要灵活的对象创建机制，用Factory。

---

五、总结

今天我们一起探讨了两种经典的设计模式：Singleton和Factory。它们各有千秋，适用于不同的场景。记住，设计模式不是万能药，不要为了用而用，而是要在合适的场景下选择合适的工具。

最后引用一句国外技术文档中的名言：“Design patterns are solutions to recurring problems, not a silver bullet.”（设计模式是解决问题的方案，而不是万能钥匙。）

好了，今天的讲座就到这里啦！希望大家都能成为设计模式的大师！