匿名函数 sorted() filter() map() 递归函数

一、 lambda() 匿名函数  

　　说白了,从字面理解匿名函数就是看不见的函数,那么他的看不见表现在哪里呢?

其实就是在查询的时候他们的类型都是lambda的类型所以叫匿名,只要是用匿名函数写的大家都一个名字都叫lambda

那么我们来看一看他的用法

　　比如一个很简单的函数计算n 的平方你会怎么写??

很多人如果没有用过匿名函数的都会这样去写
def func(n):
    return n**
pinrt(func())

输出结果

这样写是没有问题的

但是经常写函数的你会知道一个问题那就是起函数名是一件非常痛苦的事,而且一个很简单的问题但必要写一个函数去执行的时候你还必须要按照函数的所有格式去把它写出来那么有没有一种简单而且又省事的写法呢?

匿名函数就可以帮你解决这个问题

前面的函数我们可以这样去写
f = lambda(n :n**2)
print(f(5))

输出的结果
 25

同样是一个结果但是匿名函数只需要一行就可以解决而且调用的时候直接调用就可以用,是不是很容易

语法 :  函数名  = lambda ()  参数: 返回值

注意:  1.函数的参数可以有多个.多个参数之间用途逗号隔开

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

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

　　

二.sorted()

排序函数.

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

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

reverse:是否是倒叙,True;倒叙False:正序

lst = [1,5,3,4,6]
lst2 = sorted(lst)
print(lst)
print(lst2) 

输出结果

[1,5,3,4,6]

[1,3,4,5,6]

字典也是一样的  返回的是排序后的key

在函数里组合使用

　　假如有这么一道题,让你根据列表里的字的长短来排序

lst = ["马化腾","马云","波多野结衣","海"]
def fun(s):
    return len(s)

print(sorted(lst, key= func))

输出结果

['海', '马云', '马化腾', '波多野结衣']

当然也可以按照我们前面学习的隐藏函数来写

def fun (s)
    return len(s)
print(sorted(lst , key = lambda s : len(s)))
lst = ["马化腾","马云","波多野结衣","海"]

输出结果

['海', '马云', '马化腾', '波多野结衣']
 

三.filter()

筛选函数

语法:  filter(function. Iterable)
function:用来筛选的函数,在filter中会自动的把iterable中的元素传递给function.然后根据function返回的Ture或者False来判断你是否保留此项数据

iterable:可迭代对象

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

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

四. map ()

映射函数

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

计算列表中每个元素的平方,返回新列表

def fun(s)
    return s**2
mp = map(fun,[1,2,3,4,5])
print (mp)
print(list(mp))

输出结果

<map object at 0x000002990C24DE10>
[1, 4, 9, 16, 25]

改写成lambda()

print(list(map)lambda x: x *x,[1,2,3,4,5,])))

输出的结果是一样的

计算两个列表中相同的位置迭的数据的和

lst 1=[1,2,3,4,5]
lst 2= [2,5,8,6,4]
print(lst (map)lamba x,y :x+y , lst1,lst2)))

输出结果

[3, 7, 11, 10, 9]

五.递归

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

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

在python中递归的深度最大到1000.但是一般是达不到1000是在998左右

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

输出结果
...
997
998Traceback (most recent call last):
RecursionError: maximum recursion depth exceeded while calling a Python object
报错

递归的应用:

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

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("\t"*n, fi)
　　　　　　　　read(fi_d, n+1) # 继续进⾏行行相同的操作
　　　　　　else:
　　　　　　　　print("\t"*n, fi) # 递归出⼝口. 最终在这⾥里里隐含着return
#递归遍历⽬目录下所有⽂文件
read('../oldboy/', 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:
　　middle = (left + right) // 2
　　if n < lst[middle]:
　　　　right = middle - 1
　　elif n > lst[middle]:
　　　　left = middle + 1
　　else:
　　　　print(count)
　　　　print(middle)
　　　　break
　　count = 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]:
　　　　eft = middle + 1
　　else:
　　　　return middle
return binary_search(n, left, right) # 这个return必须要加. 否则接收
到的永远是None.
　　else:
　　　　return -1
print(binary_search(567, 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[middle+1:], target)
　　else:
　　　　print("在这⾥里里")
binary_search(lst, 567)