一、global与nonlocal
#global
x = 1 def f1():
global x # 声明此处是全部变量x
x = 2
print(x) f1() # 调用f1后，修改了全局变量x = 2
print(x) # 打印结果为2 # nonlocal
def f1():
x = 1
def f2():
nonlocal x # 此处声明使用外层函数的变量x
x = 2 # 将外层函数进行了修改
print(x) #
f2()
print(x) # 因为f1()下的x已经被修改，所以打印结果为2 f1()
二、闭包函数
1、什么是闭包函数？
①、根据名词解析：
闭：定义在函数内部的函数，特点是只能在函数内部使用；
包：该函数引用了一个名字，改名字来自函数外层，但又不是全局名称空间
# 闭包函数
def f1()
x = 1
def f2():
print(x)
f2()
# f2()就是一个闭包函数
②、闭包函数升级：能够在全局名称空间使用闭包函数名称
在闭包函数中，使用了函数嵌套，函数名称空间与定义域的知识，要想能够在全局定义域使用闭包函数，就需要使用函数对象的知识
函数可以如变量一般被引用、被当做参数，当然也能被用来赋值给变量，函数名实质上绑定了存放函数内存空间的内存地址，在不＋（）的情况下，我们得到的是内存地址，就可以赋值到全局名称空间
# 闭包函数
def f1()
x = 1
def f2():
print(x)
return f2 # 此处返回函数f2的内存地址，千万不要加括号 f = f1() # f ------>调用f1()----->返回f2内存地址
f() # 此时，f指向了f2的内存地址，并且是全局名称空间的名称
③为函数传参的两种方式
- 直接以参数的形式传入
- 通过闭包函数的形式包给函数
# 给函数传参的两种方式
#方式一
def f1(x):
print(x) f1("ksdffbksd") #方式二
def f2():
x = 2
def f3():
print(x)
f2() f2()
三、装饰器
1、什么是装饰器
装饰器思想：在开放封闭原则下为被修饰对象添加新功能，所谓开放原则是对拓展新功能是开放的，封闭原则是指对源代码不进行修改，不改变源代码调用方式。
实际生产中，如果需要对以上线的程序添加新功能，但是为了保证程序运行的稳定性与安全性，会根据装饰器思想进行添加。
装饰器：指创建一个工具，在遵循以下原则前提下，为被装饰对象添加新功能
- 原则1：不修改被装饰对象源代码
- 原则2：不修改被装饰对象调用方式
2、装饰器详解
现有需求：为函数增加计时功能，该如何实现？
方案一：修改源代码
# 方案一：修改源代码
def f1():
start = time.time()
print("hhhh")
end = time.time()
time.sleep(0.8)
print("run time is %s" %(end - start)) f1()
# 改变了源代码，没有改变调用方式
方案二：在函数后增加代码
#方案二：在函数后增加代码
start = time.time()
f1()
end = time.time()
print("run time is %s" %(end - start))
#没有改变源代码，也没有改变调用方式，但是需要重复代码，并且比较复杂
方案三：将后面的功能代码写成函数
# 方案三：将后面的功能代码写成函数
def f2():
start = time.time()
f1()
end = time.time()
print("run time is %s" % (end - start)) f2()
# 没有改变源代码，但是改变了调用方式
方案四：使用闭包函数，可以实现不改变源代码，并且不改变调用方式
# 方案四使用闭包函数，可以实现不改变源代码，并且不改变调用方式
def outter():
def f2():
start = time.time()
f1()
end = time.time()
print("run time is %s" % (end - start))
return f2 # 我们需要返回封装好的函数内存地址，所以千万不要加（） f = outter()
f()
#实现了添加功能，也没有改变源代码，但是调用方式改变了
- 方案五：使用修改后的闭包函数
- #使用修改后的闭包函数
def outter():
def f2():
start = time.time()
f1()
end = time.time()
print("run time is %s" % (end - start))
return f2f1 = outter() # 可以在*域中，将f2的内存地址赋值给f1，此时，原函数调用没有改变
f1()
#注意，此处的f1不是原来的f1，而是经过“打包”后的f2，只是名字也叫f1
# 我们还发现一个问题，这个闭包函数只可以对f1有用，但是我们需要一个能够通用的工具
- 方案六：通用装饰器
#通用装饰器
def outter(func):
def f2():
start = time.time()
func()
end = time.time()
print("run time is %s" % (end - start))
return f2 f1 = outter(f1)
f1()
# 进一步的，我们将函数名按照常用的规范改写
def outter(func):
def wrapper():
start = time.time()
func()
end = time.time()
print("run time is %s" % (end - start))
return wrapper f1 = outter(f1)
f1()
#在这里，f1()是没有参数的，如果f1是有参数的呢？
- 方案七：有参函数的装饰器
# 有参函数的装饰器
def print1(name):
print(name)
time.sleep(1) def outter(func):
def wrapper(name): # 注意这里和无参函数的区别，由于我们之前的操作就是将封装好的wrapper函数重新复制，
# 但是实质还是wrapper，所以我们要在这里添加一个参数，为函数体内的修饰对象func()传参
start = time.time()
func(name) # 将wrapper接受的参数放进我们所修饰的对象
end = time.time()
print("run time is %s" % (end - start))
return wrapper print1 = outter(print1)
print1("hadsbf")
#上面将装饰器写死了，只能对print1函数有效，如何做到对所有函数有效呢？
- 方案八：有参函数装饰器改进,使用*与**
# 有参函数装饰器改进,使用*与**
def print1(name):
print(name)
time.sleep(1) def outter(func):
def wrapper(*args,**kwargs): # 由于我们不知道函数有多少参数，所以要用到*args与**kwargs来接受可变数量的参数
start = time.time()
func(*args,**kwargs) # 这里将上面的实参放到函数内，代表将传递过来的参数打散，最后的效果就是原样传递
end = time.time()
print("run time is %s" % (end - start))
return wrapper print1 = outter(print1)
print1("hadsbf")
# 此时，装饰器无论对于有参函数，还是无参函数都同样适用，但是如果有返回值呢？
- 方案九：有返回值函数的装饰器
# 有返回值函数的装饰器
def print1(name):
print(name)
time.sleep(1)
return 111 def outter(func):
def wrapper(*args,**kwargs):
start = time.time()
res = func(*args,**kwargs) # 我们需要一个变量接受函数的返回值
end = time.time()
print("run time is %s" % (end - start))
return res # 我们装饰器的核心是wrapper函数，只需要在wrapper函数中提供返回值即可
return wrapper print1 = outter(print1)
print1("hadsbf")
python语法糖：python官方提供的一种简洁定义装饰器的语法，使用@
# python语法糖
def outter(func):
def wrapper(*args,**kwargs):
start = time.time()
res = func(*args,**kwargs) # 我们需要一个变量接受函数的返回值
end = time.time()
print("run time is %s" % (end - start))
return res # 我们装饰器的核心是wrapper函数，只需要在wrapper函数中提供返回值即可
return wrapper @outter # @+装饰器名称，可以快速完成 pint1 = outter(print1)的函数赋值
def print1(name):
print(name)
time.sleep(1)
return 111
- python装饰器模板
# 装饰器标准模板
def outter(func):
def wrapper(*args,**kwargs):
res = func(*args,**kwargs)
return res
return wrapper
# 可根据实际的需求对模板进行修改
多层装饰器嵌套
# 多层装饰器嵌套
def outter1(func1):
def wrapper1(*args,**kwargs):
print("11111")
res1 = func1(*args,**kwargs)
return res1
return wrapper1 def outter2(func2):
def wrapper2(*args,**kwargs):
print("22222")
res2 = func2(*args,**kwargs)
return res2
return wrapper2 def outter3(func3):
def wrapper3(*args,**kwargs):
print("333333")
res3 = func3(*args,**kwargs)
return res3
return wrapper3 @outter1
@outter2
@outter3
def print1():
print("444444")
当出现多个装饰器时，代码越靠后，则越先封装，如图，首先使用outter3封装print1（），可以看做一个整体：f3，然后再使用outter2修饰f3，修饰后可以看做一个整体：f2，最后使用outter1修饰f2，看做整体f1，所以最先运行的是f1，也就是outter1，遇到func1，则跳转到其修饰的outter2，运行wrapper2，遇到func2，则跳转到outter3，运行wrapper3,遇到func3，则跳转到源代码print1，运行完毕后，返回wrapper3，运行ruturn，退出outter3，如此往后逐层退出，最后结果为：