内置函数, 递归, 二分法

一. lambda()

a = lambda n: n ** 2

a = lambda x, y: (x, y)

a = lambda x, y: x, y            这个需要两个变量名来接收, 把y赋值给第二个变量名

fn = lambda *args: max(args)

lambda有返回值

 

二. sorted()

sorted(iterable, key, reverse)

lst = sorted(lis, key = lambda el: el[:2], reverse = True)

lst = sorted(lis, key = func, reverse = True)            func不加括号

sorted函数会把lis的每一个元素交给key, 然后计算出这个元素的权重, 整个函数按权重进行排序, sorted有返回值

 

三. filter()

filter(function, iteraable)

f = filter(lambda el: int(el[0]) < 5, lst)

print(list(f))

filter函数返回True的都会保留, False都会去除

获取的返回值是一个迭代器

m = map(func1, map(func2, map(func3, lst)))           # 分而治之

m = map(lambda x, y, z: x + y + z, [1,2,3,4,5,6], [1,2,3,4,5], [1,2,3,4])     # 返回的迭代器的元素个数取最短的那个列表的个数

 

四. map()

map(function, iterable)

把可迭代对象中的每一个元素交给前面的函数进行执行, 返回值就是map的处理结果

m = map(lambda el: el ** 2, lst)

print(list(m))

返回的也是迭代器

 

五. repr()

print(repr('你好'))        # '你好'         程序中内部存储的内容, 是给程序员看的

print('你好')       # 你好          给用户看的

print(r'\\你好')       # \\你好          原样输出

 

六. 递归

递归深度默认是1000, 可以改变, 但实际只能到998左右, 看机器好坏, 到了深度会报错

遍历 D:/sylar文件夹, 打印出所有的文件和普通文件的文件名
import os
def func(filepath, n): # d:/sylar/
    # 1,打开这个文件夹
    files = os.listdir(filepath)
    # 2. 拿到每一个文件名
    for file in files:  # 文件名
        # 3. 获取到路径
        f_d = os.path.join(filepath, file) # d:/sylar/文件名/
        # 4. 判断是否是文件夹
        if os.path.isdir(f_d):
            # 5. 如果是文件夹. 继续再来一遍
            print("\t"*n, file,":") # 打印文件名
            func(f_d, n + 1)
        else:   #  不是文件夹. 普通文件
            print("\t"*n, file)

func("d:/sylar",0)

　　

七. 二分法

核心: 切头去尾取中间, 一次砍一半

两种算法: 常规循环, 递归循环

# 递归来完成二分法
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789]
def func(n, left, right):
    if left <= right: # 边界
        print("哈哈")
        mid = (left + right)//2
        if n > lst[mid]:
            left = mid + 1
            return func(n, left, right) # 递归  递归的入口
        elif n < lst[mid]:
            right = mid - 1
            # 深坑. 函数的返回值返回给调用者
            return func(n, left, right)    # 递归
        elif n == lst[mid]:
            print("找到了")
            return mid
            # return  # 通过return返回. 终止递归
    else:
        print("没有这个数") # 递归的出口
        return -1 # 1, 索引+ 2, 什么都不返回, None
# 找66, 左边界:0,  右边界是:len(lst) - 1
ret = func(66, 0, len(lst) - 1)
print(ret) # 不是None

　　

时间复杂度, 空间复杂度最低的查找方法

lst1 = [5,6,7,8]
lst2 = [0,0,0,0,0,1,1,1,1]     # 个数是lst1中最大的元素加1
for el in lst1:           
    lst2[el] = 1

print(lst2[5])

　　

　　

来源：https://www.cnblogs.com/NachoLau/p/9483300.html