内置函数二. 递归 二分法
一、lambda匿名函数
为了解决一些简单的需求而设计的一句话函数，如下示例：
# 以前的写法
def func(n):
return n ** n
print(func(10))
# lambda函数
f = lambda n : n ** n
print(f(10))
print(f.__name__) # 结果为：<lambda>
# __name__可以查看函数的名字，匿名函数__name__的值都是<lambda>
lambda表示的是匿名函数，不需要用def来声明，一句话就可以声明出一个函数，语法如下：
函数名 = lambda 参数 ： 返回值
注意：
1，函数的参数可以有多个，多个参数之间用逗号隔开；
2，匿名函数不管多复杂，只能写一行，且逻辑结束后直接返回数据；
3，返回值和正常的函数一样，可以是任意数据类型；
再注意：匿名函数有两个返回值时，返回值用()括起来，如下示例：
suiyi = lambda x, y : (x+1, y+2)
print(suiyi(2,3)) # 结果为：(3, 5)
匿名函数并不是说一定没有名字，上面的例子中匿名函数前面变量就是一个函数名，说它匿名是因为我们通过__name__查看的时候是没有名字的，统一都叫lambda，在调用的时候没有什么特别之处，像正常的函数调用即可。
二、sorted()
前边我们学了一个排序函数sort()，这是列表的专用排序函数，详见“python数据类型二（列表和元组）”，python的内置函数中为我们提供了一个通用的排序方案：sorted()。
排序函数sorted()，语法：sorted(Iterable, key=None, reverse=False)
Iterable：可迭代对象；
key：排序规则（排序函数），在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数，根据函数的运算的结果进行排序；
reverse：是否是倒序，True：倒序，False：正序(默认)
lst = [1,5,3,4,6]
lst2 = sorted(lst)
print(lst) # [1, 5, 3, 4, 6]，元列表不会改变
print(lst2) # [1, 3, 4, 5, 6]，返回新列表是经过排序的
dic = {1:'a', 3:'c', 2:'b'}
print(sorted(dic)) # 结果为：[1, 2, 3]
# 如果是字典，则返回排序过后的key
和普通函数组合使用，示例如下：
# 根据字符串长度进行排序
lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
# 计算字符串长度
def func(s):
return len(s)
print(sorted(lst, key=func))
# 结果为：['狐仙', '麻花藤', '冈本次郎', '中央情报局']
和lambda匿名函数组合使用，示例如下：
# 根据字符串长度进行排序
print(sorted(lst, key=lambda s : len(s)))
# 结果也为：['狐仙', '麻花藤', '冈本次郎', '中央情报局']
# 有如下列表，按照年龄对学生信息进行排序
lst = [
{'id':1, 'name':'alex', 'age':18},
{'id':2, 'name':'wusir', 'age':17},
{'id':3, 'name':'taibai', 'age':19}
]
print(sorted(lst, key=lambda el : el['age']))
三、filter()
筛选函数：语法：filter(function, Iterable)
function：用来筛选的函数，在filter中会自动的把iterable中的元素传递给function，然后根据function返回的True或者False来判断是否保留此项数据，返回True的保留，返回False的被过滤掉；
Iterable：可迭代对象
lst = [1,2,3,4,5,6,7]
ll = filter(lambda x : x % 2 == 0, lst) # 筛选所有的偶数
print(ll) # 结果为：<filter object at 0x0000000002974198>
print(list(ll)) # 结果为：[2, 4, 6]
lst = [
{'id': 1, 'name': 'alex', 'age': 18},
{'id': 2, 'name': 'wusir', 'age': 17},
{'id': 3, 'name': 'taibai', 'age': 19}
]
f1 = filter(lambda e : e['age'] > 17, lst) # 筛选年龄大于17的数据
print(list(f1))
四、map()
映射函数：语法：map(function, iterable)对可迭代对象中的每一个元素进行映射，分别去执行function。
# 计算列表中的每个元素的平方，返回新列表，如下示例：
def func(e):
return e*e
mp = map(func, [1,2,3,4,5])
print(list(mp)) # 结果为：[1, 4, 9, 16, 25]
# 改写成lambda匿名函数
print(list(map(lambda e : e*e, [1,2,3,4,5])))
# 计算两个列表中相同位置的数据的和(遵循水桶效应，即长度取决于最短的列表长度)
lst1 = [1,2,3,4,5]
lst2 = [2,4,6,8,10]
print(list(map(lambda x, y : x+y , lst1, lst2))) # [3, 6, 9, 12, 15]
注意：map()函数的代码很简单，但是思想很重要，分而治之的思想，map(func1, map(func2, map(func3 , lst)))。
五、递归
在函数中调用函数本身，就是递归。如下示例：
def func():
print("我是谁")
func()
func()
递归深度就是函数自己调用自己的次数，官方文档中递归最大深度是1000. 但是在这之前就会报错，所以到不了1000。下面示例可以显示递归的深度：
def foo(n):
print(n)
n += 1
foo(n)
foo(1)
递归的应用：
我们可以使用递归来遍历各种树形结构，比如我们的文件夹系统，可以使用递归来遍历该文件夹中的所有文件夹，示例如下：
import os
def read(filepath, n):
files = os.listdir(filepath) # 获取到当前文件夹中的所有文件
for fi in files: # 遍历文件夹中的文件，这里获取的只是本层文件名
fi_d = os.path.join(filepath, fi)
if os.path.isdir(fi_d): # 如果该路径下的文件是文件夹
print("\t"*n, fi)
read(fi_d, n+1) # 继续进行相同的操作
else:
print("\t"*n, fi) # 递归出口，最终在这里隐含着return
# 递归遍历目录下所有文件
read('e:/pythonDemo', 0)
六、二分法查找（核心：掐头去尾取中间，一次砍一半）
二分法查找：每次能够排除掉一半的数据，查找的效率非常高，但是局限性比较大，必须是有序序列才可以使用二分法查找。前提条件：查找的序列必须是有序序列。
# 判断n是否在lst中出现，如果出现请返回n所在的位置
# 方法一：二分法--常规循环，非递归算法
lst = [22,33,44,55,66,77,88,99,101,238,345,456,567,678,789]
n = 567
left = 0
right = len(lst) - 1
count = 1
while left <= right:
mid = (left + right) // 2
if n < lst[mid]:
right = mid - 1
elif n > lst[mid]:
left = mid + 1
else:
print(f"查找了{count}次")
print(f"索引是{mid}")
break
count += 1
else:
print("不存在")
# 方法二：递归二分法
def search(n, left, right):
if left <= right:
mid = (left+right)//2
if n < lst[mid]:
right = mid - 1
elif n > lst[mid]:
left = mid + 1
else:
return mid
return search(n, left, right)
# 这个return必须要加，否则接收到的永远是None。
else:
return -1
print(f"索引是{search(567, 0, len(lst)-1)}")
# 方法三：另类二分法，弊端是无法获取查找元素的位置，只能判断是否存在
def search2(lst, target):
left = 0
right = len(lst) - 1
if left > right:
print("不存在")
mid = (left+right)//2
if target < lst[mid]:
return search2(lst[:mid],target)
elif target > lst[mid]:
return search2(lst[mid+1:],target)
else:
print("存在")
search2(lst, 567)
二分法拓展：
# 查找的时间复杂度最低, 空间复杂度最低
lst1 = [5,6,7,8]
lst2 = [0,0,0,0,0,0,0,0,0] # lst1的最大数字是n就设置n+1个元素的lst2
for el in lst1:
lst2[el] = 1 # 将lst2中的下标分别为lst1中元素的元素设置为1
# lst2 = [0,0,0,0,0,1,1,1,1]
if lst2[6] == 1: # o(1)，查找一次即可知道是否存在
print("存在")
else:
print("不存在")
补充：上篇遗留问题（repr()函数）
repr()的官方文档写的是：Return the canonical string representation of the object，翻译为：返回对象的规范字符串表示形式。
print("你好. 我\\叫周润发") # 对用户是友好的. 非正式的字符串，结果为：你好. 我\叫周润发
# 正式(官方)的字符串, 面向对象的时候能用到
print(repr("你好, 我\"叫周润发")) # 程序中内部存储的内容, 这个是给程序员看的
# 结果为：'你好, 我"叫周润发'
print("我叫%r" % "周润发") # %r 实际上调用的是repr() 结果为：我叫'周润发'
# 原样输出
print(r"马化腾说:\"哈哈哈, \" \n\t")
print("你好") # 用户看着舒服
print(repr("你好")) # 真实的字符串表示形式(正式的)
