python notice10 内置函数2

一、lambda匿名函数

　　为解决一些简单的需求而设计的一句话函数。lambda表示的是匿名函数，不需要def来声明，一句话就可以声明一个函数。

　　语法：

　　　　函数名 =lambda 参数：返回值

#计算N的n次方
def func(n):
    return n**n
print(func(3))

#lambda函数
f = lambda n:n**n
print(f(3))

注：

　　1.函数的参数可以有多个，各个参数之间用逗号隔开。

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

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

二、sorted()

　　排序函数

　　语法:sorted(Iterable,key= None,reverse=False)

　　　　Iterable:可迭代对象

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

　　　　reverse:是否是倒序。True：倒序；False：正序。

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

dic = {1:"A",3:"C",2:"B"}
print(sorted(dic))    #对于字典，以列表形式返回排序后的key

#和函数组合使用
lst = ["小黑人","请叫他小黑人","小黑人不黑"]
def func(s):
    return len(s)

print(sorted(lst,key=func))

#和lambda组合使用
lst = ["小黑人","请叫他小黑人","小黑人不黑"]
print(sorted(lst,key=lambda s: len(s)))

三、filter()函数

　　筛选函数

　　语法：filter(function,Iterable)

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

　　　　Iterable:可迭代对象

lst = [1,2,3,4,5,6,7]
ss = filter(lambda x: x%2 == 0,lst)
print(ss)

四、map()函数

　　映射函数

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

#计算列表中每个元素的平方，并返回新列表
def func(e):
    return e*e

mp = map(func,[1,2,3])
print(mp)
print(list(mp))

#lambda形式
print(list(map(lambda x:x*x,[1,2,3])))

#计算列表中相同位置数据的和
lst1 = [1,2,3,4,5]
lst2 = [2,4,6,8,10]
print(list(map(lambda x,y:x+y,lst1,lst2)))

五、递归

　　递归就是在函数中调用函数本身，在python中递归的最大深度到998.可以通过sys模块改变递归深度。难点：不好想，需要找规律，同时代码不好读。

import sys
sys.setrecursionlimit(深度)    #可以调整递归深度，但不一定能达到。

递归的应用：可以使用递归来遍历各种树形结构，比如文件夹系统，可以使用递归来遍历文件夹中的所有文件。

import os

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("F:/learning/python/workspace",0)

六、二分法查找

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

　　要求：查找的序列必须是有序序列。

　　法1.二分法查找——非递归算法

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
n = 567
left = 0
right = len(lst) - 1
count = 1
while left <= right:
    middle = (left + right) // 2
    if n > lst[middle]:
        left = middle + 1
    elif n < lst[middle]:
        right = middle - 1
    else:
        print(count)
        print("存在")
        print(middle)
        break
    count = count + 1
else:
    print("不存在")

　　法2.二分法查找——普通递归

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]

def binary_search(left, right, n):
    if left <right:
        middle = (left + right)//2
        # if left > right:
        #     return -1
        if n > lst[middle]:
            left = middle + 1
        elif n < lst[middle]:
            right = middle - 1
        else:
            return middle
        return binary_search(left, right, n) '''这个return必须加，否则接收到的
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　永远是None。在函数调用时，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　哪里调用返回值就返回哪里。'''
    else:
        return -1
print(binary_search(0, len(lst)-1, 65))

　　法3.切片二分法，只能输出是否找到，很难计算位置。

lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
def binary_search(lst, n):
    left = 0
    right = len(lst) - 1
    middle = (left + right) // 2
    if right <= 0:
        print("没找到")
        return
    if n > lst[middle]:
        lst = lst[middle+1:]
    elif n < lst[middle]:
        lst = lst[:middle]
    else:
        print("找到了")
        return
    binary_search(lst, n)
binary_search(lst, 66)

　

https://www.processon.com/view/link/5b4ee15be4b0edb750de96ac