内置函数递归二分法

Posted li-li

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了内置函数递归二分法相关的知识,希望对你有一定的参考价值。

一、lambda匿名函数

       为了解决一些简单的需求而设计的一句话函数,如下示例:

    # 以前的写法
    def func(n):
        return n ** n
    print(func(10))

    # lambda函数
    f = lambda n : n ** n
    print(f(10))
    print(f.__name__)  # 结果为:<lambda>
    # __name__可以查看函数的名字,匿名函数__name__的值都是<lambda>

  lambda表示的是匿名函数,不需要用def来声明,一句话就可以声明出一个函数,语法如下:

              函数名 = lambda 参数 : 返回值

注意:

       1,函数的参数可以有多个,多个参数之间用逗号隔开;

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

       3,返回值和正常的函数一样,可以是任意数据类型;

再注意:匿名函数有两个返回值时,返回值用()括起来,如下示例:

    suiyi = lambda x, y : (x+1, y+2)   
    print(suiyi(2,3))  # 结果为:(3, 5)

  匿名函数并不是说一定没有名字,上面的例子中匿名函数前面变量就是一个函数名,说它匿名是因为我们通过__name__查看的时候是没有名字的,统一都叫lambda,在调用的时候没有什么特别之处,像正常的函数调用即可。

二、sorted()

       前边我们学了一个排序函数sort(),这是列表的专用排序函数,详见“python数据类型二(列表和元组)”,python的内置函数中为我们提供了一个通用的排序方案:sorted()。

       排序函数sorted(),语法:sorted(Iterable, key=None, reverse=False)

                     Iterable:可迭代对象;

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

                     reverse:是否是倒序,True:倒序,False:正序(默认)

    lst = [1,5,3,4,6]
    lst2 = sorted(lst)
    print(lst)  # [1, 5, 3, 4, 6],元列表不会改变
    print(lst2)  # [1, 3, 4, 5, 6],返回新列表是经过排序的

    dic = {1:a, 3:c, 2:b}
    print(sorted(dic)) # 结果为:[1, 2, 3]
    # 如果是字典,则返回排序过后的key

和普通函数组合使用,示例如下:

    # 根据字符串长度进行排序
    lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"]
    # 计算字符串长度
    def func(s):
        return len(s)
    print(sorted(lst, key=func))
    # 结果为:[‘狐仙‘, ‘麻花藤‘, ‘冈本次郎‘, ‘中央情报局‘]

和lambda匿名函数组合使用,示例如下:

    # 根据字符串长度进行排序
    print(sorted(lst, key=lambda s : len(s)))
    # 结果也为:[‘狐仙‘, ‘麻花藤‘, ‘冈本次郎‘, ‘中央情报局‘]

    # 有如下列表,按照年龄对学生信息进行排序
    lst = [
        {id:1, name:alex, age:18},
        {id:2, name:wusir, age:17},
        {id:3, name:taibai, age:19}
    ]
    print(sorted(lst, key=lambda el : el[age]))

三、filter()

       筛选函数:语法:filter(function, Iterable)

                            function:用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据,返回True的保留,返回False的被过滤掉;

                            Iterable:可迭代对象

    lst = [1,2,3,4,5,6,7]
    ll = filter(lambda x : x % 2 == 0, lst)  # 筛选所有的偶数
    print(ll)  # 结果为:<filter object at 0x0000000002974198>
    print(list(ll))  # 结果为:[2, 4, 6]

    lst = [
        {id: 1, name: alex, age: 18},
        {id: 2, name: wusir, age: 17},
        {id: 3, name: taibai, age: 19}
    ]
    f1 = filter(lambda e : e[age] > 17, lst)  # 筛选年龄大于17的数据
    print(list(f1))

四、map()

       映射函数:语法:map(function, iterable)对可迭代对象中的每一个元素进行映射,分别去执行function。

    # 计算列表中的每个元素的平方,返回新列表,如下示例:
    def func(e):
        return e*e
    mp = map(func, [1,2,3,4,5])
    print(list(mp))  # 结果为:[1, 4, 9, 16, 25]
    # 改写成lambda匿名函数
    print(list(map(lambda e : e*e, [1,2,3,4,5])))

    # 计算两个列表中相同位置的数据的和(遵循水桶效应,即长度取决于最短的列表长度)
    lst1 = [1,2,3,4,5]
    lst2 = [2,4,6,8,10]
    print(list(map(lambda x, y : x+y , lst1, lst2)))  # [3, 6, 9, 12, 15]

