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

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

目录

• 多层语法糖、装饰器、递归函数
  • 一、多层语法糖
  • 二、有参装饰器
  • 三、装饰器模板
    • • 1、最常用的无参装饰器
      • 2、不常用的有参装饰器
  • 四、装饰器修复技术
  • 五、递归函数
    • • 1、函数的递归调用
      • 2、递归函数

一、多层语法糖

多层语法糖就是有多个@函数名，一个函数就有多个功能。

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

@outter1
@outter2  # 双层语法糖
def index():
    print('from index')

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

• 代码执行顺序

二、有参装饰器

有参装饰器目的仅仅是给装饰器传递额外的参数。

ps:装饰器最多就三层嵌套，但是一层是最常见的。

def outer(condition,type_user):
    def login_auth(func_name):  # 这里不能再填写其他形参
        def inner(*args, **kwargs):  # 这里不能再填写非被装饰对象所需的参数
            username = input('username>>>:').strip()
            password = input('password>>>:').strip()
            # 应该根据用户的需求执行不同的代码
            if type_user =='jason':print('VIP')
            if condition == '列表':
                print('使用列表作为数据来源 比对用户数据')
            elif condition == '字典':
                print('使用字典作为数据来源 比对用户数据')
            elif condition == '文件':
                print('使用文件作为数据来源 比对用户数据')
            else:
                print('去你妹的 我目前只有上面几种方式')
        return inner
    return login_auth
    
@outer('文件','jason')
def index():
    print('from index')
index()

三、装饰器模板

1、最常用的无参装饰器

def outer(func_name):
    def inner(*args,**kwargs):
        res = func_name(*args,*kwargs)
        return res
    return inner
@outer
def index():
    pass

2、不常用的有参装饰器

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

四、装饰器修复技术

使用装饰器有一个小毛病，就是想要查看被装饰器的注释或者名字时，比如使用如下方法时：
print(help(index)) # 查看函数的注释
print(index.__name__) # 查看函数名字符串形式
结果看到的注释不是被装饰器的注释，而是装饰器里面的内部闭包函数的注释。
查看到的函数名字也是装饰器内部函数的名字，调用函数的时候，想看函数的名字和注释，看到的却不是对的。
基于以上情况，Python提供了解决方案，叫做装饰器修复技术。
# 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():
    print('from index')
    index()
index()
# 会先输出一部分from index，然后报错。因为此代码会一直开辟局内空间，类似死循环，为防止内存溢出，Python解释器会启用自带的安全措施。

#间接调用
def index():
    print('from index')
    func()
    
def func():
    print('from func')
    index()
func()
# 会交替输出from index及from func，然后报错。

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

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
    return get_age(n-1) + 2
res = get_age(5)
print(res)

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

l1 = [1,[2,[3,[4,[5,[6,[7,[8,]]]]]]]]
def l1_list(a):
    for i in a :
        if isinstance(i,int):
            print(i)
        else:
            l1_list(i)
    return a
l1_list(l1)