单例模式(Singleton Pattern)是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在，不管实例化多少次就只有一个实例
单例设计模式的优点是不占内存，每个人都调用一个实例对象
那在python里面怎么怎么实现单例模式呢，单例模式就是只有一个实例，那肯定是指类在实例化的时候，只会实例化一个，就需要用到类里面的一个内置函数__new__，类就是通过这个函数来进行实例化操作的，它在__init__之前先执行
那我们知道类是通过__new__函数来进行实例化的，那就好办了，思路就是先判断一下这个类有没有被实例化过，如果实例化过了，那我们就不要调用继续实例化了，返回原来的那个实例，如果没有被实例化才继续实例化
先写一个普通的类，看一下实例化之后的内存地址，可以看到，正常的一个类，实例化两次，内存地址是不一样的，不是一个对象，如下图：
再写单例模式，再实例化看内存地址是一样的，重写__new__这个方法，如果想实例化必须调用一个父类的__new__(cls)方法，要不然不能实例化，单例模式的写法也很单一，死记硬背就可以了，代码如下：
工厂模式就是类继承，就是流水线模式
本质上由decorator和嵌套的wrapper组成一个共生体，这个共生体我们叫做闭包，闭包满足三个条件
1、函数嵌套函数
2、函数返回函数
3、函数间有参数引用
满足这三个条件的嵌套函数我们称之为闭包，闭包在python中即为修饰器，因此我们可以将代码写成如下形式：
@deco
def f():
print('hello')
time.sleep(1)
print('world')
python装饰器(fuctional decorators)就是用于拓展原来函数功能的一种函数，目的是在不改变原函数名(或类名)的情况下，给函数增加新的功能，这个函数的特殊之处在于它的返回值也是一个函数，这个函数是内嵌"原"函数的函数
装饰器的作用：
1、装饰器的本质还是一个函数
2、在不改变函数调用方式的情况下，对函数进行额外功能的封装(装饰器的作用就是为已经存在的对象添加额外的功能)
3、装饰一个函数，给他加一个其他功能
import time
def deco(f):
def wrapper():
start_time = time.time()
f()
end_time = time.time()
execute_time = round((end_time - start_time) * 1000, 2)
print('运行的时间是 %s ms' % execute_time)
return wrapper
@deco
def f():
print('hello')
time.sleep(1)
print('world')
if __name__ == '__main__':
f()
这里的deco函数就是最原始的装饰器，它的参数是一个函数名，然后返回值也是一个函数名，其中作为参数的这个函数f()就在返回函数wrapper()的内部执行，然后在函数f()前面加上@deco，f()函数就相当于被注入了计时功能，现在只要调用f()，它就已经变身为"新的功能更多"的函数了，不需要重复执行原函数
# 带有固定参数的装饰器
import time
def deco(f):
def wrapper(a, b):
start_time = time.time()
f(a, b)
end_time = time.time()
execute_time = round((end_time - start_time) * 1000, 2)
print('运行的时间是 %s ms' % execute_time)
return wrapper
@deco
def f(a, b):
print('be on')
time.sleep(1)
print('result is %d' % (a + b))
if __name__ == '__main__':
f(3, 4)
# 无固定参数的装饰器
import time
def deco(f):
def wrapper(*args, **kwargs):
start_time = time.time()
f(*args, **kwargs)
end_time = time.time()
execute_time = round((end_time - start_time) * 1000, 2)
print('运行的时间是 %s ms' % execute_time)
return wrapper
@deco
def f(a, b):
print('be on')
time.sleep(1)
print('result is %d' % (a + b))
@deco
def f2(a, b, c):
print('be on')
time.sleep(1)
print('result is %d' % (a + b + c))
if __name__ == '__main__':
f(3, 4)
f2(3, 4, 5)
# 使用多个装饰器，装饰一个函数
import time
def deco01(f):
def wrapper(*args, **kwargs):
print("this is deco01")
start_time = time.time()
f(*args, **kwargs)
end_time = time.time()
execute_time = round((end_time - start_time) * 1000, 2)
print('运行的时间是 %s ms' % execute_time)
print("deco01 end here")
return wrapper
def deco02(f):
def wrapper(*args, **kwargs):
print("this is deco02")
f(*args, **kwargs)
print("deco02 end here")
return wrapper
@deco01
@deco02
def f(a, b):
print('be on')
print('result is %d' % (a + b))
if __name__ == '__main__':
f(3, 4)
执行结果如下：
装饰器调用顺序：
装饰器是可以叠加使用的，那么使用装饰器以后代码是啥顺序呢？，在这个例子中，"f(3, 4) = deco01(deco02(f(3, 4)))"