python实现的单子模式（附解释）

[list]
[*][b][color=red][size=x-large]一、通过metaclass来实现[/size][/color][/b]
[/list]

class Singleton(type):
    def __init__(self, name, bases, dct):
        super(Singleton, self).__init__(name, bases, dct)
        self.instance = None

    def __call__(self,*args,**kw):
        if self.instance is None:
            self.instance = super(Singleton, self).__call__(*args, **kw)
        return self.instance
class A(object):
    __metaclass__ = Singleton
    def __init__(self):
        self.xx = 1
A()

[color=red]注解：[/color]
__metaclass__顾名思义是class A的元类，所谓元类即其实例是一个类。所以，Singleton的一个实例是class A。那么A()到底是怎样的执行过程呢？
[list]
[*]1) Singleton实例化：隐式调用了Sinleton的__new__方法生成一个实例，并调用Singleton.__init__去初始化这个实例，初始化之后便产生了class A。这里，name, bases, dct就是class A的定义中的相关属性。
[*]2) A的实例化，由于在Singleton中定义了__call__，即Singleton的实例可以像函数一样调用。然而，Singleton的实例是class A，根据规则，在实例化A时即A()，解释器选择调用Singleton.__call__（并不调用A.__new__和A.__init__）。那么A.__init__在何时调用呢？
[*]3) 在执行Singleton.__Call__时，如果self.instance（即A.instance）是None时，则调用super(Singleton, self).__call__，在这个函数中会调用A.__init__,初始化A的实例后存在self.instance（即A.instance）中。
[/list]
通过这样就可以做到只有一个A的实例，并存储在A.instance中。元类确实有点绕人，但是弄清楚了之后，它在特定的时刻能带来很大的方便。
[list]
[*][b][size=x-large][color=red]二、通过decorator来实现[/color][/size][/b]
[/list]

class Singleton:
    """
    A non-thread-safe helper class to ease implementing singletons.
    This should be used as a decorator -- not a metaclass -- to the
    class that should be a singleton.

    The decorated class can define one `__init__` function that
    takes only the `self` argument. Other than that, there are
    no restrictions that apply to the decorated class.

    To get the singleton instance, use the `Instance` method. Trying
    to use `__call__` will result in a `TypeError` being raised.

    Limitations: The decorated class cannot be inherited from.

    """

    def __init__(self, decorated):
        self._decorated = decorated

    def Instance(self):
        """
        Returns the singleton instance. Upon its first call, it creates a
        new instance of the decorated class and calls its `__init__` method.
        On all subsequent calls, the already created instance is returned.

        """
        try:
            return self._instance
        except AttributeError:
            self._instance = self._decorated()
            return self._instance

    def __call__(self):
        raise TypeError('Singletons must be accessed through `Instance()`.')

    def __instancecheck__(self, inst):
        return isinstance(inst, self._decorated)

   @Singleton
   class Foo:
       def __init__(self):
           print 'Foo created'

   f = Foo() # Error, this isn't how you get the instance of a singleton

   f = Foo.Instance() # Good. Being explicit is in line with the Python Zen
   g = Foo.Instance() # Returns already created instance

   print f is g # True

[list]
[*][size=x-large][color=red][b]三、通过__new__来实现[/b][/color][/size]
[/list]

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


if __name__ == '__main__':
    s1=Singleton()
    s2=Singleton()
    if(id(s1)==id(s2)):
        print "Same"
    else:
        print "Different"

部分源码来自于：[url]http://stackoverflow.com/questions/42558/python-and-the-singleton-pattern[/url]
[url]http://stackoverflow.com/questions/6760685/creating-a-singleton-in-python[/url]