内置函数二

一. lamda匿名函数

1 # 计算n的n次方 
2 def func(n):
3     return n**n 
4 print(func(10))
5 
6 
7 f = lambda n: n**n 
8 print(f(10))

　　语法:

　　　　函数名 = lambda 参数: 返回值

　　注意: 1. 函数的参数可以有多个. 多个参数之间用逗号隔开

　　　　 2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据

　　　　 3. 返回值和正常的函数一样, 可以是任意数据类型

匿名函数并不是说一定没有名字. 这里前面的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的. 统一都叫lambda. 在调用的时候没有什么特别之处. 像正常的函数调用即可.

二. sorted()

　　排序函数.

语法: sorted(Iterable, key=None, reverse=False)

Iterable: 可迭代对象

key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序

　　key: 排序方案, sorted函数内部会把可迭代对象中的每一个元素拿出来交给后面的key,后面的key计算出一个数字. 作为当前这个元素的权重, 整个函数根据权重进行排序

　　 reverse: 是否是倒叙. True: 倒叙, False: 正序　　

1 lst = [1,5,3,4,6] 
2 lst2 = sorted(lst) 
3 print(lst)  # 原列表不会改变 
4 print(lst2) # 返回的新列表是经过排序的 
5 
6 dic = {1:'A', 3:'C', 2:'B'} 
7 print(sorted(dic))  # 如果是字典. 则返回排序过后的key

和函数组合使⽤

1 # 根据字符串长度进行排序
2  lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"] 
3 # 计算字符串长度 
4 def func(s):
5     return len(s) 
6 print(sorted(lst, key=func))

和lambda组合使⽤

 1 # 根据字符串长度进行排序 
 2 lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"] 
 3 # 计算字符串长度 
 4 def func(s):
 5     return len(s) 
 6 print(sorted(lst, key=lambda s: len(s)))
 7 lst = [{"id":1, "name":'alex', "age":18},
 8        {"id":2, "name":'wusir', "age":16},
 9        {"id":3, "name":'taibai', "age":17}] 
10 # 按照年龄对学生信息进行排序 
11 print(sorted(lst, key=lambda e: e['age']))

三. ﬁlter()

　　筛选函数

语法: ﬁlter(function. Iterable)

function: 用来筛选的函数. 在ﬁlter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留此项数据

Iterable: 可迭代对象

1 lst = [1,2,3,4,5,6,7]
2 ll = filter(lambda x: x%2==0, lst)    # 筛选所有的偶数 
3 print(ll)
4 print(list(ll)) 
5 lst = [{"id":1, "name":'alex', "age":18},
6        {"id":2, "name":'wusir', "age":16},
7        {"id":3, "name":'taibai', "age":17}] 
8 fl = filter(lambda e: e['age'] > 16, lst)   # 筛选年年龄⼤大于16的数据 
9 print(list(fl))

四. map()

映射函数

语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射. 分别取执行 function

计算列表中每个元素的平方 ,返回新列表

1 def func(e):
2     return e*e 
3 mp = map(func, [1, 2, 3, 4, 5]) 
4 print(mp) 
5 print(list(mp))

改写成lambda

print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))

计算两个列表中相同位置的数据的和

1 # 计算两个列列表相同位置的数据的和
2 lst1 = [1, 2, 3, 4, 5] 
3 lst2 = [2, 4, 6, 8, 10] 
4 print(list(map(lambda x, y: x+y, lst1, lst2))) 
　　　　水桶效应, zip()

五. 递归

在函数中调用函数本身. 就是递归在python中递归的深度最大到998

1 def foo(n):
2     print(n)
3     n += 1
4     foo(n) 
5 foo(1)

递归的应用:

我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统. 可以使用递归来遍历该文件夹中的所有⽂件

 1 遍历 D:/sylar文件夹, 打印出所有的文件和普通文件的文件名
 2 import   os
 3 def   func(filepath, n):     # d:/sylar/
 4     #1.打开这个文件夹
 5     files = os.listdir(filepath)
 6     #2.拿到每一个文件名
 7     for file in files:    #文件名
 8         #3.获取到路经
 9         f_d = os.path.join(filepath,file)     #  d:/sylar/文件名
10         #4.判断是否是文件夹
11         if os.path.isdir(f_d):
12             #5.如果是文件夹,继续再来一遍
13             print("	"*n,file,":")  #打印文件名
14             func(f_d,n+1)
15         else:         #  不是文件夹,普通文件
16             print("	"*n,file)
17 func("d:/sylar",0)

六. 二分查找

二分查找. 每次能够排除掉一半的数据. 查找的效率非常⾼高. 但是局限性比较大. 必须是有序列列才可以使用二分查找

要求: 查找的序列必须是有序列.

　　核心: 掐头去尾取中间. 一次砍一半
　　两种算法: 常规循环, 递归循环

 1  使用二分法可以提高效率, 前提条件:有序序列
 2 lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789]
 3 
 4  n = 88
 5  left = 0
 6 pright = len(lst)-1
 7 while left <= right: # 边界, 当右边比左边还小的时候退出循环
 8      mid = (left + right)//2 # 必须是整除. 因为索引没有小数
 9      if lst[mid] > n:
10         right = mid - 1
11      if lst[mid] < n:
12          left = mid + 1
13      if lst[mid] == n:
14          print("找到了这个数")
15          break
16 else:
17      print("没有这个数")
18 
19 
20 # 递归来完成二分法
21 lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789]
22 def func(n, left, right):
23     if left <= right: # 边界
24         print("哈哈")
25         mid = (left + right)//2
26         if n > lst[mid]:
27             left = mid + 1
28             return func(n, left, right) # 递归  递归的入口
29         elif n < lst[mid]:
30             right = mid - 1
31             # 深坑. 函数的返回值返回给调用者
32             return func(n, left, right)    # 递归
33         elif n == lst[mid]:
34             print("找到了")
35             return mid
36             # return  # 通过return返回. 终止递归
37     else:
38         print("没有这个数") # 递归的出口
39         return -1 # 1, 索引+ 2, 什么都不返回, None
40 # 找66, 左边界:0,  右边界是:len(lst) - 1
41 ret = func(70, 0, len(lst) - 1)
42 print(ret) # 不是None

 1 # 另类二分法, 很难计算位置. 
 2 def binary_search(ls, target):
 3     left = 0
 4     right = len(ls) - 1
 5     if left > right:
 6         print("不在这里")
 7     middle = (left + right) // 2
 8     if target < ls[middle]:
 9         return binary_search(ls[:middle], target)
10     elif target > ls[middle]:
11         return binary_search(ls[middle+1:], target)
12     else:
13         print("在这里") 
14 binary_search(lst, 567)

# 时间复杂度最低, 空间复杂度最低
        lst1 = [5,6,7,8]
        lst2 = [0,0,0,0,1,1,1,1]
        for el in lst1:
            lst2[el] = 1

        lst2[4] == 1   # o(1)