python学习第13天----lambdasortedmapfilter递归二分查找

Posted piaolaipiaoqu

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python学习第13天----lambdasortedmapfilter递归二分查找相关的知识,希望对你有一定的参考价值。

1.lambda(匿名函数)

1)当需要用到很简单的函数时,可以使用lambda;一行可定义一个函数,但是不能完成复杂的函数操作

2)语法:

         lambda x,y: x+y

lambda后的变量为参数,冒号后面时函数体(直接return的内容)

#普通函数

技术图片
def func(n):
    return n*n
print(func(3))
View Code

#匿名函数

技术图片
a = lambda n: n*n
print(a)  #直接打印为内存地址
print(a(3))
View Code

3)lambda生成的匿名函数,函数名都为lamdba;可以通过函数__name__查看

技术图片
def func(n):
    return n*n
print(func(3))

a = lambda n: n*n
print(a)  #直接打印为内存地址
print(a(3))

x = func
print(x.__name__)
print(a.__name__)
输出:
9
<function <lambda> at 0x000001C0FFC1B0D0>
9
func
<lambda>
View Code

3)lambda(匿名函数)注意事项

①函数的参数可以有多个,多个参数之间只能用逗号隔开

②匿名函数不管有多复杂,只能写一行,且逻辑结束后直接返回数据

③返回值和正常的函数一样,可以是任意的数据类型;若要返回一个列表,可使用推导式

注:匿名函数并不是一定没有名字,前面的变量就是一个函数名;只是通过__name__查看的时候是没有名字的,同意都叫lambda,在调用的时候没有特殊之处,像正常的函数调用即可

2.sorted()内置函数-------用于排序

1)语法

         sorted(lterable,key=None,reverse=False)

         参数说明:

lterable:可迭代对象

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

技术图片
#sort()是列表自身的一个方法,是对自身的一个修改和处理
lst = [2,7,3,8,13,9]
lst.sort()
print(lst)

#sotred()是一个内置函数,返回的是一个新列表,新列表是被排序的
lst = [2,7,3,8,13,9]
lst_new = sorted(lst)
print(lst_new)
输出:
[2, 3, 7, 8, 9, 13]
[13, 9, 8, 7, 3, 2]
View Code

#倒叙排列

技术图片
lst = [2,7,3,8,13,9]
lst_new = sorted(lst,reverse=True)
print(lst_new)
输出:
[13, 9, 8, 7, 3, 2]
View Code

#参数key的使用:根据字符串的长度对列表进行排序

技术图片
lst = ["英雄联盟","飞车","DNF","剑灵","地下城勇士"]
def func(s):
    return len(s)
lst_new = sorted(lst,key = func)  #是把可迭代对象中的每一个元素传递给func
print(lst_new)
输出:
[飞车, 剑灵, DNF, 英雄联盟, 地下城勇士]
View Code

#lambda配合sorted()一起使用

技术图片
lst = ["英雄联盟","飞车","DNF","剑灵","地下城勇士"]
lst_new = sorted(lst,key = lambda s: len(s))
print(lst_new)
输出:
[飞车, 剑灵, DNF, 英雄联盟, 地下城勇士]
View Code

#将列表中的人,按照年龄进行排序

技术图片
lst = [
    {"id":1,"name":"九尾妖狐","age":26},
    {"id":2,"name":"惩戒之箭","age":28},
    {"id":3,"name":"远古巫灵","age":18}
]
lst_new = sorted(lst,key = lambda dic :dic["age"])
print(lst_new)
输出:
[{id: 3, age: 18, name: 远古巫灵}, {id: 1, age: 26, name: 九尾妖狐}, {id: 2, age: 28, name: 惩戒之箭}]
View Code

3.filter()函数------栓选

1)语法

         filter(function,lterable)

         参数说明:

         function:用来筛选的函数,会自动的把iterable中的元素传递给function,然后根据function返回的True或False来判断是否保留次项数据,如果是True则保留下该元素

         lterable:可迭代对象

注:filter的返回结果是一个迭代器

#判断哪些是技术

技术图片
def func(i):
    return i % 2 == 1
lst= [1,2,3,4,5,6,7,8]
ll = filter(func,lst)
print(ll)
print(list(ll))
输出:
<filter object at 0x000001865882CAC8>
[1, 3, 5, 7]
View Code

#通过lambda修改以上程序

技术图片
lst= [1,2,3,4,5,6,7,8]
ll = filter(lambda i:i%2==1,lst)
print(ll)
print(list(ll))
输出:
<filter object at 0x0000022E8728CAC8>
[1, 3, 5, 7]
View Code

