内置函数二、递归、二分法
一、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("你好")) # 真实的字符串表示形式(正式的)
