在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

未延迟实例化

当前回答

好吧，除了同意Pythonic关于模块级全局的一般建议之外，这又如何呢

def singleton(class_):
    class class_w(class_):
        _instance = None
        def __new__(class2, *args, **kwargs):
            if class_w._instance is None:
                class_w._instance = super(class_w, class2).__new__(class2, *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(object):
    def __init__(self, text):
        print text
    @classmethod
    def name(class_):
        print class_.__name__

x = MyClass(111)
x.name()
y = MyClass(222)
print id(x) == id(y)

输出为：

111     # the __init__ is called only on the 1st time
MyClass # the __name__ is preserved
True    # this is actually the same instance

2011-07-25 00:09:34

其他回答

class Foo(object):
     pass

some_global_variable = Foo()

模块只导入一次，其他一切都在考虑之中。不要使用singleton，也不要使用globals。

2011-07-20 10:52:04

这个解决方案在模块级别造成了一些命名空间污染（三个定义而不是一个），但我发现很容易理解。

我希望能够编写这样的东西（惰性初始化），但不幸的是，类在它们自己的定义体中不可用。

# wouldn't it be nice if we could do this?
class Foo(object):
    instance = None

    def __new__(cls):
        if cls.instance is None:
            cls.instance = object()
            cls.instance.__class__ = Foo
        return cls.instance

由于这是不可能的，我们可以在

Eagle初始化：

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        return foo_instance


foo_instance = FooMaker()
foo_instance.__class__ = Foo

延迟初始化：

Eagle初始化：

import random


class FooMaker(object):
    def __init__(self, *args):
        self._count = random.random()
        self._args = args


class Foo(object):
    def __new__(self):
        global foo_instance
        if foo_instance is None:
            foo_instance = FooMaker()
        return foo_instance


foo_instance = None

2016-10-31 22:07:59

方法：一次性使用后重写__new__

class Singleton():
    def __init__(self):
        Singleton.instance = self
        Singleton.__new__ = lambda _: Singleton.instance

Pros

极其简洁真正的类，不需要模块正确使用lambda和蟒猴补丁

Cons

__new__可能再次被覆盖

2022-05-15 08:10:42

看看这个。其思想是通过args和kwargs来散列实例密钥。https://stackoverflow.com/a/73495782/2910384

2022-08-26 03:39:52

正如@Staale在这里提到的，在python中创建单例的最简单方法是使用带有全局变量的模块（作为“属性”，而全局函数作为“方法”）。但我想为这个已经令人惊叹的答案补充一点非常重要的东西：继承也在这里发挥作用！

要创建一个继承自另一个“singleton module”a.py的“singleton模块”B.py，只需使用以下行启动B.py：from a import*，这将尊重私有变量（默认情况下不导入它们）。

2022-05-30 20:00:36

在Python中创建单例

推荐文章

最新文章

标签