python中的单例模式解析

class Foo:
    def __init__(self,name,age):
        self.name = name
        self.age = age

# obj = Foo() obj对象，obj也成为Foo类的实例，（实例化）
obj1 = Foo('fengte',12)
obj2 = Foo('dada',21)
obj3 = Foo('daddf',32)
print(id(obj1),id(obj2),id(obj3))

1253964523784 1253964524120 1253964522776

由上可知，在创建一个类后，实例化对象时，每实例化一次，内存都会重新分配一块内存地址存放，那怎么才能使我们每次实例化出来的对象都在一个内存空间呢？这就要用到我们的单例模式。

一：要想弄明白为什么每个对象被实例化出来之后, 都会重新被分配出一块新的内存地址, 就要清楚一个python中的内置函数__new__(), 它跟__init__()一样, 都是对象在被创建出来的时候, 就自动执行的一个函数, init()函数, 是为了给函数初始化属性值的, 而__new__()这个函数, 就是为了给对象在被实例化的时候, 分配一块内存地址, 因此, 我们可以重写__new__()这个方法, 让他在第一次实例化一个对象之后, 分配一块地址, 在此后的所有实例化的其他对象时, 都不再分配新的地址, 而继续使用第一个对象所被分配的地址, 因此, 我们可以在类对象里, 定义一个类属性, 初始值设为None, 如果这个值是None就调用父类的__new__()方法, 为其分配地址, 并返回这个地址(__new__方法一定要返回一个地址)

class B(object):
    instant = None
    flag = True

    def __new__(cls, *args, **kwargs):
        if cls.instant is None:
            cls.instant = super().__new__(cls)
        return cls.instant

    def __init__(self):
        if not B.flag:
            return
        self.name = ''
        B.flag = False
        print('B已经被初始化了')


d = B()
print('d对象所在的内存地址是 %d, B类所在的内存地址是 %d' % (id(d), id(B)))
e = B()
print('e对象所在的内存地址是 %d, B类所在的内存地址是 %d' % (id(e), id(B)))
f = B()
print('f对象所在的内存地址是 %d, B类所在的内存地址是 %d' % (id(f), id(B)))

out：
B已经被初始化了
d对象所在的内存地址是 1253964634096, B类所在的内存地址是 1253951407576
e对象所在的内存地址是 1253964634096, B类所在的内存地址是 1253951407576
f对象所在的内存地址是 1253964634096, B类所在的内存地址是 1253951407576

二：

class Foo:
    __v = None

    @classmethod
    def get_instance(cls):
        if cls.__v:
            return cls.__v
        else:
            cls.__v = Foo()
            return cls.__v

# 不要再使用类()
obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)
obj3 = Foo.get_instance()
print(obj3)

out：
<__main__.Foo object at 0x00000123F61C2C88>
<__main__.Foo object at 0x00000123F61C2C88>
<__main__.Foo object at 0x00000123F61C2C88>