Python学习路程——Day12
global与nonlocal
'''
global:
是一个内置方法，它的作用是在函数体内声明一个全局名称空间，让这个全局名称空间可以在函数体内的局部名称空间中被修改。
'''
name = 'Jason'
def index():
global name
name = 'Tony'
index()
print(name)
# 输出结果为：Tony
'''
nonlocal:
它的作用是在内层局部名称空间修改外层局部名称空间中的数据
'''
def index():
name = 'Maria'
def inner ():
nonlocal name
name = 'Tom'
inner()
print(name)
index()
# 输出结果为：Tom
函数的多种用法
函数名其实绑定的也是一块内存地址，该内存地址内存放的是一段代码，函数名加()就可以找到并执行该段代码。
1.可以做变量名赋值
def index():
print('我可以被res+()输出')
res = index # 把函数名index作为变量名传给res
res() # 通过res() 就可以调用函数index
# 输出结果为：我可以被res+()输出
2.可以当作函数的参数
def index():
print('I\'m index' )
def func(a):
print(a)
a()
func(index) # 把函数名index作为func的实参，输出结果为index函数里的东西
# 输出结果为：I'm index
3.可以当作函数的返回值
def index():
print('I\m index')
def func():
print('I\m func')
return index
res = func() # 先调用func()，输出I\m func
print(res) #输出res绑定的内存地址 <function index at 0x000001C16883A320>
res() #调用res()函数， 输出I\m index
4.可以做容器类型（可以存放多个数据的数据类型）的数据
# 我们定义了一大波功能性函数
def register():
print('注册功能')
def login():
print('登录功能')
def withdraw():
print('提现功能')
def transfer():
print('转账功能')
def shopping():
print('购物功能')
# 定义一个字典，用键值对的形式，来接收定义的函数的函数名，函数名里存的是内存地址
func_dict = {
'1': register,
'2': login,
'3': withdraw,
'4': transfer,
'5': shopping
}
while True:
# 获取用户的选择
user_chioce = input('>>>:')
# 判断用户的选择的在不在字典里
if user_chioce in func_dict:
# 定义一个变量接收字典内的函数地址
chioce = func_dict.get(user_chioce)
# 通过变量+()调用函数
chioce()
else:
print('您输入的序号不存在！')
闭包函数
闭包函数的定义
'''
闭包函数：
必须要满足两个
1.要是一个嵌套函数
2.内层函数要用到外部函数名称空间中的名字
'''
def index():
name = 'Jason'
def inner():
print(name)
闭包函数实际应用
'''
是一种给函数代码传参的方式
'''
def outer(name, age):
# name = 'jason'
# age = 18
def register():
print(f"""
姓名:{name}
年龄:{age}
""")
return register
res = outer('jason', 18)
res()
res = outer('kevin', 16)
res()
'''
输出结果：
姓名:jason
年龄:18
姓名:kevin
年龄:16
'''
装饰器
装饰器的简介
'''
1.概念
在不改变被装饰对象原代码和调用方式的情况下给被装饰对象添加新的功能
2.本质
并不是一门新的技术 而是由函数参数、名称空间、函数名多种用法、闭包函数组合到一起的结果
3.口诀
对修改封闭 对扩展开放
'''
装饰器推导
import time
def index():
time.sleep(3)
print('from index')
def home():
time.sleep(1)
print('from home')
'''1.直接在调用index函数的前后添加代码'''
start_time = time.time()
index()
end_time = time.time()
print('函数index的执行时间为>>>:', end_time-start_time)
'''2.index调用的地方较多 代码不可能反复拷贝>>>:相同的代码需要在不同的位置反复执行>>>:函数'''
def get_time():
start_time = time.time()
index()
end_time = time.time()
print('函数index的执行时间为>>>:', end_time - start_time)
get_time()
'''3.函数体代码写死了 只能统计index的执行时间 如何才能做到统计更多的函数运行时间 直接传参变换统计的函数'''
def get_time(xxx):
start_time = time.time()
xxx()
end_time = time.time()
print('函数的执行时间为>>>:', end_time - start_time)
get_time(index)
get_time(home)
'''4.虽然实现了一定的兼容性 但是并不符合装饰器的特征 第一种传参不写 只能考虑闭包'''
def outer(xxx):
# xxx = index
def get_time():
start_time = time.time()
xxx()
end_time = time.time()
print('函数的执行时间为>>>:', end_time - start_time)
return get_time
res = outer(index)
res()
res1 = outer(home)
res1()
'''5.调用方式还是不对 如何变形>>>:变量名赋值绑定 (******)'''
def outer(xxx):
def get_time():
start_time = time.time()
xxx()
end_time = time.time()
print('函数的执行时间为>>>:', end_time - start_time)
return get_time
res = outer(index) # 赋值符号的左边是一个变量名 可以随意命名
res1 = outer(index)
res2 = outer(index)
jason = outer(index)
index = outer(index)
index()
home = outer(home)
home()
'''6.上述装饰器只能装饰无参函数 兼容性太差'''
def func(a):
time.sleep(0.1)
print('from func', a)
def func1(a,b):
time.sleep(0.2)
print('from func1', a, b)
def func2():
time.sleep(0.3)
print('from func2')
func(123)
def outer(xxx):
def get_time(a, b):
start_time = time.time()
xxx(a, b)
end_time = time.time()
print('函数的执行时间为>>>:', end_time - start_time)
return get_time
func1 = outer(func1)
func1(1, 2)
func = outer(func)
func(1)
func2 = outer(func2)
func2()
'''7.被装饰的函数不知道有没有参数以及有几个参数 如何兼容'''
def func(a):
time.sleep(0.1)
print('from func', a)
def func1(a,b):
time.sleep(0.2)
print('from func1', a, b)
def outer(xxx):
def get_time(*args, **kwargs): # get_time(1,2,3) args=(1,2,3)
start_time = time.time()
xxx(*args, **kwargs) # xxx(*(1,2,3)) xxx(1,2,3)
end_time = time.time()
print('函数的执行时间为>>>:', end_time - start_time)
return get_time
func = outer(func)
func(123)
func1 = outer(func1)
func1(1, 2)
'''8.如果被装饰的函数有返回值'''
def func(a):
time.sleep(0.1)
print('from func', a)
return 'func'
def func1(a,b):
time.sleep(0.2)
print('from func1', a, b)
return 'func1'
def outer(xxx):
def get_time(*args, **kwargs):
start_time = time.time()
res = xxx(*args, **kwargs)
end_time = time.time()
print('函数的执行时间为>>>:', end_time - start_time)
return res
return get_time
func = outer(func)
res = func(123)
print(res)
func1 = outer(func1)
res = func1(123, 123)
print(res)
装饰器模板
'''
装饰器模板作用：
有了这个模板，我们就可以偷懒了！爽
创建装饰器的流程，其实就像我们有一套新房子需要装修的流程一样，具体对应关系如下所示：
我们所拥有的房子 = 需要装饰的代码
我装修房子，有前置要求，不能动我房子本身的任何结构（不改变被装饰对象的原代码），不能动我的门牌号（不改变调用方式），要让人能通过门牌号找到我，在这样的前提下，给我房子增加新的装饰品（添加新功能）
具体步骤：
1. 需要一个被装饰的对象（房子）
2. 创建装饰器 （开始装修）
2.1 创建一个闭包函数———闭包函数，需要是一个有嵌套，而且内层函数调用外层函数名称空间的函数。
具体解释步骤、代码流程在下面展示：
'''
# 首先我们要有一段需要被装饰的代码（房子）
def func(a, b):
print('I\'m func', a, b)
return 'func'
# 接下来我们要写装饰器（找装修队开始装修房子）
# 创建一个闭包函数（找一个好的装修队）
def outer(house): # 形参的意义：需要实参（房子）进行动态绑定。（装修队需要我们告诉他我们的房子是啷个）
def inner(*args, **kwargs): # 装修队准备开始干活，这里形参存在的意义是，接收不同户型不同的要求，即被装饰的对象有参和无参。
print('执行被装饰对象之前可以做的额外操作')# 这里是开始装修房子之前，我们是否移情别恋了，是否有什么特殊要求癖好，需要装修队能做，我们才让他装修，没有就直接开干
res = house(*args, **kwargs) # 这里就是我们房子，装修队需要来到我们的房子然后进行装修 （这里的参数是我们的房子是否有是什么特殊的配置）
print('执行被装饰对象之后可以做的额外操作') # 到了这一步，装修队就开始装修我们的房子了，在这里装修队根据我们的要求干活就行了
return res # 返回我们的房子res 然后把装修好的房子给交付了
return inner # 返回inner 把inner传给func，可以用func来调用inner
func = outer(func) # 这一步是进行狸猫换太子，让用户误以为使用的是func函数（其实在这里func绑定的已经是inner了）
func(11,22) # 我们调用函数func，并给他传参，任务完成
装饰器语法糖
def outer(func_name):
def inner(*args, **kwargs):
print('执行被装饰对象之前可以做的额外操作')
res = func_name(*args, **kwargs)
print('执行被装饰对象之后可以做的额外操作')
return res
return inner
"""
语法糖会自动将下面紧挨着的函数名当做第一个参数自动传给@函数调用
"""
@outer # func = outer(func)
def func():
print('I\'m func')
return 'func'
@outer # index = outer(index)
def index():
print('I\'m index')
return 'index'
func()
index()