多层语法糖、有参装饰器、递归函数

内容回顾

内容回顾
多层语法糖
有参装饰器
无参、有参装饰器模板
装饰器修复技术
递归函数
练习

多层语法糖
有参装饰器
装饰器模板
装饰器修复技术
递归函数

多层语法糖

def outter1(func1):
    print('加载了outter1')
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)  # func1相当于wrapper2
        return res1
    return wrapper1

def outter2(func2):
    print('加载了outter2')
    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)  # func2相当于wrapper3
        return res2
    return wrapper2
def outter3(func3):
    print('加载了outter3')
    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)  # func3相当于真正的index函数
        return res3
    return wrapper3
	
# 打印执行流程
# 1、加载了outter3
# 2、加载了outter2
# 3、加载了outter1
# 4、执行了wrapper1
# 5、执行了wrapper2
# 6、执行了wrapper3
# 7、打印from index
@outter1  # 将outter2(wrapper3)返回值wrapper2当做数据值传给outter1则:outter1(wrapper2)返回值是wrapper1被index变量名接收 简:index=outter1(wrapper2)  index=wrapper1
@outter2  # 将outter3(index)返回值wrapper3当做数据值传给outter2则:outter2(wrapper3)返回值是wrapper2 简:wrapper2=outtr2(wrapper3)
@outter3  # 将index当做数据值传给outter3函数则:outter3(index)返回值是wrapper3 简:wrapper3=outter(index)
def index():
    print('from index')
index()    # 相当于warpper1加括号
'''
多层语法糖 加载顺序由下往上
每次执行之后如果上面还有语法糖 则直接将返回值函数名传给上面的语法糖
如果上面没有语法糖了 则变形为 index = outter1(wrapper2)
'''

有参装饰器

# 校验用户是否登录装饰器
def outer(mode):
    def login_auth(func_name):
        def inner(*args,  **kwargs):
            username = input('username>>>:').strip()
            password = input('password>>>:').strip()
            if mode == '1':
                print('数据直接写死')
            elif mode == '2':
                print('数据来源与文本文件')
            elif mode == '3':
                print('数据来源于字典')
            elif mode == '4':
                print('数据来源于MySQL')
        return inner
    return login_auth
'''当装饰器中需要额外的参数时>>>:有参装饰器'''
'''
函数加括号执行优先级最高 有参装饰器的情况
	先看函数名加括号的执行
	然后再是语法糖的操作
'''

@outer('1')    # 先执行outre加括号这时mode=1再返回login_auth给@在执行语法糖——>@login_auth
def index():
    print('from idex')
index()

@outer('2')
def func():
    print('from func')
func()

无参、有参装饰器模板

# 最常用的无参装饰器
def outer(func_name):
    def inner(*args, **kwargs):
        res = func_name()
    return res
return inner

@outer
def index():
    pass

#不常用的无参装饰器
def outer_plus(mode):
    def outer(func_name):
        def inner(*args, **kwargs):
            res = func_name(*args, **kwargs)
            return res
     	return inner
    return outer
@outer_plus('MySQL')
def func():
    pass

装饰器修复技术

def index():
    '''index函数 特别厉害'''
    pass
help(index)
help(len)
from functool import wraps
def outer(func_name):
    @wraps(func_name)  # 为了让装饰器的效果更加逼真
    def inner(*args, **kwargs):
        '''我是inner 我的目的是为了迷糊人'''
        res = func_name()
        return res
    return inner

@outer
def func():
    '''我是真正的func没有被装饰'''
    pass

help(func)  # 可以不用执行print打印 结果是 func() 我是正真的func没有被装饰
# print(func)
# func()

递归函数

1.函数的递归调用
	函数直接或者间接的调用了函数自身
# 直接调用
def index():
    print('from index')
    index()
index()
# 间接
def inex():
    print('from index')
    func()
    
def func():
    print('from func')
    index()
func()

'''最大递归深度：python解释器添加的安全措施'''
count = 0
def index():
    global count
    count += 1
    print(count)
    index()
index()
'''官网提供最大递归深度为1000 我们在测试的时候可能会出现996 998'''

2.递归函数
	1.直接或间接调用
    2.每次调用都必须比上一次简单 并且需要有一个明确的结束条件
    
    递推：一层层往下
    回溯:基于明确的结果一层层往往上
    
伪代码：
	age(5) = age(4) + 2 第五个人的年龄比第四个人的年龄大2岁
    age(4) = age(3) + 2 第四个人的年龄比第三个人的年龄大2岁
    age(3) = age(2) + 2 第三个人的年龄比第二个人的年龄大2岁
    age(2) = age(1) + 2 第二个人的年龄比的一个人的年龄大2岁
    age(1) = 18		    第一个人的年龄是18岁

    
def get_age(n):
    if n == 1:
        return 18
    return get_age(n-1) + 2
res = get_age(5)
print(res)

练习

利用递归函数依次打印出列表中的每一个数据值
	l1 = [1,[2,[3,[4,[5,[6,[7,[8,]]]]]]]]
    
# 分析列表一个大列表套了多个小列表 那对l1列表for循环遍历拿到数据值是整型1和列表[2,[3,[4,[5,[6,[7,[8,]]]]]]]
# 然后再判断遍历出来的数据值是整型则打印 不是则将列表再循环遍历
def func(num):
    for i in num:
        if type(i) == int:
            print(i)
        else:
            func(i)
func(l1)  # 1 2 3 4 5 6 7 8