python中的内置函数(2)

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

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

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

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

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

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

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

def func(n):
    return n**2
print(func(10))  #100
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))  #55

二.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)