多层语法糖

多层语法糖 加载顺序由下往上
每次执行之后如果上面还有语法糖 则直接将返回值函数名传给上面的语法糖
如果上面没有语法糖了 则变形 index = outter1(wrapper2)

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

def outter2(func2):
    print('加载了outter2')
    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2
    return wrapper2

def outter3(func3):
    print('加载了outter3')
    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3
    return wrapper3


@outter1
@outter2
@outter3
def index():
    print('from index')
    

有参装饰器

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')
def index():
    print('from index')
index()

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

装饰器模板

 * 最常用的无参装饰器
 def outer(func_name):
     def inner(*args, **kwargs):
         res = func_name(*args, **kwargs)
         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
     

装饰器修复技术

from functools import wraps
     pass
   @wraps(func_name)  # 仅仅是为了让装饰器的效果更加逼真 平时可以不写
   

递归函数

* 函数的递归调用： 函数直接或者间接调用了函数本身
1 直接调用
def index():
    print('from index')
    index()
index()
2 间接
def index():
    print('from index')
    func()

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

func()

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

* 递归函数
直接或者间接调用自己
每次调用都比上一次简单 并且需要一个明确的结束条件
    get_age(5) = get_age(4) + 2
    get_age(4) = get_age(3) + 2
    get_age(3) = get_age(2) + 2
    get_age(2) = get_age(1) + 2
    get_age(1) = 18
    def get_age(n):
        if n == 1:
            return 18
        return get_age(n-1) + 2
    res = get_age(5)
    print(res)
    
  递归函数真正的应用场景 
    递推:一次次寻找答案直到找到答案
    回溯:根据最终答案在向回推导找到答案
    

1.利用递归函数依次打印列表中每一个数据值 l1 = [1,[2,[3,[4,[5,[6,[7,[8,]]]]]]]]