python基础之多层语法糖、函数递归

• 一、多层语法糖
• 二、装饰器模版
• 三、装饰器修复技术
• 四、函数的递归调用
  • 1.函数的递归调用
  • 2.递归函数的定义
  • 3.递归函数的特点
  • 4.递归函数

一、多层语法糖

1.语法糖的语法要点：
  语法糖会'将紧挨着的被装饰对象的名字'当作'参数'自动'传入装饰器'中,然后将'返回的结果重新赋值'给'原函数名'
2 多层语法糖：
  装饰顺序由上往下，遇到最后一个才会将与函数名相同的变量名传给装饰器函数调用
  也就是说，每次执行之后如果上面还有语法糖 则直接将返回值函数名传给上面的语法糖，如果上面没有语法糖了， 则变形最终套娃的结果在案例中为' 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')
index()  # 函数名加括号执行优先级最高

二、装饰器模版

1. 无参装饰器
def outer(func):
    def inner(*args, **kwargs):
        # 原函数调用前添加的功能
        res = func(*args, **kwargs)
        # 原函数调用后添加的功能
        return res
    return inner

@outer
def index():
    pass

index()


2. 有参装饰器
  有参装饰器的目的仅仅是给装饰器传递额外的参数
# 模板
def outer_plus(mode):  # 3只能在外面再包一层函数，为装饰器内部传参
    def outer(func):  # 1这里不能添加额外的参数
        def inner(*args, **kwargs):  # 2这里也不能添加额外的参数
            # 函数前添加的操作
            res = func(*args, **kwargs)
            # 函数后添加的操作
            return res
        return inner

@outer_plus('mode')
def func1():
    pass

有参装饰器案例：校验用户是否登陆装饰器

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

装饰器语法优先级：

​ 1 函数名加括号执行优先级最高,在有参装饰器的情况下,先看函数名加括号的执行
​ 2 然后再是语法糖的操作

三、装饰器修复技术

1.在定义装饰器前填写代码：
from functools import wraps
2.在装饰器中的外层函数代码体中，调用内置的装饰器 @wraps(func_name)
# help(函数名) help关键字可以打印函数内部的代码

# 案例
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)  # help(函数名) help关键字可以打印函数内部的代码
print(func)
func()
--------------------运行结果---------------------
Help on function func in module __main__:

func()
    这里说原始的func函数

<function func at 0x102d789d0>

四、函数的递归调用

1.函数的递归调用

1.直接调用：函数在定义中调用自己
def index():
    print('from index')
    index()
index()
# 最大递归深度：python中添加到安全措施,执行后会一直执行，但执行到一定次数会停止即报错


2.间接调用：函数在彼此的定义中调用彼此
def index():
    print('from index')
    func()
def func():
    print('from func')
    index()
func()
# 最大递归深度：python中添加到安全措施,执行后会一直执行，但执行到一定次数会停止即报错

3.最大递归深度：1000
# 计算最大递归深度
count = 0
def index():
    global count
    count += 1
    print(count)
    index()
index()
'''官网提供的最大递归深度为1000，我们在测试的时候可能会出现996 997'''

2.递归函数的定义

递归函数定义： 
  1 直接或者间接调用自己 
  2 每次调用都必须比上一次简单，并且需要有一个明确结束条件

3.递归函数的特点

1.必须有一个明确的结束条件；
2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少；
3.相邻两次重复之间有紧密的联系，前一次要为后一次做准备（通常前一次的输出就作为后一次的输入）；
4.直接或间接的调用自身的函数，递归效率不高

4.递归函数

# 递推：一层层往下
# 回溯：基于明确的结果一层层往上

# 案例
"""
假设有五个同学，编号从1-5，1号同学的年龄为十八岁，用递归函数如何得到5号同学的年龄
"""
def get_age(number):  # 定义一个获取年龄的函数，参数为数字
    if number == 1:  # 判断 编号1的同学 年龄为18
        return 18
    return get_age(number - 1) + 2  # 返回函数本身，并将值+2


real_age = get_age(5)
print(real_age)

作业：
1.昨日作业回顾

is_login = False


def login_auth(func_name):
    def inner(*args, **kwargs):
        global is_login
        if is_login:
            res = func_name(*args, **kwargs)
            return res
        username = input('username>>>:').strip()
        password = input('password>>>:').strip()
        if username == 'jason' and password == '123':
            is_login = True
            res = func_name(*args, **kwargs)
            return res
        else:
            print('用户名或密码错误无法执行函数')
    return inner


@login_auth
def register():
    print('注册功能')


@login_auth
def login():
    print('登录功能')


@login_auth
def shopping():
    print('购物功能')


register()
login()
shopping()

2.今日作业

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


def get_list(l):  # 定义一个函数
    for i in l:  # 获取列表中的数据
        if type(i) == list:  # 判断数据是列表
            get_list(i)  # 如果数据是列表，将这个数据用该函数继续for循环
        else:  # 判断数据不是列表
            print(i)  # 打印该数据

            
get_list(l1)