多层装饰器

目录

• 今日内容概要
  • 今日内容详解
    • 多层语法糖
    • 有参装饰器
    • 装饰器模板
    • 装饰器修复技术
    • 递归函数

今日内容概要

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

今日内容详解

多层语法糖

def outter1(func1):  # 1.定义一个函数outter1
    print('加载了outter1')  # 12.打印内容

    def wrapper1(*args, **kwargs):
        print('执行了weapper1')  # 15.打印内容
        res1 = func1(*args, **kwargs) # 16.因为 func1 = wrapper2  所以 func1（） = wrapper2 （）
        return res1

    return wrapper1  # 13.获得返回值wrapper1


def outter2(func2):  # 2.定义一个函数outter2
    print('加载了outter2')  # 9.打印内容

    def wrapper2(*args, **kwargs):
        print('执行了weapper2')  # 17. 打印内容
        res2 = func2(*args, **kwargs)  # 18. 因为 func2 = wrapper3 所以 func2（） = wrapper3（）
        return res2

    return wrapper2  # 10.获得返回值wrapper2


def outter3(func3):  # 3.定义一个函数outter3
    print('加载了outter3')  # 6. 打印内容

    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')  # 19.打印内容
        res3 = func3(*args, **kwargs) # 20. 因为 func3 = 真正的index  所以 func3（） = 真正的index（）
        return res3

    return wrapper3  # 7.获得返回值wrapper3


@outter1  # 11.调用函数outter1中的函数体代码  index = outter1（wrapper2）>>>:返回值是wrapper1
@outter2  # 8.调用函数outter2中的函数体代码  outter2 = outter2（wrapper3）>>>:返回值是wrapper2
@outter3  # 5.调用函数outter3中的函数体代码  outter3 = outter（真正的index） >>>返回值是wrapper3
def index():  # 4.定义一个函数index
    print('from index') # 21. 打印内容


index()  # 14.将outter返回值给index使用 index（）= wrapper1（）
    

有参装饰器

'当装饰器中需要额外的参数时>>>:有参装饰器'

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('数据来源于数据库')
        return inner
    return login_auth

  
  '''  
  函数名加括号执行优先级最高 有参装饰器的情况 
    先看函数名加括号的执行
    然后再是语法糖的操作
    '''
  
@outer('1')
def index():
    print('hello')
index()


@outer('2')
def func():
    print('world')
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
def outer(func):
    @wraps(func)  # 修复技术就是为了让被装饰对象更加不容易被察觉装饰了
    def inner(*args, **kwargs):
        print('执行函数之前可以添加的额外功能')
        res = func(*args, **kwargs)  # 执行被装饰的函数
        print('执行函数之后可以添加的额外功能')
        return res  # 将被装饰函数执行之后的返回值返回
    return inner

@outer  # index = outer(index)
def index():
    print('from index')
print(index)
help(index)

def home():
    """这是一个home函数"""
    print('from home')
 help(index)
 help(home)
 print(index)
 help(len)

递归函数

递归函数:函数在运行过程中 直接或者间接的调用了自身

官网表示:python默认的最大递归深度为1000次
框架 查看递归最大次数
import sys
获取递归的限制
print(sys.getrecursionlimit())
修改递归限制次数
print(sys.setrecursionlimit(2000))
 定义一个
count = 1
 定义一个函数
def index():
     在局部想要修改全局的不可变类型数据
    global count
     叠加
    count +=1
     打印
    print(count)
    print('from index')
     内部调用函数
    index()
 调用函数
index()
 递归
      1.递推
           一层层往下推导答案(每次递归之后复杂度相较于上一次一定要有所下降)
        2.回溯
            依据最后的结论往后推导出最初需要的答案
        递归一定要有结束条件！！！
        
 
 伪代码:可能无法运行 但是可以表述逻辑
age(5) = age(4) + 2
age(4) = age(3) + 2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 18

1.递推
一层层往下推导答案(每次递归之后复杂度相较于上一次一定要有所下降)
2.回溯
依据最后的结论往后推导出最初需要的答案
代码运行

定义一个函数 参数用n表示
def get_age(n):
     判断n是否等于1
    if n == 1:
         返回18
        return 18
     返回值 调用函数
    return get_age(n - 1) + 2
 打印 调用函数
print(get_age(3))