函数递归调用介绍

函数不仅可以嵌套定义，还可以嵌套调用，即在调用一个函数的过程中，函数内部又调用另一个函数，而函数的递归调用指的是在调用一个函数的过程中又直接或间接地调用该函数本身

例如

在调用f1的过程中，又调用f1，这就是直接调用函数f1本身

def f1():
    print('from f1')
    f1()
f1()

在调用f1的过程中，又调用f2，而在调用f2的过程中又调用f1，这就是间接调用函数f1本身

def f1():
    print('from f1')
    f2()
 
def f2():
    print('from f2')
    f1()
    
f1()

从上图可以看出，两种情况下的递归调用都是一个无限循环的过程，但在python对函数的递归调用的深度做了限制，因而并不会像大家所想的那样进入无限循环，会抛出异常，要避免出现这种情况，就必须让递归调用在满足某个特定条件下终止。

提示：

#1. 可以使用sys.getrecursionlimit()去查看递归深度，默认值为1000，虽然可以使用
sys.setrecursionlimit()去设定该值，但仍受限于主机操作系统栈大小的限制
#2. python不是一门函数式编程语言，无法对递归进行尾递归优化。

回溯与递推

下面我们用一个浅显的例子，为了让读者阐释递归的原理和使用：

例4.5

某公司四个员工坐在一起，问第四个人薪水，他说比第三个人多1000，问第三个人薪水，第他说比第二个人多1000，问第二个人薪水，他说比第一个人多1000，最后第一人说自己每月5000，请问第四个人的薪水是多少？

思路解析：

要知道第四个人的月薪，就必须知道第三个人的，第三个人的又取决于第二个人的，第二个人的又取决于第一个人的，而且每一个员工都比前一个多一千，数学表达式即：

salary(4)=salary(3)+1000
salary(3)=salary(2)+1000
salary(2)=salary(1)+1000
salary(1)=5000
总结为：
salary(n)=salary(n-1)+1000 (n>1)
salary(1)=5000 (n=1)

很明显这是一个递归的过程，可以将该过程分为两个阶段：回溯和递推。

在回溯阶段，要求第n个员工的薪水，需要回溯得到(n-1)个员工的薪水，以此类推，直到得到第一个员工的薪水，此时，salary(1)已知，因而不必再向前回溯了。然后进入递推阶段：从第一个员工的薪水可以推算出第二个员工的薪水(6000)，从第二个员工的薪水可以推算出第三个员工的薪水(7000)，以此类推，一直推算出第第四个员工的薪水(8000)为止，递归结束。需要注意的一点是，递归一定要有一个结束条件，这里n=1就是结束条件。

代码实现：

def salary(n):
    if n==1:
        return 5000
    return salary(n-1)+1000
 
s=salary(4)
print(s)

执行结果：

8000

程序分析：

在未满足n1的条件时，一直进行递归调用，即一直回溯，见图4.3的左半部分。而在满足n1的条件时，终止递归调用，即结束回溯，从而进入递推阶段，依次推导直到得到最终的结果。

递归本质就是在做重复的事情，所以理论上递归可以解决的问题循环也都可以解决，只不过在某些情况下，使用递归会更容易实现，比如有一个嵌套多层的列表，要求打印出所有的元素，代码实现如下

items=[[1,2],3,[4,[5,[6,7]]]]
def foo(items):
    for i in items:
        if isinstance(i,list): #满足未遍历完items以及if判断成立的条件时，一直进行递归调用
            foo(i) 
        else:
            print(i,end=' ')
    
foo(items) #打印结果1 2 3 4 5 6 7

使用递归，我们只需要分析出要重复执行的代码逻辑，然后提取进入下一次递归调用的条件或者说递归结束的条件即可，代码实现起来简洁清晰

匿名函数

匿名函数就是没有函数名的函数

语法结构
	lambda 形参: 返回值
具体案例
	(lambda x: x + 1)(123)  直接调用
    res = lambda x: x + 1  命名调用
	 print(res(123))
应用场景
	匿名函数通常都需要配合其他函数一起使用 用于减少代码

匿名集合内置函数使用

max()  # 求最大值
l1 = [223, 3423, 123, 24, 34, 35, 435, 3, 24, 3534, 53, 24, 234, 132, 4234, 456, 456, 5345, 4, 234, 345, 23, 2123432]
res = max(l1)
print(res)  # 2123432

dic = {
    'jason': 100,
    'aj': 123,
    'Bason': 9999999,
    'zero': 888
}
def index(k):
    return dic.get(k)
# res = max(dic, key=lambda k: dic.get(k))
res = max(dic, key=index)
print(res)  # Bason

# print('A' > 'a')
"""
字符比较的是ASCII码
A-Z   65-90
a-z   97-122
"""

重要内置函数

min()  最小值
map()  映射

map()
l1 = [11, 22, 33, 44, 55, 66]
# 需求:将列表中所有的数据值自增20
# 方式1:for循环
# 方式2:列表生成式
# 方式3:map函数
res = map(lambda x: x + 20, l1)
print(res)  # <map object at 0x000001954B581100>
print(list(res))

def index(a):
    return a + 20
res = map(index, l1)
print(list(res))

filter()
l1 = ['jason', 'kevin', 'oscar', 'tony']
# 需求:移除数据值里面的jason
# 方式1:for循环
# 方式2:列表生成式
# 方式3:filter()
res = filter(lambda a: a != 'jason', l1)
print(res)  # <filter object at 0x00000195F21E6C70>
print(list(res))  # ['kevin', 'oscar', 'tony']

def index(a):
    return a != 'jason'
res = filter(index, l1)
print(list(res))

reduce()
l2 = [1, 2, 3]
# 需求:求列表中所有数据值的和
# 方式1:for循环
# 方式2:sum()
res = sum(l2)
print(res)
# 方式3:reduce()   将很多单体 变成一个整体
from functools import reduce
res = reduce(lambda x, y: x + y, l2, 100)
print(res)

zip()
n1 = [1, 2, 3]
n2 = ['jason', 'kevin', 'oscar']
res = zip(n1, n2)
print(res)  # <zip object at 0x000002A9E38C7F40>
print(list(res)) # [(1, 'jason'), (2, 'kevin'), (3, 'oscar')]

n1 = [1, 2, 3, 4]
n2 = [5, 6, 7, 8]
n3 = 'jack'
res = zip(n1, n2, n3)
print(list(res)) # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 'c'), (4, 8, 'k')]

n1 = [1, 2, 3, 4, 5, 6, 7]
n2 = [5, 6, 7, 8]
n3 = 'jason'
res = zip(n1, n2, n3)
print(list(res)) # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 's'), (4, 8, 'o')]