装饰器

今日内容详细

global与nonlocalx

money = 666   # 1.命名赋值
def index():   # 2.看到命名函数先找命名函数
	global money  # 4.使用global局部修改全局数据
    money = 123    # 5.修改后的数据
index()            #3.执行函数体代码
print(money)      # 6.打印123 

"""局部空间修改全局空间数据"""

def index():     # 1.看到函数 index直接不用看别的 找对应的
    name = 'shabi'  # 3.第三步执行位置
    def inner():    # 4.从上往下执行又到函数
        nonlocal name  # 6. 使用nonlocal做出修改
        name = 'naocan'  # 7. 修改完毕
    inner()        # 5.第四步对应位置
    print(name)     # 8. 打印naocan
index()          # 2.运行函数体代码

"""内部局部空间修改外层局部空间数据"""

函数名的多种用法

函数名其实绑定的也是一块内存地址 只不过该地址里面存放的不是数据值而是一段代码  函数名加括号就可以找到改代码运行
1.可以当作变量名赋值
	def index():pass
    res = index
    res()
2.可以当作函数参数
	def index():
        print('from index')
    def func(a):
        print(a)
        a()
3.可以当作函数的返回值
	def index():
        print('from index')
    
    def func():
        print('from fucn')
        return index
    res = func()
    print(res)
    res()
    
    def index():
        print('from index')
    def func():
        print('form func')
        return func
    res = index()
    print(res)
    res()
    
4.可以存放多个数据类型的数据  # 简单写两个
	def register():
    	print('注册功能')
	
    def login():
    	print('登录功能')
    
    ## 定义功能便号与功能对应关系
    func_dict = {
        '1':register
        '2':login
    }    
    while True:
        print("""
        1.注册功能
        2.登入功能
        """)
    choice = input('请输入>>>:').strip()
    if choicen in func_dict:
        func_name = func_dict.get(choice)
        func_name()
    else:
        print('编号不存在')

闭包函数

定义在函数内部的函数 并且用到了外部函数名称空间的名字
	1.定义在函数的内容
    2.用到外部函数名称空间中的名字

    def index():
        name = 'jason'
        def inner():
            print(name)
'闭包函数的实际应用实际上就是另一种给函数体代码的传参方式！！！'

# 给函数体代码传参的方式1:
	def register(name,age, gender):
        print(f"""
        姓名:{name}
        年龄:{age}
        性别:{gender}        
        """)
     register('jason', 18, male)
    
    
# 给函数体代码传参方式2：闭包函数
    def outer(name, age):
        def register():
            print(f"""
            姓名:{name}
            年龄:{age}
            """)

        return register


    res = outer('jason', 18)
    res()    
    res = outer('shabi', 28)  # 更改
    res()

装饰器简介

1.概念
	在不改变装饰对象源代码和调用方式的情况下给被装饰对象添加新功能
2.本质
	并不是新的技术 而是由函数参数  名称空间  函数名多种用法，闭包函数组合到一起的结果
3.口诀
	对修改封闭  对扩展开放
4.储备知识
	时间相关操作
    import time
    print(time.time())   # 时间戳(距离1970-01-01 00:00:00所经历的秒数)
    time.sleep(3)    # 间隔三秒打印
    print('你真是个星星星')
    count = 0
    # 循环获取之前的时间戳
    start_time = time.time()
    while  count < 100:
        print('xixixi')
        count += 1
    end_time = time.time()
    print('循环消耗时间:', end_time - start_time)
    

装饰器推导流程

import time
def index():
    time.sleep(3)
    print('from index')
    # from index
def home():
    time.sleep(1)
    print('from home')
    # 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)

装饰器模板

# 务必掌握 
def outer(func):
    def inner(*args, **kwargs):
        		# print('新添加功能代码前')
        res = func(*args, **kwargs)
        		# print('新添加功能代码后')
        return res
    return inner

装饰器语法糖

每次转换的语句func = outer(func)比较麻烦，而且实际写代码时由于位置不固定也十分的乱。

python提供了一个简单语法，来代替这一条语句：

@outer  # 紧贴着要被装饰的函数前，代表func = outer(func)
def func():
	"""被装饰函数"""
    pass