面试准备(三)-设计模式

单例模式

new 和 init

在讲单例设计模式之前，我们有必要先了解一下new和init的区别

原文参考 https://www.cnblogs.com/suntp/p/6445286.html

class A(object):
    def __init__(self,*args, **kwargs):
        print "init A"
    def __new__(cls,*args, **kwargs):
        print "new A %s"%cls
　　　　 #return super(A, cls).__new__(cls, *args, **kwargs)
        return object.__new__(cls, *args, **kwargs)

1、继承自object的新式类才有__new__

2、__new__至少要有一个参数cls，代表当前类，此参数在实例化时由Python解释器自动识别

3、__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例

4、__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值

5、如果__new__传入的cls是自己的类，会自动调用__init__函数，通过return语句里面调用的__new__函数的第一个参数是cls来保证是当前类实例，如果是其他类的类名，；那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数。

class B(A):
    def __init__(self,*args, **kwargs):
        print "init B"
    def __new__(cls,*args, **kwargs):
        print "new B %s"%cls
　　　　 #return super(B, cls).__new__(cls, *args, **kwargs)
        return object.__new__(cls, *args, **kwargs)

1、在定义子类时没有重新定义__new__()时，Python默认是调用该类的直接父类的__new__()方法来构造该类的实例，如果该类的父类也没有重写__new__()，那么将一直按此规矩追溯至object的__new__()方法，因为object是所有新式类的基类。

2、而如果子类中重写了__new__()方法，那么你可以自由选择任意一个的其他的新式类（必定要是新式类，只有新式类必定都有__new__()，因为所有新式类都是object的后代，而经典类则没有__new__()方法）的__new__()方法来制造实例，包括这个新式类的所有前代类和后代类，只要它们不会造成递归死循环。反正肯定不能调用自己的__new__，这肯定是死循环。

3、对于子类的__init__，其调用规则跟__new__是一致的，当然如果子类和父类的__init__函数都想调用，可以在子类的__init__函数中加入对父类__init__函数的调用。

4、我们在使用时，尽量使用__init__函数，不要去自定义__new__函数，因为这两者在继承派生时的特性还是很不一样的。

总结一下就是

• new是在init之前调用的，init中的self就是new创建处理的实例

• new必要有一个参数cls（表示当前类），和一个返回值

• new的返回值可以return父类（通过super(当前类名, cls)）__new__出来的实例，或者直接是object的__new__出来的实例

• 在new中不可调用自己的new，这会造成死循环

• 如果子类中没有重写new,python默认调用父类的new，注意这一点，这和java中的构造方法非常像，但是在python中，可以自定义调用其他任何新式类的new

• 子类会在实例化时会默认调用父类的new,但不会调用父类的init

• 只有继承object的新式类，才有new方法

• new的简单实用是实现单例设计模式

meta元类

如果理解了上述的new，那么理解元类就显得比较轻松了
原文链接：https://www.liaoxuefeng.com/wiki/1016959663602400/1017592449371072

单例模式的四种实现方式

原文链接 https://www.cnblogs.com/haiyan123/p/8251032.html

1.使用new实现

import threading


class SingleTon(object):
    instance_lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            with SingleTon.instance_lock:
                # 这里不适用__instace命名的原因是
                # 不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，
                # 所以，仍然可以通过_Student__name来访问__name变量
                if not hasattr(cls, '_instance'):
                    # 添加一个类属性_instance，实例为父类的实例
                    SingleTon._instance = super().__new__(cls, *args, **kwargs)
                    # SingleTon._instance = object.__new__(cls)
        return SingleTon._instance


if __name__ == '__main__':
    s1 = SingleTon()
    s2 = SingleTon()

    print(s1 == s2)
    print(s1 is s2)


    def task(i):
        a = 1 + i
        s = SingleTon()
        print(s)


    t1 = threading.Thread(target=task, args=[1, ])
    t2 = threading.Thread(target=task, args=[2, ])

    t1.start()
    t2.start()

True
True
<__main__.SingleTon object at 0x0000019A70718B00>
<__main__.SingleTon object at 0x0000019A70718B00>

2.使用类方法实现

import threading
import time


class SingleTon(object):
    lock = threading.Lock()
    def __init__(self,i):
        time.sleep(1) 

    @classmethod
    def instance(cls,*args, **kwargs):
        if not hasattr(cls,'_instance'):
            with SingleTon.lock: #为了保证线程安全在内部加锁
                if not hasattr(cls, '_instance'):
                    cls._instance = cls(*args, ** kwargs)
        return cls._instance

if __name__ == '__main__':
    for i in range(1,10):
        t = threading.Thread(target = lambda i :print(SingleTon(i)),args = (i, ))
        print('t:',t)
        t.start()

3.使用装饰器实现（两种）

def wrapper(cls):
    # instance = {}
    def inner(*args, **kwargs):
        if not hasattr(cls,'_instance'):
            # instance[cls] = cls(*args,**kwargs)
            cls._instance = cls(*args,**kwargs)
        # return instance[cls]
        return cls._instance
    return inner


@wrapper        # Singleton = wrapper(cls)
class Singleton(object):
    def __init__(self,a,b):
        self.a = a
        self.b = b

if __name__ == '__main__':
    s1 = Singleton(1,2)
    s2 = Singleton([],{})

    print(s1 == s2)
    print(s1 is s2)
    print(s1)
    print(s2)
    print(s1.a)
    print(s2.a)

True
True
<__main__.Singleton object at 0x000001E4EEDA6438>
<__main__.Singleton object at 0x000001E4EEDA6438>
1
1

4. 使用文件导入的形式

s1.py

class Foo(object):
    def test(self):
        print("123")

v = Foo()
#v是Foo的实例

s2.py
from s1 import v as v1
print(v1,id(v1))  #<s1.Foo object at 0x0000000002221710> 35788560

from s1 import v as v2
print(v1,id(v2))   #<s1.Foo object at 0x0000000002221710> 35788560

# 两个的内存地址是一样的
# 文件加载的时候，第一次导入后，再次导入时不会再重新加载。