注意:map()函数的代码很简单,但是思想很重要,分而治之的思想,map(func1, map(func2, map(func3 , lst)))。

五、递归

       在函数中调用函数本身,就是递归。如下示例:

    def func():
        print("我是谁")
        func()
    func()

  递归深度就是函数自己调用自己的次数,官方文档中递归最大深度是1000. 但是在这之前就会报错,所以到不了1000。下面示例可以显示递归的深度:

    def foo(n):
        print(n)
        n += 1
        foo(n)
    foo(1)

递归的应用:

       我们可以使用递归来遍历各种树形结构,比如我们的文件夹系统,可以使用递归来遍历该文件夹中的所有文件夹,示例如下:

    import os
    def read(filepath, n):
        files = os.listdir(filepath)   # 获取到当前文件夹中的所有文件
        for fi in files:  # 比你文件夹中的文件,这里获取的只是本层文件名
            fi_d = os.path.join(filepath, fi)
            if os.path.isdir(fi_d): # 如果该路径下的文件是文件夹
                print("	"*n, fi)
                read(fi_d, n+1)  # 继续进行相同的操作
            else:
                print("	"*n, fi)  # 递归出口,最终在这里隐含着return

    # 递归遍历目录下所有文件
    read(e:/pythonDemo, 0)

六、二分法查找(核心:掐头去尾取中间,一次砍一半)

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

    # 判断n是否在lst中出现,如果出现请返回n坐在的位置
    # 方法一:二分法--常规循环,非递归算法
    lst = [22,33,44,55,66,77,88,99,101,238,345,456,567,678,789]
    n = 567
    left = 0
    right = len(lst) - 1
    count = 1
    while left <= right:
        mid = (left + right) // 2
        if n < lst[mid]:
            right = mid - 1
        elif n > lst[mid]:
            left = mid + 1
        else:
            print(f"查找了{count}次")
            print(f"索引是{mid}")
            break
        count += 1
    else:
        print("不存在")

    # 方法二:递归二分法
    def search(n, left, right):
        if left <= right:
            mid = (left+right)//2
            if n < lst[mid]:
                right = mid - 1
            elif n > lst[mid]:
                left = mid + 1
            else:
                return mid
            return search(n, left, right)
            # 这个return必须要加,否则接收到的永远是None。
        else:
            return -1

    print(f"索引是{search(567, 0, len(lst)-1)}")

    # 方法三:另类二分法,弊端是无法获取查找元素的位置,只能判断是否存在
    def search2(lst, target):
        left = 0
        right = len(lst) - 1
        if left > right:
            print("不存在")
        mid = (left+right)//2
        if target < lst[mid]:
            return search2(lst[:mid],target)
        elif target > lst[mid]:
            return search2(lst[mid+1:],target)
        else:
            print("存在")
    search2(lst, 567)

二分法拓展:

    # 查找的时间复杂度最低, 空间复杂度最低
    lst1 = [5,6,7,8]
    lst2 = [0,0,0,0,0,0,0,0,0]  # lst1的最大数字是n就设置n+1个元素的lst2
    for el in lst1:
        lst2[el] = 1   # 将lst2中的下标分别为lst1中元素的元素设置为1
    # lst2 = [0,0,0,0,0,1,1,1,1]
    if lst2[6] == 1:   # o(1),查找一次即可知道是否存在
        print("存在")
    else:
        print("不存在")

补充:上篇遗留问题(repr()函数)

repr()的官方文档写的是:Return the canonical string representation of the object,翻译为:返回对象的规范字符串表示形式。

    print("你好. 我\叫周润发") # 对用户是友好的. 非正式的字符串,结果为:你好. 我叫周润发

    # 正式(官方)的字符串, 面向对象的时候能用到
    print(repr("你好, 我"叫周润发")) # 程序中内部存储的内容, 这个是给程序员看的
    # 结果为:‘你好, 我"叫周润发‘

    print("我叫%r" % "周润发") # %r 实际上调用的是repr() 结果为:我叫‘周润发‘

    # 原样输出
    print(r"马化腾说:"哈哈哈, " 
	")

    print("你好") # 用户看着舒服
    print(repr("你好")) # 真实的字符串表示形式(正式的)

 

以上是关于内置函数递归二分法的主要内容,如果未能解决你的问题,请参考以下文章

14 内置函数 递归 二分法查找

函数递归 二分法 匿名函数 内置函数 模块的使用 模块的搜索路径

内置函数递归二分法

三元表达式递归二分法匿名函数内置函数

内置函数递归二分法

函数的递归,二分法,三元表达式,列表生成式,字典生成式,匿名函数,内置方法