一、函数递归
1.什么是递归
函数在调用阶段直接或者间接的又调用了自身
（1）直接
def func(): print('from func') func() func()
死循环，无限调用函数
（2）间接
def index(): print('from index') login() def login(): print('from login') index() index()
也是死循环，无限调用这两个函数，不是在自身函数中直接调用，而是间接调用
2.递归深度
Python为了避免函数无限递归下去，设置了一个函数递归深度（重复执行上限），避免函数无限递归，导致计算机内存空间溢出（发生卡死，死机）。
（1）如何查看递归深度
import sys # 调用模块 print(sys.getrecursionlimit()) # 查看递归深度
递归深度（重复调用）默认是1000，不过不是很准确
def func(n): print('from func',n) func(n+1) func(1) # 精确一点的python中最大递归深度是998左右
精确一点的python中最大递归深度是998左右
（2）如何修改最大递归深度
import sys # 调用模块 sys.setrecursionlimit(2000) # 修改递归深度 def func(n): print('from func',n) func(n+1) func(1)
结论：函数不应该无限制的递归下去
3.递归用在什么地方
如果让函数无限制的递归下去没有任何意义，那递归应该用在什么场景？
举个例子：
询问A的年龄，A说比B小两岁，又问B，B说比C小两岁，再问C，C说比D小两岁......，直到E说他26岁，一个个推导得出A18岁
递归分为两个阶段：
（1）回溯：就是一次次重复询问的过程,这个重复的过程必须建立在每一次重复问题的复杂度都应该下降，直到有一个最终的结束条件（就是E说出26岁）
（2）递推：一次次往回推导的过程（推导出A18岁）
用代码演示这个例子：
''' age(A) = 18 age(B) = age(A) + 2 age(C) = age(B) + 2 age(D) = age(C) + 2 age(E) = age(D) + 2 age(1) = 18 age(2) = age(1)+2 age(n) = age(n-1)+2 # n>1 ''' def age(n): if n == 1: # 必须要有结束条件 return 18 # 返回18岁 else: return age(n-1) + 2 res = age(5) print(res)
如何做到：
将列表中的数字依次打印出来：l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,]]]]]]]]]]]]]
推导思路：
l = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,]]]]]]]]]]]]] for i in l: if type(i) is int: print(i) else: for item in i: if type(item) is int: print(item) else: for j in item: if type(item) is int: print(item) else: ... # 无限重复，前提还得知道有多少层列表
如果不知道多少层列表怎样做
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)
结论：递归函数不需要考虑循环的次数，只需要把握结束的条件即可
二、算法之二分法
1.什么是算法
解决问题的高效率的方法
2.如何实现：
找到num=345是不是在 l = [1,3,5,12,57,89,101,123,146,167,179,189,345]列表中
l = [1,3,5,12,57,89,101,123,146,167,179,189,345] num = 345 for i in l: if num == i: print('找到了')
如果这个列表有非常多数据，那查找效率就会变低，算法就是提高效率的方法，比如这里可以用二分法
3.二分法
先在列表中间找，然后判断出在哪一边，然后在那一边的中间再找，没找到就再重复上述操作，提高查找效率
l = [1,3,5,12,57,89,101,123,146,167,179,189,345] def get_num(l,target_num): print(l) # 把每次切取到的列表打印下 if not l: # 判断列表是否为空了，空了还没找到就说明不在列表中 print('你要找的值不在列表中') return middle_index = len(l) // 2 # 获取列表中间的索引 if target_num > l[middle_index]: # 判断target_num跟middle_index对应的数字的大小 num_right = l[middle_index + 1:] # 切取列表右半部分 get_num(num_right,target_num) # 再递归调用get_num函数，传入的列表变成切取的新列表 elif target_num < l[middle_index]: # 判断target_num跟middle_index对应的数字的大小 num_left = l[0:middle_index] # 切取列表左半部分 get_num(num_left, target_num) # 再递归调用get_num函数，传入的列表变成切取的新列表 else: # target_num = l[middle_index]的情况 print('找到了') get_num(l,345) get_num(l,666)
使用二分法有一个前提：
容器类型里面的数字必须有大小顺序，没有顺序可以使用 sort() 进行排序
三、三元表达式
1.比较大小的函数
def my_max(x,y): if x > y: return x else: return y print(my_max(1,5))
当x大的时候返回x，当y大的时候返回y，也就是当某个条件成立做一件事，不成立做另外一件事
2.如何用三元表达式表示这个函数
x = 1 y = 5 res = x if x > y else y # 如果if后面的条件成立返回if前面的值,否则返回else后面的值 print(res)
如果if后面的条件成立返回if前面的值，否则返回else后面的值
3.三元表达式的固定语法结构
值1 if 条件 else 值2
条件成立返回值1
条件不成立返回值2
4.三元表达式的应用场景
三元表达式只推荐只有两种情况的可能下
例如：
is_free = input('请输入是否免费(y/n)>>>:') is_free = '免费' if is_free == 'y' else '收费' print(is_free)
username = input('username>>>:') res = 'NB' if username == 'francis' else '垃圾' print(res)
四、列表生成式
1.如何实现：
使列表中的字符串后面加上字符 _NB：l = ['tank','nick','oscar','sean']
l = ['francis','jason','tank','egon'] l1 = [] for name in l: l1.append('%s_NB'%name) # l1.append(name + '_NB') # 等价于上面的办法，不推荐使用，python中这种字符串拼接效率太低 print(l1)
如何简单实现，需要用到列表生成式
2.列表生成式
l = ['francis','jason','tank','egon'] res = ['%s_NB'%name for name in l] # for循环依次拿出name交给for前面的，作为列表的一个个元素 print(res)
原理：for循环依次拿出name交给for前面的，作为列表的一个个元素
3.列表生成式还可以加上if判断
取出列表中以 _NB结尾的元素：l = ['francis_NB','jason_NB','tank_NB','egon']
l = ['francis_NB','jason_NB','tank_NB','egon'] res = [name for name in l if name.endswith('_NB')] # 后面不支持再加else的情况 # 先for循环依次取出列表里面的每一个元素 # 然后交由if判断,条件成立才会交给for前面的,作为列表的一个个元素 # 如果条件不成立,当前的元素，直接舍弃 print(res)
原理：先for循环依次取出列表里面的每一个元素，然后交由if判断，条件成立才会交给for前面的，作为列表的一个个元素，如果条件不成立，当前的元素，直接舍弃
五、字典生成式
1.如何实现：
把两个列表的数值一一对应，组成一新个字典：l1 = ['name','password','hobby']、l2 = ['francis','123','read']
l1 = ['name','password','hobby'] l2 = ['francis','123','read'] d = {} for k,v in enumerate(l1): # v是新字典的key，k是l2值对应的索引 d[v] = l2[k] print(d)
2.字典生成式
l = ['francis','123','read'] d = {i:j for i,j in enumerate(l) if j != '123'} # 还可以加上if判断，如果j不等于'123'就交个for前面的，否则舍弃 print(d)
3.集合生成式
s = {i for i in range(10) if i != 4}
print(s)
只要记住这个格式，外面加什么就生成什么（基本）
4.生成器表达式
t = (i for i in range(10) if i != 4) # 这样写不是元组生成式，而是生成器表达式 print(t) # 返回的是个老母猪 for i in t: print(i)
六、匿名函数
1.什么是匿名函数
没有名字的函数（也就意味着之后无法通过函数名加括号调用），所以是临时存在的函数，用的时候才存在，用过就没了
2.怎么用
lambda x,y:x+y # 求和的匿名函数 就等价于下面的有名函数 def my_sum(x,y): return x + y # 求和的有名函数
lambda x,y:x+y
（1）冒号(:)左边的相当于函数的形参
（2）冒号(:)右边的相当于函数的返回值
（3）匿名函数通常不会单独使用，而是配合内置函数一起使用
（4）也可以加括号使用，不过用完就没了
res = (lambda x,y:x+y)(1,2) # 加括号使用并传参数 print(res)
（5）也可以给匿名函数命名，命名知乎就变成有名函数了，但失去了匿名函数的意义
func = lambda x,y:x+y print(func(1,2)) # 函数加括号调用
七、常用的内置函数
1.max、min（最大值，最小值）
得出薪资最高的人的名字（比较薪资，返回人名）：
d = {'francis':30000, 'jason':20000, 'egon':15000, 'tank':10000}
（1）直接用max比较
d = {'francis':30000, 'jason':20000, 'egon':15000, 'tank':10000}
print(max(d)) # 比较的是字典的key的大小，得出tank，不对
比较的是字典的key的大小（字典暴露给用户的只有key）
（2）调用函数的办法
d = {'francis':30000, 'jason':20000, 'egon':15000, 'tank':10000}
def index(name):
return d[name]
print(max(d,key=index)) # max支持传一个函数，这样传入的key就被函数index变成了value，比较的就是value了
这样index函数只是为下面的比较大小服务的，就可以简化成匿名函数
d = {'francis':30000, 'jason':20000, 'egon':15000, 'tank':10000}
print(max(d,key=lambda name:d[name])) # 冒号左边是函数的形参，右边是返回值
得出薪资最低的人也是这样
d = {'francis':30000, 'jason':20000, 'egon':15000, 'tank':10000}
print(min(d,key=lambda name:d[name]))
2.map（映射）
把列表中的每个数字都加1：l = [1,2,3,4,5,6]
l = [1,2,3,4,5,6] res = map(lambda a:a+1,l) # map是基于for循环的,返回的是一个老母猪 print(list(res)) # list会循环老母猪里的数值组成列表
3.zip（拉链）
让列表中的值一一组合在一起：l1 = [1,2,3]、l2 = ['jason','egon','tank']、l3 = ['a','b','c']
l1 = [1,2,3,4] l2 = ['jason','egon','tank'] l3 = ['a','b','c'] print(list(zip(l1,l2,l3))) # 得出的是列表中包含一对对元组 # 如果某列表元素多于其他列表也不影响，只保留能对应上的部分
4.filter（过滤）
返回一个新列表，去除3：l = [1,2,3,4,5,6]
l = [1,2,3,4,5,6] res = filter(lambda x:x != 3,l) # filter是基于for循环的,返回的是一个老母猪 print(list(res)) # list会循环老母猪里的数值组成列表
5.sorted（排序）
给列表排序：l = [3,5,1,4,2,4]
l = [3,5,1,6,2,4] res = sorted(l) # 相当于sort，默认升序 print(res) res1 = sorted(l,reverse=True) # 也可以传参数，变为降序 print(res1)
6.reduce
类似于一个工厂，你给我多份材料，我只返回一个结果（给我一个列表，只返回一个值）
把列表中的值相加：l = [1,2,3,4,5,6]
（1）没有初始值的时候
l = [1,2,3,4,5,6] from functools import reduce # reduce不可以直接用，需要先导入一个模块 print(reduce(lambda x,y:x+y,l)) # 没有初始值 # 没有初始值的时候，第一次获取两个值然后相加，之后每次获取一个值与上一次相加的结果再相加
（2）有初始值的时候
l = [1,2,3,4,5,6] from functools import reduce # reduce不可以直接用，需要先导入一个模块 print(reduce(lambda x,y:x+y,l,10)) # 初始值为10，初始值就是第一个参数 # 有初始值的时候，第一次获取一个值然后相加，之后每次获取一个值与上一次相加的结果再相加