两次调用singleton python时出现问题__

Question

我有一个这样的单身汉

class Singleton:

    class __impl:
        def __init__(self):
            print "INIT"

    __instance = None

    def __init__(self):
        # Check whether we already have an instance
        if Singleton.__instance is None:
            Singleton.__instance = Singleton.__impl()

        # Store instance reference as the only member in the handle
        self.__dict__['_Singleton__instance'] = Singleton.__instance

    def __getattr__(self, attr):
        """ Delegate access to implementation """
        return getattr(self.__instance, attr)

    def __setattr__(self, attr, value):
        """ Delegate access to implementation """
        return setattr(self.__instance, attr, value)

当我对Singleton做了几个实例时，我接到了两个对init的调用，我的意思是“init”被打印了两次，我确信它不应该发生

有人知道这个有什么问题或者有更好的方法来实现这个？？

Answer 1

下面是一个稍微简单一点的写单子的方法：

class Singleton(object):
    __instance = None
    def __new__(cls):
        if cls.__instance is None:
            cls.__instance = super(Singleton,cls).__new__(cls)
            cls.__instance.__initialized = False
        return cls.__instance

    def __init__(self):      
        if(self.__initialized): return
        self.__initialized = True
        print ("INIT")

a = Singleton()
b = Singleton()
print (a is b)

尽管有更好的方法。我不得不承认我从来都不喜欢单身汉。我更喜欢工厂式的方法：

class Foo(object):
    pass

def foo_singleton_factory(_singlton = Foo()):
    return _singleton

a = foo_singleton_factory()
b = foo_singleton_factory()
print (a is b)

这样做的好处是，如果你想要的话，你可以一直获得相同的Foo实例，但是如果你决定在未来10年内不想要真正的单实例，你就不局限于一个实例。

Answer 2

既然我们都忽略了你的问题，而是提出了其他的单例实现方案，我将介绍我最喜欢的。它利用了python模块只加载一次的事实，不管您导入它多少次。

它也基于python的座右铭“我们都同意这里的成年人”，因为如果你真的想，你可以多次实例化它。。。但是你真的要付出额外的努力去做错事。

所以在mysingleton.py中：

class SingletonClass(object):
    def __init__(self):
        # There's absolutely nothing special about this class
        # Nothing to see here, move along
        pass

# Defying PEP8 by capitalizing name
# This is to point out that this instance is a Singleton
Singleton = SingletonClass()

# Make it a little bit harder to use this module the wrong way
del SingletonClass

然后像这样使用：

from mysingleton import Singleton

# Use it!

我说你必须付出额外的努力去做错事。下面是如何创建singleton类的两个实例，使其不再是singleton类：

another_instance = Singleton.__class__()

那么你如何避免这个问题呢？我引用医生的话：那就不要那样做！

---

注意：这是在发表以下评论之后添加的

当我在这里的时候，这里有另一个单例变量，它最小化了复杂代码的数量。它使用元类：

class SingletonMeta(type):
    # All singleton methods go in the metaclass
    def a_method(cls):
        return cls.attribute

    # Special methods work too!
    def __contains__(cls, item):
        return item in cls.a_list

class Singleton(object):
    __metaclass__ = SingletonMeta
    attribute = "All attributes are class attributes"

    # Just put initialization code directly into the class
    a_list = []
    for i in range(0, 100, 3):
        a_list.append(i)

print Singleton.a_method()
print 3 in Singleton

在Python3中，您将创建如下的单例实例：

class Singleton(metaclass=SingletonMeta):
    attribute = "One... two... five!"

现在这个有点不确定了，因为singleton是一个类，您可以创建singleton的实例。理论上这是可以的，因为即使有实例，singleton仍然是singleton，但是您需要记住Singleton()不是singleton--Singleton！它甚至可以满足您的需要，将singleton属性作为类属性随时提供给它的实例。

Answer 3

PEP 318有一个类的单例装饰器示例：

def singleton(cls):
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

@singleton
class MyClass:
    ...

（虽然我自己没有用过。）

顺便说一下，关于。。。

I made a singleton like this

另外，你应该提到你copied it directly from ActiveState。