在Python中创建单例

这个问题不是为了讨论单例设计模式是否可取、是否是一种反模式，或者是否用于任何宗教战争，而是为了讨论如何以最Python化的方式在Python中最好地实现这种模式。在这个例子中，我定义“最蟒蛇”是指它遵循“最少惊讶的原则”。

我有多个类将成为单类（我的用例是一个记录器，但这并不重要）。当我可以简单地继承或装饰时，我不希望在几个类中添加口香糖。

最佳方法：

方法1：装饰器

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

@singleton
class MyClass(BaseClass):
    pass

Pros

装饰符的添加方式通常比多重继承更直观。

Cons

虽然使用MyClass（）创建的对象将是真正的单例对象，但MyClass本身是一个函数，而不是类，因此不能从中调用类方法x=MyClass（）；y=MyClass（）；t=类型（n）（）；

则x==y但x！=t&y！=吨

方法2：基类

class Singleton(object):
    _instance = None
    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance

class MyClass(Singleton, BaseClass):
    pass

Pros

这是一门真正的课

Cons

多重继承-嗯__new__是否可以在从第二个基类继承期间被覆盖？一个人必须想得比必要的多。

方法3：元类

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

#Python2
class MyClass(BaseClass):
    __metaclass__ = Singleton

#Python3
class MyClass(BaseClass, metaclass=Singleton):
    pass

Pros

这是一门真正的课自动神奇地覆盖继承为正确的目的使用__metaclass__（并让我意识到）

Cons

有吗？

方法4：decorator返回同名类

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class_, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w,
                                    class_).__new__(class_,
                                                    *args,
                                                    **kwargs)
                class_w._instance._sealed = False
            return class_w._instance
        def __init__(self, *args, **kwargs):
            if self._sealed:
                return
            super(class_w, self).__init__(*args, **kwargs)
            self._sealed = True
    class_w.__name__ = class_.__name__
    return class_w

@singleton
class MyClass(BaseClass):
    pass

Pros

这是一门真正的课自动神奇地覆盖继承

Cons

创建每个新类是否没有开销？在这里，我们为每个希望成为单例的类创建两个类。虽然这对我来说很好，但我担心这可能无法扩展。当然，对于这种模式的规模是否太容易，还有争议。。。_seled属性的意义是什么无法使用super（）在基类上调用同名方法，因为它们将递归。这意味着您不能自定义__new__，也不能对需要调用__init__的类进行子类化。

方法5：模块

模块文件singleton.py

Pros

简单胜于复杂

Cons

未延迟实例化

当前回答

这个怎么样：

def singleton(cls):
    instance=cls()
    cls.__new__ = cls.__call__= lambda cls: instance
    cls.__init__ = lambda self: None
    return instance

将其用作应该是单例的类的装饰器。这样地：

@singleton
class MySingleton:
    #....

这类似于另一个答案中的singleton=lambda c:c（）修饰符。与其他解决方案一样，唯一的实例具有类名（MySingleton）。然而，使用此解决方案，您仍然可以通过执行MySingleton（）从类中“创建”实例（实际上是唯一的实例）。它还防止您通过执行类型（MySingleton）（）（也返回相同的实例）来创建其他实例。

2014-05-17 23:48:58

其他回答

如果要将实例用作属性，可以使用元类。例如

class SingletonMeta(type):
    def __init__(cls, *args, **kwargs):
        super().__init__(*args, **kwargs)
        cls._instance = None
        cls._locker = threading.Lock()

    @property
    def instance(self, *args, **kwargs):
        if self._instance is None:
            with self._locker:
                if self._instance is None:
                    self._instance = self(*args, **kwargs)
        return self._instance


class MyClass(metaclass=SingletonMeta):
    def __init__(self):
        # init here
        pass


# get the instance
my_class_instance = MyClass.instance

2021-03-10 16:18:07

使用模块。它只导入一次。在其中定义一些全局变量-它们将是单例的“属性”。添加一些函数-单例的“方法”。

2011-07-20 10:58:19

这里是一个结合@agf和@（Siddhesh Suhas Sathe）解决方案的简单实现，它使用元类并考虑构造函数参数，因此如果使用完全相同的参数创建foo类，则可以返回相同的实例


class SingletonMeta(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        """
        Possible changes to the value of the `__init__` argument do not affect
        the returned instance.
        """
        cls_instances = cls._instances.get(cls) or []
        matching_instances = list(
            filter(
                lambda x: x["args"] == args and x["kwargs"] == kwargs,
                cls_instances,
            )
        )
        if len(matching_instances) == 1:
            return matching_instances[0]["instance"]
        else:
            instance = super().__call__(*args, **kwargs)
            cls_instances.append({"instance": instance, "args": args, "kwargs": kwargs})
            cls._instances[cls] = cls_instances
            return instance


class foo(metaclass=SingletonMeta):
    def __init__(self, param, k_param=None) -> None:
        print("Creating new instance")
        self.param = param
        self.k_param = k_param
        self._creation_time = time.time()

2021-11-17 16:12:44

赞成的意见这是一个真正的类Auto神奇地覆盖继承使用元类出于正当目的（并使我意识到）有吗？

这将是串行化的问题。如果您尝试从文件（pickle）反序列化对象，它将不使用__call__，因此将创建新文件，您可以使用__new__的基类继承来防止这种情况。

2021-03-06 19:21:25

使用类变量（无修饰符）

通过重写__new__方法返回类的相同实例。仅首次初始化类的布尔值：

class SingletonClass:
    _instance = None

    def __new__(cls, *args, **kwargs):
        # If no instance of class already exits
        if cls._instance is None:
            cls._instance = object.__new__(cls)
            cls._instance._initialized = False
        return cls._instance
        
    def __init__(self, *args, **kwargs):
        if self._initialized:
            return

        self.attr1 = args[0]
        # set the attribute to `True` to not initialize again
        self._initialized = True

2021-09-20 19:23:42

在Python中创建单例

推荐文章

最新文章

标签