python中的内置函数(2)

一.lambda匿名函数
定义:为了解决一些简单的需求而设计的一句话函数
例子:计算n的n次方

 def func(n):#正常的写法
     return n**2
 print(func(10))  #

 f=lambda n:n**2
 print(f(10))   #

这里的lambda小时的是匿名函数,不需要用def来声明,一句话就可以声明出一个函数

语法:
函数名=lambda 参数:返回值

注意:
　　1.函数的参数可以有多个,多个参数之间用逗号隔开,多个返回值也需要用逗号隔开,并且需要用小括号括起来
　　2.匿名函数不管多复杂,只能写一行
　　3.返回值和正常函数一样,可以是任意数据类型

匿名函数并不是说一定没有名字,这里前面的变量就可以看做函数名,说他匿名的原因是我们通过__name__查看的时候统一都叫lambda
__name__的使用方法:__name__在这里用的看起来没有多大的作用,实际上在一个大的文件中,函数可能被多次调用传递,这时只能通过__name__来查看

 def func(n):
     return n**2
 print(func(10))  #
 print(func.__name__)

 f=lambda n:n**2
 print(f(10))
 print(f.__name__)   #<lambda>

匿名函数也可以用*args()和**args():

 f=lambda *args:max(args)
 print(f(1,2,3,4,55,9,2,1))  #

二.sorted() 排序函数,内置函数提供的一个供可迭代对象排序的通用的方案
　　语法:sorted(iterable,key==none,reverse=false)
　　key:排序规则,在sorted的内部,会将可跌倒对象的每一个元素传递给这个函数的形参,根据函数运算的结果进行排序
　　reverse:是否倒叙,默认是False,不是倒叙即正序,true是正序

 lst2=sorted(lis)  #原列表不会改变,返回的是一个新列表
 print(lst2)  #[1, 1, 2, 2, 3, 4, 5, 5, 6, 6, 8, 55]

★★★★★★★★★★★★★★★★★★★★★★内置函数一般不会改变原对象,会产生并返回一个新的对象

对字典排序

 dic={1:'啊',2:'想',3:'睡觉',4:'不能睡'}
 dic1=sorted(dic)
 print(dic1)  #[1, 2, 3, 4]   返回的是排序后的 key

根据字符串的长度排序

 lis=['杀鸡取卵','杀鸡给猴看','杀人如麻,咦,吓人','杀气腾腾,阔怕']
 print(sorted(lis,key=lambda el:len(el)))

 dic=[
     {'name':'汪峰','age':20},
     {'name':'章子怡','age':18},
     {'name':'美丽','age':13}
 ]
 dic1=sorted(dic,key=lambda el:el['age'],reverse=True)
 print(dic1)  #[{'name': '汪峰', 'age': 20}, {'name': '章子怡', 'age': 18}, {'name': '美丽', 'age': 13}]

三.filter()筛选函数
　　语法:filter(function,iterable)
　　function:用来筛选的函数,在filter中自动的会吧iterable中的每一个元素传给function,然后根据function返回的true或False来判断是否保留此项数据
　　iterable:可迭代对象

 lis=[1,2,3,4,5,5,66,98,55,15,20]
 lis1=filter(lambda el:el%2==0,lis)   #符合函数的内容就是true,留下,不符合函数的内容就是False,筛掉
 print(lis1)   #<filter object at 0x000002B514A08860>  #返回的是内存地址
 print(list(lis1))   #[2, 4, 66, 98, 20]

 lis=['周冬雨','李易峰','周杰伦','李连杰','李小龙']
 ll=filter(lambda el :el[0]=='周',lis)
 print(list(ll))   #['周冬雨', '周杰伦']

 dic=[
     {'name':'汪峰','age':20},
     {'name':'章子怡','age':18},
     {'name':'美丽','age':13}
 ]
 baobao=filter(lambda el:el['age']<15,dic)
 print(list(baobao))   #[{'name': '美丽', 'age': 13}]

四.map():映射函数
　　语法:map(function,iterable) 将列表中的每一个元素都践行function操作,返回得到的列表的地址

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

 lis=[1,2,3,4,5,6]
 mp=map(lambda el :el**2,lis)
 print(list(mp))   #[1, 4, 9, 16, 25, 36]

 计算两个列表中相同位置的数据的和
 lis=[1,2,3,4,5,6]
 # lis2=[6,5,4,3,2,1]
 # mp=map(lambda el1, el2 :el1+el2 ,lis,lis2)
 # print(list(mp))  #[7, 7, 7, 7, 7, 7]

 map()也存在水桶效应
 lis=[1,2,3]
 lis2=[6,5,4,3,2,1]
 mp=map(lambda el1, el2 :el1+el2 ,lis,lis2)
 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))

五.递归:在函数中调用函数本身就是递归

 i=1
 def func(i):
     print(i)
     print('我是专业的!')
     i+=1
     func(i)
 func(i)
 我是专业的!
 995
 我是专业的!
 996
 我是专业的!
 997
 我是专业的!
 998    #在python中递归的最大深度到998,官方的最大深度是1000,但是在这之前会报错

递归的作用:可以使用递归来便利各种树形结构,比如文件夹系统,可以使用递归便利一个文件夹中的所有文件

 import os  #引入os模块
 def func(filepath,n):   #failpath是要打开的文件的路径    n用来控制文件或文件夹前有几个tab键,以形成层次
     files=os.listdir(filepath)    #os模块中的方法,获取当前文件夹中的所有文件名
     for fi in files:     #将所有的文件名遍历
         fi_d=os.path.join(filepath,fi)    #引用os模块中的方法,将e:/python和文件名连在一起,组成一个新的路径
         if os.path.isdir(fi_d):       #判断该路径下的文件是不是文件夹
             print('\t'*n+fi+':')  #前面加指定个数的tab键,文件名,冒号
             func(fi_d,n+1)     #继续调用func函数
         else:
             print('\t'*n+fi)   #直接打印文件名
 func('e:/python',0)

六.二分法查找:
　　二分法查找,每次能够 排除掉一半的数据,查找的效率非常高,但是有一定的局限性,必须是有序序列才可以使用二分法查找
判断n是否在lst中,如果存在返回n所在位置的索引
普通版本二分法

 lst=[11,22,33,44,55,66,77,88,99,123,145,156,178,189,215,246,287,298,568,687,789,890,960]
 n=246
 left=0
 right=len(lst)-1
 middle=(left+right)//2
 while left<=right:
     if n<lst[middle]:
         right=middle-1
         middle = (left + right) // 2
     elif n>lst[middle]:
         left=middle+1
         middle = (left + right) // 2
     elif n==lst[middle]:
         print('找到了',middle)
         break
 else:
     print('没找到')

递归版本二分法

 lst=[11,22,33,44,55,66,77,88,99,123,145,156,178,189,215,246,287,298,568,687,789,890,960]
 def func(n,left,right):
     if left <=right:
         middle=(left+right)//2
         if n<lst[middle]:
             right=middle-1
             return func(n, left, right)
         elif n>lst[middle]:
             left=middle+1
             return func(n, left, right)
         elif n==lst[middle]:
             print('找到了')
             return middle  #这个位置返回的值返回的是给调用他的函数,而不是直接返回给第一个func
     else:
         print('没找到')
         return -1
 ret=func(78,0,len(lst)-1)
 print(ret)