python递归函数

今日内容概要

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

内容详细

多层语法糖

语法糖的定义：

语法糖（Syntactic sugar），也译为糖衣语法，由英国计算机科学家彼得·约翰·兰达发明的一个术语，指计算机语言中添加的某种语法。这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。

    之所以叫“语法”糖，不只是因为加糖后的代码功能与加糖前保持一致，更重要的是，糖在不改变其所在位置的语法结构的前提下，实现了运行时的等价。可以简单理解为，加糖后的代码编译后跟加糖前一致。

    之所以叫语法“糖”，是因为‘加糖后’的代码写起来更爽，包括但不限于：**==代码更简洁流畅，代码更语义自然……写着爽，看着爽，就像吃了糖。==**

    有人将语法糖归类为奇技淫巧，需要声明的是，“语法糖”这个词绝非贬义，它不是糖衣炮弹，更不是口蜜腹剑，它可以给编码带来实实在在的方便，也可以提高编码的效率，更重要的，在性能上也不来损失。

语法糖是约定俗成的，为编译器所认可的，可以带来方便快捷的，编程语法。一定程度上而言，语法糖可以呈现于书本，流通于码界，也可以诞生于指尖。窃以为，能够带来编码便利的语法，皆可称为糖😁

案例：

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,**kwags):
        print('执行了wrapper2')
        res2 = wrapper2(*args,**kwargs)
        return res2
    return wrapper2

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

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

上述案例是语法糖的多层语法糖

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

有参装饰器

有参装饰器：

是为装饰器提供多样功能的选择的实现而提供的，实现的原理是三层闭包

有参装饰器的模板：

def outer(a):
    def outer1(func):
        def wrapper(*args,**kwargs):
            print('流程推对了吗')
            res = func(*args,**kwargs)
            return res
        return wrapper
    return outer1

@outer('mySQL')
def func():
    pass

通过第三层进行传值，使得有参装饰器可以使用其他参数，实现其他功能。

无参装饰器模板:

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

装饰器修复技术

小知识：
   def index():
       """index函数"""
       pass
help(index)
help(len)

结果：
index()
   index函数

Help on built-in function len in module builtins:

len(obj, /)
   Return the number of items in a container.


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 # func = outer(func)
def func():
   '''我是真正的func'''
   pass

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

递归函数

1.函数的递归调用
函数直接或者间接的调用函数自身

直接调用
def index():
    def index ('from index ')
    index()
index()

间接调用
def index():
    print('from index ')
    func()
    
def func():
    print('from func')
    index()
 index()

'''官网提供的最大递归深度为1000，我们在测试的时候可能会出现996 997  998 每个人电脑不同结果也会不同'''

2.递归函数

1.直接或者间接调用自己

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)