一.lambda匿名函数
定义:为了解决一些简单的需求而设计的一句话函数
例子:计算n的n次方
1 def func(n):#正常的写法
2 return n**2
3 print(func(10)) #100
4
5 f=lambda n:n**2
6 print(f(10)) #100
这里的lambda小时的是匿名函数,不需要用def来声明,一句话就可以声明出一个函数
语法:
函数名=lambda 参数:返回值
注意:
1.函数的参数可以有多个,多个参数之间用逗号隔开,多个返回值也需要用逗号隔开,并且需要用小括号括起来
2.匿名函数不管多复杂,只能写一行
3.返回值和正常函数一样,可以是任意数据类型
匿名函数并不是说一定没有名字,这里前面的变量就可以看做函数名,说他匿名的原因是我们通过__name__查看的时候统一都叫lambda
__name__的使用方法:__name__在这里用的看起来没有多大的作用,实际上在一个大的文件中,函数可能被多次调用传递,这时只能通过__name__来查看
1 def func(n):
2 return n**2
3 print(func(10)) #100
4 print(func.__name__)
5
6 f=lambda n:n**2
7 print(f(10))
8 print(f.__name__) #<lambda>
匿名函数也可以用*args()和**args():
1 f=lambda *args:max(args)
2 print(f(1,2,3,4,55,9,2,1)) #55
二.sorted() 排序函数,内置函数提供的一个供可迭代对象排序的通用的方案
语法:sorted(iterable,key==none,reverse=false)
key:排序规则,在sorted的内部,会将可跌倒对象的每一个元素传递给这个函数的形参,根据函数运算的结果进行排序
reverse:是否倒叙,默认是False,不是倒叙即正序,true是正序
1 lst2=sorted(lis) #原列表不会改变,返回的是一个新列表
2 print(lst2) #[1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 8, 55]
★★★★★★★★★★★★★★★★★★★★★★内置函数一般不会改变原对象,会产生并返回一个新的对象
对字典排序
1 dic={1:'啊',2:'想',3:'睡觉',4:'不能睡'}
2 dic1=sorted(dic)
3 print(dic1) #[1, 2, 3, 4] 返回的是排序后的 key
根据字符串的长度排序
1 lis=['杀鸡取卵','杀鸡给猴看','杀人如麻,咦,吓人','杀气腾腾,阔怕']
2 print(sorted(lis,key=lambda el:len(el)))
1 dic=[
2 {'name':'汪峰','age':20},
3 {'name':'章子怡','age':18},
4 {'name':'美丽','age':13}
5 ]
6 dic1=sorted(dic,key=lambda el:el['age'],reverse=True)
7 print(dic1) #[{'name': '汪峰', 'age': 20}, {'name': '章子怡', 'age': 18}, {'name': '美丽', 'age': 13}]
三.filter()筛选函数
语法:filter(function,iterable)
function:用来筛选的函数,在filter中自动的会吧iterable中的每一个元素传给function,然后根据function返回的true或False来判断是否保留此项数据
iterable:可迭代对象
1 lis=[1,2,3,4,5,5,66,98,55,15,20]
2 lis1=filter(lambda el:el%2==0,lis) #符合函数的内容就是true,留下,不符合函数的内容就是False,筛掉
3 print(lis1) #<filter object at 0x000002B514A08860> #返回的是内存地址
4 print(list(lis1)) #[2, 4, 66, 98, 20]
5
6 lis=['周冬雨','李易峰','周杰伦','李连杰','李小龙']
7 ll=filter(lambda el :el[0]=='周',lis)
8 print(list(ll)) #['周冬雨', '周杰伦']
9
10 dic=[
11 {'name':'汪峰','age':20},
12 {'name':'章子怡','age':18},
13 {'name':'美丽','age':13}
14 ]
15 baobao=filter(lambda el:el['age']<15,dic)
16 print(list(baobao)) #[{'name': '美丽', 'age': 13}]
四.map():映射函数
语法:map(function,iterable) 将列表中的每一个元素都践行function操作,返回得到的列表的地址
1 def func(e):
2 return e*e
3 mp=map(func,[1,2,3,4])
4 print(list(mp)) #[1, 4, 9, 16]
5
6 lis=[1,2,3,4,5,6]
7 mp=map(lambda el :el**2,lis)
8 print(list(mp)) #[1, 4, 9, 16, 25, 36]
9
10 计算两个列表中相同位置的数据的和
11 lis=[1,2,3,4,5,6]
12 # lis2=[6,5,4,3,2,1]
13 # mp=map(lambda el1, el2 :el1+el2 ,lis,lis2)
14 # print(list(mp)) #[7, 7, 7, 7, 7, 7]
15
16 map()也存在水桶效应
17 lis=[1,2,3]
18 lis2=[6,5,4,3,2,1]
19 mp=map(lambda el1, el2 :el1+el2 ,lis,lis2)
20 print(list(mp)) #[7, 7, 7]
分而治之:一个人处理一个量特别大的数据太慢,而且耗内存,所以假设这个人找了五个人来完成,
但是五个人的工作量依旧很大,所以这五个人每个人又找了十个人......一次下去直达工作量合适
lis=[1,2,4,5,5,8,6,6,5,5,5,6,6,5,55,5,9,5,5,44,4,8,56,98,5654,654565,65,65,56,5,6,5,456,48,9,89,8,98,56]
mp = map ( func1 , map ( func2 , map ( func3 , lis ) ) )
func3的目的是将这个这个大工作量的list切片成五份
func2的目的是将这五份中的每一份又切片成十份
func3的目的是将一共的50份每份都做映射处理,得到想要的结果
print(list(mp))
五.递归:在函数中调用函数本身就是递归
1 i=1
2 def func(i):
3 print(i)
4 print('我是专业的!')
5 i+=1
6 func(i)
7 func(i)
8 我是专业的!
9 995
10 我是专业的!
11 996
12 我是专业的!
13 997
14 我是专业的!
15 998 #在python中递归的最大深度到998,官方的最大深度是1000,但是在这之前会报错
递归的作用:可以使用递归来便利各种树形结构,比如文件夹系统,可以使用递归便利一个文件夹中的所有文件
1 import os #引入os模块
2 def func(filepath,n): #failpath是要打开的文件的路径 n用来控制文件或文件夹前有几个tab键,以形成层次
3 files=os.listdir(filepath) #os模块中的方法,获取当前文件夹中的所有文件名
4 for fi in files: #将所有的文件名遍历
5 fi_d=os.path.join(filepath,fi) #引用os模块中的方法,将e:/python和文件名连在一起,组成一个新的路径
6 if os.path.isdir(fi_d): #判断该路径下的文件是不是文件夹
7 print(' '*n+fi+':') #前面加指定个数的tab键,文件名,冒号
8 func(fi_d,n+1) #继续调用func函数
9 else:
10 print(' '*n+fi) #直接打印文件名
11 func('e:/python',0)
六.二分法查找:
二分法查找,每次能够 排除掉一半的数据,查找的效率非常高,但是有一定的局限性,必须是有序序列才可以使用二分法查找
判断n是否在lst中,如果存在返回n所在位置的索引
普通版本二分法
1 lst=[11,22,33,44,55,66,77,88,99,123,145,156,178,189,215,246,287,298,568,687,789,890,960]
2 n=246
3 left=0
4 right=len(lst)-1
5 middle=(left+right)//2
6 while left<=right:
7 if n<lst[middle]:
8 right=middle-1
9 middle = (left + right) // 2
10 elif n>lst[middle]:
11 left=middle+1
12 middle = (left + right) // 2
13 elif n==lst[middle]:
14 print('找到了',middle)
15 break
16 else:
17 print('没找到')
递归版本二分法
1 lst=[11,22,33,44,55,66,77,88,99,123,145,156,178,189,215,246,287,298,568,687,789,890,960]
2 def func(n,left,right):
3 if left <=right:
4 middle=(left+right)//2
5 if n<lst[middle]:
6 right=middle-1
7 return func(n, left, right)
8 elif n>lst[middle]:
9 left=middle+1
10 return func(n, left, right)
11 elif n==lst[middle]:
12 print('找到了')
13 return middle #这个位置返回的值返回的是给调用他的函数,而不是直接返回给第一个func
14 else:
15 print('没找到')
16 return -1
17 ret=func(78,0,len(lst)-1)
18 print(ret)