内置函数二

内置函数二

lambda匿名函数

# 计算n的n次方
    def func(n):
        return n**n
    print(func(10))
    
    f = lambda n : n**2
    print(f(10))

lambda表示的是匿名函数，不需要用def来声明，一句话就可以声明处一个函数。

语法 ：
    函数名 = lambda  参数：返回值
    
注：
    1.函数的参数可以有多个，多个参数之间用逗号隔开。
    2.匿名函数不管多复杂只能用一行，切罗季结束后直接返回数据。
    3.返回值和正常的函数一样，可以是任意数据类型。

sorted 排序函数

语法：sorted（lterable,key=None,reverse=False）
    lterable:可迭代对象
    key：排序规则（排序函数），在sorted内部将可迭代对象的每一个元素传递给这个函数的参数，根据函数运行的结果进行排序。

    lst = [1,5,3,7,9,]
    lst2 = sorted(lst)
    print(lst)  # 元列表不会改变
    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 = ["宫崎骏", "和田光司", "中央情报局", "狐仙"]
    
# 计算字符串长度
    def func(s):
        return len(s)
       
    print(sorted(lst,key=lambda s: len(s)))

 # 按照年龄对学⽣信息进⾏排序
    lst = [{"id":1, "name":'alex', "age":18},
     {"id":2, "name":'wusir', "age":16},
     {"id":3, "name":'taibai', "age":17}]
    
    print(sorted(lst, key=lambda e: e['age']))

filter 筛选函数

语法：filter(function,lterable)
   fumction:用来筛选的函数，在filter中会自动的把iterable中的元素传递给function，
   然后根据function返回的True或者False来判断是否保留此项数据
   lterable:可迭代对象

# 筛选所有偶数    
    lst = [1,2,3,4,5,6]
    l1 = filter(lambda x : x%2==0,lst)
    print(l1)
    print(list(l1))

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

map() 映射函数

语法：map(function,lterable) 可以对可迭代对象中的每一个元素进行映射，分别去执行function

#  计算列表中每个元素的平方，返回新的列表
    def func(e):
        return e**e
        
    f = map(func,[1,2,3,4,5])
    print(list(f))
    
改写成lambda
    print(list(map(lambd 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)))

递归 ：在函数中调用函数本身，就是递归

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

在python中递归最大的深度到1000，函数中本身调用次数+运行次数

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

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

import os 
def read(filepath,ceng):
    files = os.listdir(filepath) # 获取到文件中的所有文件夹
    for fi in files:           # 遍历文件夹中文件，这里获取的是本层文件名
        fi_d = os.path.join(filepath,fi)  # 加入文件夹，获取到文件夹+文件
        if os.path.isdir(fi_d):  # 如果该路径下的文件是文件夹
            print('	'*ceng,fi)
            read(fi_d,ceng+1)     # 继续进行相同的操作
        else:
            print('	'*ceng,fi)   #  递归出口，最后在这里隐含着return
                           
 read('e:/123',0)  # 递归遍历目录下的所有的文件

二分查找

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

# 判断n是否在lst中出现，算了几次，返回n所在位置
# 二分查找---非递归算法    
    lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
    n = 0
    left = 0
    right = len(lst)-1
    count = 1
    while left <= right:
        middle = (left + right) // 2
        if n < lst[middle]:
            right = middle - 1
        elif n > [middle]:
            left = middle + 1
        else:
            print(count)
            print(mibble)
            break
        count += 1
    else；
        print('不在这里')    
    
    
#  普通递归版本二分法
    def binary_search(n,left,right):
        if left <= right:
            middle = (left + right) //2
            if n < lst[middle]:
                right = middle -1
            elif n > lst[middle]:
                left = middle + 1
            else:
                return middle
            return binary_search(n,left,right) # 这个return必须有，否则接受到的永远是None
            
        else:
            return -1
    print(binary_search(n,0,len(lst)-1))


# 另类二分法，很难计算位置
    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[niddle:],taret)
         else:
            print('在这里')
    binary_search(lst,（所传值）)