python进阶之路11 闭包函数 装饰器

函数名的多种用法

函数名其实绑定的也是一块内存地址 只不过该地址里面存放的不是数据值而是一段代码 函数名加括号就会找到该代码并执行

1.可以当作变量名赋值

def index():pass
    res = index
    res()

2.可以当作函数的参数

def index():
	print('from index')
def func(a):
	print(a)
	a()
func(index)

3.可以当作函数的返回值

def index()
	print('from index')
def func():
	print('from func')
	return index
res = func()
print(res)
res()

def index():
	print('from index')
	def func():
		print('from func')
	return func

res = index()
print(res)
res()

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:
	print(
        """
        1.注册功能
        2.登录功能
        3.提现功能
        4.转账功能
        5.购物功能
        """)
	choice = input('请输入功能编号>>>:').strip()
        if choice in func_dict:
            func_name = func_dict.get(choice)
            func_name()
        else:
            print('功能编号不存在')
		# if choice == '1':
        #     register()
        # elif choice == '2':
        #     login()
        # elif choice == '3':
        #     withdraw()
        # elif choice == '4':
        #     transfer()
        # elif choice == '5':
        #     shopping()
        # else:
        #     print('去你妹的 终于写完了')

闭包函数

定义在函数内部的函数，并且用到了外部名称空间的名字

1.定义在函数内部

2.用到外部函数名称空间中的名字

def index():
    name = 'jason'
    def inner():
        print(name)
闭包函数实际应用>>>:是另外一种给函数体代码传参的方式！！！
# 给函数体代码传参的方式1:代码里面缺什么变量名形参就补什么变量名
def register(name,age):
    print(f"""
    姓名:{name}
    年龄:{age}
    """)
register('jason',18)
# 给函数体代码传参的方式2:闭包函数
def outer(name,age):
     # name = 'jason'
     # age = 18
def register():
       print(f"""
          姓名:{name}
          年龄:{age}
           """)
       return register
    res = outer('jason',18)
    res()
    res()
    res = outer('kevin', 28)
    res()
    res()
    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('哈哈哈')
        count += 1
    end_time = time.time()
    print('循环消耗的时间:', end_time - start_time)

装饰器推导流程

import time

# def index():
#     time.sleep(2)
#     print('from index')
#
#
# def home():
#     time.sleep(3)
#     print('from home')

# start_time = time.time()
# index()
# end_time = time.time()
# print('函数index的执行时间为>>>',end_time - start_time)
'''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):
#     # 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)
# res1 = outer(index)
# res2 = outer(index)
# jason = outer(index)
# index = outer(index)
# index()
# home = outer(home)
# home()
'''6.上述装饰器只能装饰无参函数   兼容性太差'''

# def func(a):
#     time.sleep(3)
#     print('from func', a)
# # func(123)
#
# def func1(a, b):
#     time.sleep(2)
#     print('from func1', a, b)
#
# def func2():
#     time.sleep(2)
#     print('from func2')

# def outer(xxx):
#     def get_time(a,b):
#         start_time = time.time()
#         xxx()
#         end_time = time.time()
#         print('函数的执行时间为>>>', end_time - start_time)
#     return get_time

# func1 = outer(func1)
# func(1,2)
# func = outer(func)
# func(1)
# func2 = outer(func2)
# func2()

'''7.被装饰的函数不知道没有参数以及几个参数 如何兼容'''

# def func(a):
#     time.sleep(3)
#     print('from func', a)
#
# def func1(a, b):
#     time.sleep(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(3)
    print('from func', a)
    return 'func'
def func1(a, b):
    time.sleep(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,333)
print(res)

装饰器模板

# 必须掌握
def outer(func): # 形参func将来用于绑定真正被装饰对象的内存地址
    def inner(*args, **kwargs):
        # 执行被装饰对象之前可以作的操作
        res = func(*args, **kwargs)
        # 执行被装饰对象之后可以作的额外操作
        return res
    return inner

装饰器语法糖

def outer(func):
    def inner(*args, **kwargs):
        print('执行被装饰对象之前可以作的操作')
        res = func(*args, **kwargs)
        print('执行被装饰对象之后可以作的额外操作')
        return res
    return inner
@outer # func = outer(func)
def func():
    print('from func')
    return 'func'
@outer # index = outer(index)
def index():
    print('from index')
    return 'index'

func()
index()

小练习

编写一个用户认证装饰器

函数:register login transfer withdraw

基本要求

执行每个函数的时候必须先校验身份 eg: jason 123

拔高练习(有点难度)

执行被装饰的函数 只要有一次认证成功 那么后续的校验都通过

提示:全局变量 记录当前用户是否认证

user_login = False   # 写一个是否登录过的条件 user_login
def outer(func):
    def inner(*args, **kwargs):
        global user_login   # 将user_login变量设置成全局变量
        if user_login:       # 为True执行装饰器功能
            ret = func(*args, **kwargs)
            return ret
        else:
            # 执行用户校验功能
            username = input('username>>>:').strip()
            password = input('password>>>:').strip()
            if username == 'jason' and  password == '123':
                user_login = True    # 校验后为True  下面执行装饰器功能
                ret = func(*args, **kwargs)
                return ret
            else:
                print('用户名或密码不正确')
    return inner

# @outer
# def register():
#     print('用户注册功能')

@outer
def login():
    print('登录功能')

def transfer():
    print('转账功能')

def withdraw():
    print('提现功能')

# register()
login()
transfer()
withdraw()