#筛选出列表中年龄大于20的元素

技术图片
lst = [
    {"id":1,"name":"九尾妖狐","age":26},
    {"id":2,"name":"惩戒之箭","age":28},
    {"id":3,"name":"远古巫灵","age":18}
]

lst_new = filter(lambda dic:dic["age"]>20,lst)
print(list(lst_new))
输出:
[{age: 26, name: 九尾妖狐, id: 1}, {age: 28, name: 惩戒之箭, id: 2}]
View Code

4.map()----映射函数

1)语法:

         map(function,iterable)

         可以对可迭代对象中的每一个元素进行映射,分别取执行的function(即把可迭代对性的每一项取出来,执行前面的函数);返回的也是一个迭代器

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

技术图片
lst = [1,2,3,4,5,6,7,8,9]
def func(i):
    return i * i
a = map(func,lst)   #相当于把一个大的集合,分开处理,处理完成后再收回
print(list(a))
输出:
[1, 4, 9, 16, 25, 36, 49, 64, 81]
View Code

#map()配合lambda表达式

技术图片
lst = [1,2,3,4,5,6,7,8,9]
a = map(lambda x : x * x ,lst)
print(list(a))
输出:
[1, 4, 9, 16, 25, 36, 49, 64, 81]
View Code

#使用lambda时,如果函数中有多个参数,后面对应的别表要一一对应

技术图片
#将两个列表相加
lst1 = [1,22,53,23,10]
lst2 = [2,10,20,31,11]
print(list(map(lambda x,y:x+y,lst1,lst2)))
输出:
[3, 32, 73, 54, 21]
View Code

5.递归(即函数自己调用自己)

因为每次调用函数都会开辟新的内存空间,所以递归函数如果没有次数限制,内存一定会爆,所以在python中有一个最大的内存深度为997

1)可通过sys模块中setrecusionlimit()调整最大递归深度,但是不一定只执行得到

技术图片
import sys
sys.setrecursionlimit(1000)
def func(count):
   print(str(count))
   func(count + 1)
func(1)
View Code

2)递归最大得用处就是遍历树型解构

#通过递归查找文件和文件夹

技术图片
import  os
filePath = "d:代码python"
def read(filePath, n):
    it = os.listdir(filePath)   # 打开文件夹
    for el in it:
        #  拿到路径
        fp = os.path.join(filePath, el) # 获取到绝对路径
        if os.path.isdir(fp):   # 判断是否是文件夹
            print("	"*n,el)
            read(fp, n+1)    # 又是文件夹. 继续读取内部的内容 递归入口
        else:
            print("	"*n,el)    # 递归出口

read(filePath, 0)
View Code

6.二分查找

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

1)二分法查找一个数(不使用递归)

技术图片
lst = [4,7,10,23,66,136,254,666,728,999]
n = 136
left = 0
right = len(lst)-1
while left<=right:
    middle = (left + right) // 2
    if n<lst[middle]:
        right = middle - 1
    elif n>lst[middle]:
        left = middle + 1
    else:
        print("数字存在,位置为:"+str(middle))
        break
else:
    print("数字不存在")
输出:
数字存在,位置为:5
View Code

2)通过递归得方式实现(以取列表左右两边值的方式实现)

技术图片
lst = [4,7,10,23,66,136,254,666,728,999]
def func(left,right,n):
    middle = (left+right)//2
    if n>lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        return middle
    return func(left,right,n)  #如果不返回,第二次调用函数得到得结果接收不到
print(func(0,len(lst)-1,66))
输出:
4
View Code

3)通过递归得方式实现(以切列表得方式实现),只能判断数字是否存在于列表中,无法确定在哪

技术图片
lst = [4,7,10,23,66,136,254,666,728,999]
def func(lst,n):
    left = 0
    right = len(lst) - 1
    middle = (right+left)//2
    if left>right:
        print("找不到")
        return -1
    if n > lst[middle]:
        lst = lst[middle+1:]
    elif n < lst[middle]:
        lst = lst[:middle-1]
    else:
        print("找到了")
        return
    return func(lst,n)
func(lst,66)
输出:
找到了
View Code

以上是关于python学习第13天----lambdasortedmapfilter递归二分查找的主要内容,如果未能解决你的问题,请参考以下文章

第13天:Python 输入输出

第二模块的python学习第一天记录

深度学习100例 - 卷积神经网络(Inception V3)识别手语 | 第13天

Python开发入门14天集训营·第2章Python 数据类型字符编码学习-3级菜单

深度学习----------打卡第13天

Python全栈开发第13天