递归,二分法,lambda,filter,map,sorted

Posted 2020-12-29 lxx7

一 匿名函数(lamda) 

为及解决简单的一些需求而设计的一句话函数

函数名 = lamba参数:返回值
f = lambda n: n*n      求n的n次方
print(f(9))

注意

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

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

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

小注意点

匿名函数之所以叫匿名函数是因为我们通过__name__查看的时候,是没有名字的统一交lamda,

正常函数调用查看名字
def func(n):
    return n*n
print(func.__name__)    #func

与__doc__     差不多

二,sorted函数   (有返回值)

排序函数   sorted(iterable, key = mone, reverse = False)

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

reverse:默认是升序,reverse = True  是降序

lst = [23,4,12,3,7]
lst_new = sorted(lst)
print(lst)
print(lst_new)

# 和函数搭配使用
lst = [23,4,12,3,7]
def func(n):
    return n % 2
s = sorted(lst,key = func)
print(s)

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

# 和lambda搭配使用
lst = [23,4,12,3,7]
s = sorted(lst,key = lambda n :n + 1)
print(s)

三 filter 函数

筛选函数  filter(function,literable)

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

ll = [23,4,12,3,7]
s = filter(lambda x: x % 2 == 0,ll)
print(s)  #得到的是筛选对象 <filter object at 0x0046FE10>
print(list(s))  #[4, 12]

lst = [{"id":1, "name":‘alex‘, "age":18},
{"id":2, "name":‘wusir‘, "age":16},
{"id":3, "name":‘taibai‘, "age":17}]
s = filter(lambda x: x["age"] >16,lst)
print(s)#<filter object at 0x002D0A10>
print(list(s))#[{‘id‘: 1, ‘name‘: ‘alex‘, ‘age‘: 18}, {‘id‘: 3, ‘name‘: ‘taibai‘, ‘age‘: 17}]

四 map

映射函数    map(function,literable)可以对可迭代对象的每一个元素进行映射,分别取执行function

# def func(n):
#     return n*n
# lst = [1,3,45,2]
# s = map(func,lst)
# print(s)#<map object at 0x001EF970>
# print(list(s))#[1, 9, 2025, 4]

# 与lambda使用
lst= [1,2,3,1,78]
s = map(lambda x:x*x,lst)
print(list(s))

# 计算两个列表中相同位置的数据的和  有水桶效应(map)
lst1 = [1,3,5,7,3,23,54]
lst2 = [34,7,8,45,9,22,3,33]
s = map(lambda x,y:x + y ,lst1,lst2)
print(list(s))  #[35, 10, 13, 52, 12, 45, 57]

五 递归

在函数中调用函数本身,就是递归,在Python中递归的最大深度就是1000,其实不到1000就会报错

def func():
    print("小仙女")
    func()
func()

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

递归的应用:  递归用return 出口

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

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(‘../oldboy/‘, 0)

六 二分查找

每次能够砍掉一半的数据,查找效率非常高,但是只有有序的序列才能用

lst = [2, 3, 4, 5, 6, 7, 8, 9, 12, 45, 90, 95,112,134]
def func(left ,right,n):
    if left <= right:
        mid = (left + right) // 2   #中间索引位置
        if n > lst[mid]:
            left = mid +1
            return func(left ,right,n)
        elif n < lst[mid]:
            right = mid -1
            return func(left ,right,n)
        else:
            print("找到了")
            return mid   找到返回索引,那么上面的都要加上return在调用

　　　　###return func(left ,right,n)

    else:
        print("mei")
        return -1  #找不到返回-1
ret = func(0,len(lst)-1,77)
print(ret)

注意  也可以将下面绿色的部分只写一次,放在我标注的上面代码我标注绿色的地方

return func(left ,right,n)

============================================================
普通版本

n = 8
# lst = [2, 3, 4, 5, 6, 7, 8, 9, 12, 45, 90, 95,112,134]
# left = 0
# right = len(lst) -1
# while left <= right:
#     mid = (left + right)
#     if n > lst[mid]:
#         left += 1
#         continue
#     elif n < lst[mid]:
#         right -= 1
#         continue
#     else:
#         print("找到了")
#         break
# else:
#     print("mei")

另类的二分法

def binary_search(ls, target):
    left = 0
    right = len(ls) - 1
    if left > right:
        print("不在这里")
    middle = (left + right) // 2
    if target < ls[middle]:
        return binary_search(ls[:middle], target)
    elif target > ls[middle]:
        return binary_search(ls[middle+1:], target)
    else:
        print("在这里")
binary_search(lst, 567)