python中特殊的静态方法__new__

一、关于new方法

在Python中，__new__方法是一个特殊的静态方法，用于实例化对象。通常不需要直接调用__new__方法，Python会自动调用它来分配内存空间并返回一个新对象（或者更具体地说，是对象的引用）。然而，在某些特殊情况下，比如设计模式中，使用__new__方法来限制只能创建特定数量 的实例；你需要重写__new__方法来控制对象的创建过程。

__new__方法的典型用法是当你需要控制对象的创建过程，比如实现单例模式、确保只创建特定类型的对象等。

__new__方法的基本使用结构如下：

class MyClass:  
    def __new__(cls, *args, **kwargs):  
        # 在这里，cls 是类本身，而不是类的实例  
        # 你需要调用父类的 __new__ 方法来实际创建对象  
        # 例如，如果你继承自 object（所有类的基类），你应该这样做：  
        instance = super().__new__(cls)  
  
        # 在这里，你可以对 instance 进行任何需要的初始化  
  
        # 最后，返回 instance  
        return instance  
  
    def __init__(self, *args, **kwargs):  
        # 在这里进行对象的常规初始化  
        pass

注意，__new__方法的第一个参数是类本身（通常命名为cls），而不是类的实例。此外，你需要调用父类的__new__方法来实际创建对象。这通常是通过super().__new__(cls)来实现的。

---

二、使用__new__方法来限制只能创建特定数量的实例

LimitedInstances类使用__new__方法来跟踪已创建的实例数量，并在达到最大限制时阻止创建更多实例。

class LimitedInstances:  
    _instances = 0  
    _max_instances = 3  # 限制本类只允许创造3个实例
  
    def __new__(cls, *args, **kwargs):  
        if cls._instances >= cls._max_instances:  
            raise Exception("Cannot create more instances")  
  
        cls._instances += 1  
        instance = super().__new__(cls)  
        return instance  
  
    def __init__(self, name):  
        self.name = name  
  
    def __del__(self):  
        # 注意：这只是一个简单的示例，用于演示。在真实场景中，可能需要更复杂的逻辑来处理实例删除。  
        LimitedInstances._instances -= 1  
  
# 创建实例  
a = LimitedInstances("Instance A")  
b = LimitedInstances("Instance B")  
c = LimitedInstances("Instance C")  
  
# 尝试创建更多实例将引发异常  
try:  
    d = LimitedInstances("Instance D")  
except Exception as e:  
    print(e)  # 输出: Cannot create more instances

---

三、其他设计模式

在Python中，我们可以使用类来实现各种设计模式，如单例模式、工厂模式、观察者模式等。

3.1 单例模式（Singleton Pattern）

单例模式确保一个类仅有一个实例，并提供一个全局访问点。

class Singleton:  
    _instance = None  
  
    def __new__(cls, *args, **kwargs):  
        if cls._instance is None:  
            cls._instance = super().__new__(cls)  
        return cls._instance  
  
# 使用示例  
singleton1 = Singleton()  
singleton2 = Singleton()  
assert singleton1 is singleton2  # 应该是同一个实例

3.2 工厂模式（Factory Pattern）

工厂模式用于封装对象的创建过程，使得代码更加灵活和可维护。

class Car:  
    def __init__(self, brand):  
        self.brand = brand  
  
class CarFactory:  
    def create_car(self, brand):  
        return Car(brand)  
  
# 使用示例  
factory = CarFactory()  
bmw = factory.create_car("BMW")  
toyota = factory.create_car("Toyota")

3.3抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

参见博客，python标准库abc的使用方法:ABC, abstractmethod

from abc import ABC, abstractmethod  
  
class AbstractCarFactory(ABC):  
    @abstractmethod  
    def create_sedan(self):  
        pass  
  
    @abstractmethod  
    def create_suv(self):  
        pass  
  
class GermanCarFactory(AbstractCarFactory):  
    def create_sedan(self):  
        return Sedan("BMW")  
  
    def create_suv(self):  
        return SUV("Audi")  
  
class JapaneseCarFactory(AbstractCarFactory):  
    def create_sedan(self):  
        return Sedan("Toyota")  
  
    def create_suv(self):  
        return SUV("Honda")  
  
class Car:  
    def __init__(self, brand):  
        self.brand = brand  
  
class Sedan(Car):  
    pass  
  
class SUV(Car):  
    pass  
  
# 使用示例  
german_factory = GermanCarFactory()  
sedan = german_factory.create_sedan()  
suv = german_factory.create_suv()

3.4观察者模式（Observer Pattern）

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。当主题对象状态发生变化时，它的所有依赖者（观察者）都会自动收到通知并更新。

class Subject:  
    def __init__(self):  
        self._observers = []  
        self._state = None  
  
    def attach(self, observer):  
        if observer not in self._observers:  
            self._observers.append(observer)  
  
    def detach(self, observer):  
        try:  
            self._observers.remove(observer)  
        except ValueError:  
            pass  
  
    def notify(self):  
        for observer in self._observers:  
            observer.update(self._state)  
  
    def set_state(self, state):  
        self._state = state  
        self.notify()  
  
class Observer:  
    def update(self, state):  
        pass  
  
class ConcreteObserver(Observer):  
    def update(self, state):  
        print(f"Received state: {state}")  
  
# 使用示例  
subject = Subject()  
observer = ConcreteObserver()  
subject.attach(observer)  
subject.set_state("New state")  # 输出: Received state: New state

Tips

1. 设计模式主要用于解决在软件设计和开发中经常遇到的特定问题，它们提供了一种可重用的解决方案，使得代码更加健壮、可维护和可扩展。
2. 单例模式 (Singleton Pattern)：避免频繁创建和销毁对象导致的性能开销。应用-配置管理类：确保应用程序只加载一次配置文件，并提供一个全局访问点来获取配置信息。日志记录器：确保整个应用程序中只有一个日志记录器实例，以避免日志信息混乱。
3. 工厂模式 (Factory Pattern)：封装对象的创建过程，使得代码更加灵活和可维护。解耦对象的创建与使用，使得代码更加清晰。应用说明-数据库连接工厂：根据配置信息动态创建不同类型的数据库连接对象。邮件发送工厂：根据邮件类型（如文本邮件、HTML邮件）创建不同的邮件发送对象。
4. 抽象工厂模式 (Abstract Factory Pattern)：应用说明-UI工具包：为不同平台（如Windows、Linux）创建一组UI组件（如按钮、文本框）。游戏角色工厂：根据游戏类型（如角色扮演、射击游戏）创建一组游戏角色和装备。
5. 观察者模式 (Observer Pattern)：定义对象之间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。实现事件驱动编程。应用说明-用户界面：当数据模型发生变化时，所有依赖于该数据的视图都会自动更新。股票交易系统：当股票价格发生变化时，所有订阅了该股票的用户都会收到通知。