zoukankan      html  css  js  c++  java
  • python学习第13天----lambda、sorted、map、filter、递归、二分查找

    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
  • 相关阅读:
    编译原理-第二章 一个简单的语法指导编译器-2.4 语法制导翻译
    编译原理-第二章 一个简单的语法指导编译器-2.3 语法定义
    编译原理-第二章 一个简单的语法指导编译器-2.2 词法分析
    LeetCode 1347. Minimum Number of Steps to Make Two Strings Anagram
    LeetCode 1348. Tweet Counts Per Frequency
    1349. Maximum Students Taking Exam(DP,状态压缩)
    LeetCode 1345. Jump Game IV(BFS)
    LeetCode 212. Word Search II
    LeetCode 188. Best Time to Buy and Sell Stock IV (动态规划)
    LeetCode 187. Repeated DNA Sequences(位运算,hash)
  • 原文地址:https://www.cnblogs.com/piaolaipiaoqu/p/13853699.html
Copyright © 2011-2022 走看看