这个答案可能不是你想要的。我想要一个单例，因为只有那个对象才有它的身份，以便与之比较。在我的例子中，它被用作Sentinel Value。答案很简单，将任何对象设为mything=object（），根据python的性质，只有该对象才具有其身份。

#!python
MyNone = object()  # The singleton

for item in my_list:
    if item is MyNone:  # An Example identity comparison
        raise StopIteration

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

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

Pros

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

Cons

__new__可能再次被覆盖

我会把我的扔到戒指里。这是一个简单的装饰器。

from abc import ABC

def singleton(real_cls):

    class SingletonFactory(ABC):

        instance = None

        def __new__(cls, *args, **kwargs):
            if not cls.instance:
                cls.instance = real_cls(*args, **kwargs)
            return cls.instance

    SingletonFactory.register(real_cls)
    return SingletonFactory

# Usage
@singleton
class YourClass:
    ...  # Your normal implementation, no special requirements.

我认为它比其他一些解决方案有好处：

它清晰简洁（在我看来；D）。它的作用是完全封闭的。你不需要改变YourClass的实现。这包括不需要为类使用元类（请注意，上面的元类在工厂中，而不是“真实”类）。它不依赖猴子修补任何东西。它对呼叫者是透明的：调用者仍然只是简单地导入YourClass，它看起来像一个类（因为它是），并且他们正常使用它。无需使调用者适应工厂函数。YourClass（）实例化的仍然是您实现的YourClass的真实实例，而不是任何类型的代理，因此不会产生任何副作用。isinstance（例如，YourClass）和类似的操作仍按预期工作（尽管这个位确实需要abc，因此排除了Python＜2.6）。

一个缺点确实出现在我身上：真实类的类方法和静态方法不能通过隐藏它的工厂类透明地调用。我很少使用这种方法，我从来没有遇到过这种需要，但通过在工厂上使用一个自定义元类来实现__getattr__（），将所有的属性访问委托给真实类，这很容易纠正。

我实际上发现了一个更有用的相关模式（我并不是说这类事情经常需要），那就是“唯一”模式，用相同的参数实例化类会得到相同的实例。即“每个参数一个”。上述内容很好地适应了这一点，变得更加简洁：

def unique(real_cls):

    class UniqueFactory(ABC):

        @functools.lru_cache(None)  # Handy for 3.2+, but use any memoization decorator you like
        def __new__(cls, *args, **kwargs):
            return real_cls(*args, **kwargs)

    UniqueFactory.register(real_cls)
    return UniqueFactory

尽管如此，我还是同意一般的建议，如果你认为你需要这些东西中的一件，你真的应该停下来问问自己是否真的需要。

这是给你的一句话：

singleton = lambda c: c()

以下是您的使用方法：

@singleton
class wat(object):
    def __init__(self): self.x = 1
    def get_x(self): return self.x

assert wat.get_x() == 1

您的对象会被急切地实例化。这可能是你想要的，也可能不是你想要的。

使用函数属性也非常简单

def f():
    if not hasattr(f, 'value'):
        setattr(f, 'value', singletonvalue)
    return f.value

我想指出的是，第一种方法定义了一个查找字典，直到今天我都不理解，而且我看到这个解决方案遍布各地，所以我想每个人都只是从这里复制粘贴它。

我说的是这个：

def singleton(class_):
    instances = {} # <-- will always only have one entry.
    def getinstance(*args, **kwargs):
        if class_ not in instances:
            instances[class_] = class_(*args, **kwargs)
        return instances[class_]
    return getinstance

对于元类解决方案来说，这是有意义的，但对于一次性装饰器解决方案，每次调用装饰器时，都会定义一个新函数，以及一个新的实例变量，因此每个“实例”始终只有一个条目，除非您将其设为全局。无论如何，它也不适用于继承。

一种类似但更简单且可调节性更好的解决方案：

def singleton(class_):
    def wrapper(*args, **kwargs):
        if not wrapper._instance:
            wrapper._instance = class_(*args, **kwargs)
        return wrapper._instance

    wrapper._instance = None
    return wrapper

添加一个简单

    ...
    wrapper.__wrapped__ = class_
    return wrapper

同样，通过访问wrapped也允许继承或模仿，这在内部dict查找中也是不可能的。

（当然，如果我只是不理解查字典背后的奥秘，请原谅我。也许是我的错，不理解查词典背后的具体意图）