多层语法糖+递归

今日内容

多层语法糖

def outter1(func1):    # 1先看函数
    print('加载了outter1')
    def wrapper1(*args, **kwargs):
        print('执行力wrapper1')
        res1 = func1(*args, **kwargs)
        return res1
    return wrapper1

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


def outer3(func3):    # 3
    print('加载了outter3')
    def wrapper3(*args, **kwargs):
        print('执行了warpper3')
        res3 = func3(*args, *kwargs)
        return res3
    return wrapper3
@outer1  # index = outer1(加载了outer3的index即wrapper2)>>>wrapper1——>index
@outer2  # outer2(加载了outer3的index即wrapper3)>>>wrapper2
@outer3  # outer3(原本的index)>>>wrapper3
def index():    # 4
    print('form index')
 
index()
"""多层语法糖 加载顺序由上往下
每次执行了之后如果上面还有语法糖 就直接将返回函数名传给上面的语法糖
如果上面没有语法糖了 就变形 index = outter(wrapper)

"""

有参装饰器 脑子太笨了直接背模板把

# 校验用户是否登录装饰器
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

装饰修福技术(了解一下，装逼用的)

# def index():
#     """index函数 非常的牛"""
#     pass
# help(index)
# help(len)
from functools import wraps
def outer(func_name):
    @wraps(func_name)  # 仅仅是为了让装饰器的效果更加逼真 平时可以不写
    def inner(*args, **kwargs):
        """我是inner 我擅长让人蒙蔽"""
        res = func_name(*args, **kwargs)
        return res
    return inner

@outer
def func():
    """我是真正的func 我很强大 我很牛 我很聪明"""
    pass


# help(func)
# print(func)
func()

递归函数

1.函数的递归调用
	函数直接或者间接的调用了函数自身
 	  # 直接调用
    def index():  # 1写一个函数
         print('from index') # 3
         index()  # 又返回函数index一直反复
    index()   # 2   
    
     # 间接
    def index():  # 1函数
         print('from index') # 6
         func() # 7 又回到func 
    
    def func():  # 2函数
         print('from func') # 4
         index() # 5.又回到index
    
     func() # 3   
    '''最大递归深度:python解释器添加的安全措施'''
     count = 0
     def index():
         global count
         count += 1
         print(count)
         index()
     index()
#官网提供的最大递归深度为1000
2.递归函数
	直接或者间接的调用自己
    每次调用都比上一次简单，并且需要有一个明确的结束条件
    	递推 一层层往下
        回溯 基于明确结果一层层往上
        
        
         	 """
    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  # 明确结果18
        return get_age(n-1) + 2  # 刚开始时n-1+2一层层往上
    res = get_age(5)  # n就是get_age(5)  
    print(res)   

作业

l1 = [1,[2,[3,[4,[5,[6,[7,[8,]]]]]]]]
def print_list(lst):
    for l in lst:
        tif ype(l) is int:
            print(l)
        elif type(l) is list:
            print_list(l)
print_list(l1)