一、匿名函数
匿名函数主要是为了解决一些简单需求而设计的一种函数，匿名函数的语法为：
lambda 形参： 返回值
先来看一个例子：
# 计算n的n次方
In[2]: lst = lambda n: n ** n # 这里的lst就是一个匿名函数
In[3]: print(lst(3))
27
使用匿名函数需要注意的几点：
- 函数的参数可以有多个，多个参数之间⽤逗号隔开
- 匿名函数不管多复杂. 只能写⼀⾏, 且逻辑结束后直接返回数据
- 返回值和正常的函数⼀样, 可以是任意数据类型
二、内置函数补充
sorted
sorted是python内置的一个用于排序的函数，它接收三个参数，语法为；
sorted(Iterable， key=None， reverse=False)
- Iterable： 接收一个可迭代对象，sorted内部会去循环可迭代对象取出元素
- key： 排序规则（排序函数），sorted将每次从可迭代对象中取出的数据会传递给这个排序函数的参数，根据函数运算的结果进行排序
- reverse： 控住是否倒叙，True为倒叙，默认为False正序
# 根据字符串⻓度进⾏排序
In[7]: lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
In[8]: lst2 = sorted(lst, key=lambda s: len(s))
In[9]: print(lst2)
['狐仙', '麻花藤', '冈本次郎', '中央情报局']
sorted如果不传作排序用的函数，那么它默认是按照在字符编码中的顺序来排的：
In[10]: lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
In[11]: lst2 = sorted(lst)
In[12]: lst2
Out[12]: ['中央情报局', '冈本次郎', '狐仙', '麻花藤']
In[14]: print(ord('中'))
20013
In[15]: print(ord('冈'))
20872
In[16]: print(ord('狐'))
29392
In[17]: print(ord('麻'))
40635
filter
filter是python中内置的一个过滤的函数，其用法跟sorted差不多：
filter(function, iterable)
- function： ⽤来筛选的函数. 在filter中会⾃动的把iterable中的元素传递给function. 然后
根据function返回的True或者False来判断是否保留此项数据 - iterable： 可迭代对象
In[21]: lst = [{'id':1,'name':'alex','age':28},
...: {'id':2,'name':'taibai','age':58},
...: {'id':3,'name':'taihei','age':18},
...: {'id':4,'name':'henhei','age':38}]
In[22]: ret2 = filter(lambda x: x['age'] >= 38, lst)
...: [print(x) for x in ret2]
{'id': 2, 'name': 'taibai', 'age': 58} # 从结果来看，年龄小于38的都被过滤掉了
{'id': 4, 'name': 'henhei', 'age': 38}
Out[22]: [None, None]
map
映射函数map，使用语法为：
map(function, iterable)
可以对可迭代对象中的每⼀个元素进⾏映射. 分别取执⾏function（其语法和sorted、filter相似）
In[23]: names=['oldboy','alex','wusir']
In[24]: m = map(lambda s: s + '123', names) # 在每个字符串后加上123
In[25]: print(list(m)) # map返回的也是一个可迭代对象，使用list会去循环遍历元素
['oldboy123', 'alex123', 'wusir123']
三、递归
在函数中调⽤函数本⾝. 就是递归
def func():
print("我是谁")
func()
func()
在python中最大递归深度为1000：
In[26]: import sys
In[27]: sys.getrecursionlimit() # 虽然我们查询到的结果是1000，但是实际上却跑不到1000，通常是998或者997
Out[27]: 1000
递归的应用：计算斐波那契数列 f(0) = 1 f(1) = 1 f(n) = f(n-1) + f(n-2)
In[35]: def fib(n):
...: if n == 0:
...: return 1
...: if n == 1:
...: return 1
...: return fib(n-1) + fib(n-2)
...:
In[36]: fib(5)
Out[36]: 8
In[37]: fib(10)
Out[37]: 89
总结：
- 递归函数总是涉及到压栈和出栈的过程
- 递归函数总是压栈，知道遇到退出条件，然后出栈
- Python中递归函数有深度限制，可以通过
sys.getrecursionlimit()得到深度限制，可以通过sys.setrecursionlimit调整递归深度限制 - 递归函数在Python非常慢，并且有深度限制，所以 因尽量避免使用递归
四、二分法查找
⼆分查找. 每次能够排除掉⼀半的数据. 查找的效率非常⾼. 但是局限性比较⼤. 必须是有
序序列才可以使⽤⼆分查找
- 要求: 查找的序列必须是有序序列
(1) 使用基本的算法实现：
lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
n = int(input("请输入一个数字n:")) # 56
left = 0 # 左边界
right = len(lst) - 1 # 末尾的索引 右边界
while left <= right: # 当左边界大于右边界结束循环
mid = (left + right) // 2 # 求中间的索引坐标
if n < lst[mid]: # 判断你的数字和中间数的大小比较 .
right = mid - 1 # 右边界往左移动
elif n > lst[mid]:
left = mid + 1 # 左边界往右移动
else:
print("找到了") # 找到了目标数字
break
else: # 当左比右大, 循环结束. 没有找到目标数
print("没找到")
（2）使用递归实现：
lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
def binary_search(lst, n, left, right):
if left > right:
return False
mid = (left + right) // 2
if n > lst[mid]:
left = mid + 1
# 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值
return binary_search(lst, n, left, right)
elif n < lst[mid]:
right = mid - 1
return binary_search(lst, n, left, right)
else:
print("找到了")
return True
n = int(input("请输入一个数字n:")) # 178
ret = binary_search(lst, n, 0, len(lst)-1)
print(ret)
# 结果：
# 请输入一个数字n:178
# 找到了
# True
切记：当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值
（3）对列表切片：
def binary_search(lst, n):
if len(lst) == 0:
return False
left = 0
right = len(lst) - 1
mid = (left + right) // 2
if n > lst[mid]:
left = mid + 1
# 当递归有返回值的时候. 需要写return. 否则有可能接收不到返回值
return binary_search(lst[mid+1:], n)
elif n < lst[mid]:
right = mid - 1
return binary_search(lst[:mid], n)
else:
print("找到了")
return True