递归函数、二分法、三元表达式、列表生成式、字典生成式、匿名函数、常用的内置函数

一、递归函数

1、定义

　　函数在调用阶段直接或间接的又调用自身

2、递归分为两个阶段

　　①、回溯：就是一次次重复的过程，这个重复的过程必须建立在每一次重复后问题的复杂度都应该下降

　　②、递推：一次次往回推导的过程

3、函数不应该无限制的递归下去，必须要有结束条件，否则会造成内存溢出，而Python解释器不允许这种情况的出现，所以它设置了一个最大递归深度，当递归层数达到最大递归深度时，Python解释器会终止递归，并报错。

import sys  # 导入sys模块
print(sys.getrecursionlimit())  # 获取递归深度，不是很精确，实测大概为998
sys.setrecursionlimit(2000)  # 设置递归深度

4、两个例子

　　①、

"""
age(5) = age(4) + 2
age(4) = age(3) + 2
age(3) = age(2) + 2
age(2) = age(1) + 2
age(1) = 18

age(n) = age(n-1) + 2  # n > 1
age(1) = 18  # n = 1 终止条件
"""


def age(n):
    if n == 1:
        return 18
    return age(n-1)+2


res = age(5)
print(res)

　　②、

l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,]]]]]]]]]]]]]
# 将列表中的数字依次打印出来(循环的层数是你必须要考虑的点)
def get_num(l):
    for i in l:
        if type(i) is int:
            print(i)
        else:
            get_num(i)

get_num(l)

5、补充（两种顶替方式）

# 第一种方式，推荐使用
def index():
    pass
# 第二种方式
def index1():
    ...

二、算法之二分法

1、算法的定义

　　解决问题的高效率的方法

2、二分法查找数据

　　二分法用于查找数据时，需要将给定的数据事先排好顺序（假设由小到大排序）并放在一个列表中，然后找出中间值，将中间值与要查找的值比较，如果相等则找到，如果比要查找的值大，则说明要查找的值在列表的左边，就取左边，如果比要查找的值小，则说明要查找的值在列表的右边，就取右边。然后重复操作，直到找到该数值。

3、实例

l = [1, 3, 5, 12, 57, 89, 101, 123, 146, 167, 179, 189, 345]
target_num = 59


def get_num(l, target_num):
    if not l:
        print('你给的工资 这个任务怕是没法做')
        return
    print(l)
    middle_index = len(l) // 2
    if target_num > l[middle_index]:
        num_right = l[middle_index + 1:]
        get_num(num_right, target_num)
    elif target_num < l[middle_index]:
        num_left = l[0:middle_index]
        get_num(num_left, target_num)
    else:
        print('find it', target_num)


get_num(l, target_num)
# 输出
# [1, 3, 5, 12, 57, 89, 101, 123, 146, 167, 179, 189, 345]
# [1, 3, 5, 12, 57, 89]
# [57, 89]
# [57]
# 你给的工资 这个任务怕是没法做

三、三元表达式

1、形式

　　值1 if 条件 else 值2

　　条件成立 返回值1

　　条件不成立 返回值2

2、三元表达式的应用场景：推荐用在只有两种情况的可能下

3、例子

x = 99999
y = 9898898
res = x if x > y else y
print(res)

四、列表生成式、字典生成式

 1、形式

　　列表生成式：[放入列表的元素（可以对这个元素进行一些操作，比如字符串的拼接或者数学运算） for循环一个容器类型，取出里面的元素 if 条件（这个条件可加可不加，加的话条件成立才取出该元素，不成立直接丢掉）]

　　字典生成式：与列表生成式类似，不同的是用大括号括起来

2、例子

# 列表生成式
l = [1, 2, 3, 4, 5, 6, 7]
res = [num+1 for num in l if num != 3]


l = ['tank','nick','oscar','sean','jason']
res = ['%s_sb'%name for name in l if name != 'jason']

# 字典生成式
l = ['jason','tank','nick']
d = {'%s_sb'%name:num+1 for num,name in enumerate(l) if name != 'jason'}

 五、匿名函数

1、匿名函数就是没有名字的函数，它的特点是：临时存在，用完就没了

2、定义方式：lambda 要传入的参数：对这些参数进行的操作，冒号的左边相当于函数的形参，冒号的右边相当于函数的返回值

res = (lambda x,y:x+y)(1,2)
print(res)
func = lambda x,y:x+y
print(func(1,2))

3、匿名函数通常不会单独使用，是配合内置函数一起使用

六、常用的内置函数

1、max()，括号内可以放入多个值或一个容器类型，它的内部是基于for循环的，依次取出各个元素进行比较，返回最大值，如果这些值都是字符串，那么就是比较这些字符串的首字母在ASCII码表中对应的数字，A-Z对应65-90，a-z对应97-122。同时max()还可以传入第二个参数，一般情况下传入的是匿名函数。传入匿名函数后，max会比较匿名函数的返回值，并返回与之对应的第一个参数。

# 比较薪资，返回人名
d = {
    'egon': 30000,
    'jason': 88888,
    'nick': 3000,
    'tank': 1000
}

print(max(d, key=lambda name: d[name]))

2、map()函数，映射函数：可以传入两个参数，第一个是匿名函数，第二个是一个容器类型，map()基于for循环将容器类型内的参数依次取出交给匿名函数，处理完后交给map函数，它的返回值是一个老母猪，可以利用for循环将里面的值取出来。

# map 映射
l = [1,2,3,4,5,6]
print(map(lambda x:x+5,l))  # 基于for循环
# <map object at 0x01541250>

3、zip()函数，拉链函数：可以将任意多的容器类型里面的值按照索引组合在一起，将相同索引的元素放在同一个元组中，元组的个数由长度最小的容器类型的长度决定，容器类型的长度不一致也不会报错。

l1 = [1,2,3,4]
l2 = ['jason','egon','nick','tank']
res = zip(l1,l2)
res1 = list(res)
print(res)
print(res1)
# 输出
# <zip object at 0x02B066C0>
# [(1, 'jason'), (2, 'egon'), (3, 'nick'), (4, 'tank')]

4、filter()函数，过滤函数：用法与map()函数类似

l = [1, 2, 3, 4, 5, 6]
print(list(filter(lambda x: x != 3, l)))  # 基于for循环

5、sorted()函数，排序函数，默认从小到大排序，指定reverse = True时从大到小排序

l = ['jason','egon','nick','tank']
print(sorted(l,reverse=True))
# ['tank', 'nick', 'jason', 'egon']

6、reduce()函数，需要导入reduce模块

from functools import reduce

l = [1, 2, 3, 4, 5, 6]
print(reduce(lambda x, y: x + y, l))  # 21
print(reduce(lambda x, y: x + y, l, 19))  # 40

　　当初始值不存在的情况下，第一次先获取两个元素相加，之后每次获取一个与上一次相加的结果相加

　　当初始值存在的情况下，第一次取出一个值与初始值相加，之后每一次获取一个值与上一次相加的结果相加。