python匿名函数就是没有名字的函数_python基础-匿名函数和内置函数

匿名函数和内置函数

匿名函数：没有名字，使用一次即被收回，加括号就可以运行的函数。

语法：lambda 参数:返回值

使用方式：

将匿名函数赋值给变量，给匿名函数一个名字，使用这个变量来调用(还不如用有名函数)

res = lambda x,y:x*y

print(res(2,3)) # 打印结果：6

与内置函数一起使用，如：max，min，sorted，map，filter，reduce

内置函数就是python解释器给我们提供的函数。

max 返回给定参数的最大值，这个参数可以是可迭代对象

语法：max(可迭代对象,key=函数对象)

min 返回给定参数的最小值，这个参数可以是可迭代对象

语法：min(可迭代对象,key=函数对象)

# 需求：求出以下工资最高和工资最低的员工

user_dic = {

'赵铁柱': 3000,

'张全蛋': 20000,

'伍六七': 1500,

'李小花': 8000

}

s_max = max(user_dic, key=lambda x: user_dic[x])

"""

1.max内部会遍历user_dic，将遍历结果一一传给lambda的参数x

2.依据lambda的返回值作为比较条件，得到最大条件下的那个遍历值

3.对外返回最大的遍历值

"""

print(f"工资最高的员工是：{s_max}")

s_min = min(user_dic, key=lambda x: user_dic[x])

print(f"工资最低的员工是：{s_min}") # 原理跟max 类似

sorted 接收一个key函数(可选)来实现对可迭代对象进行自定义的排序

语法：sorted(可迭代对象,key=函数对象,reverse=False)

reverse：排序方向，默认从小到大，reverse=True为降序

# 1、对列表按照绝对值进行排序

li = [-21, -12, 5, 9, 36]

print(sorted(li, key=lambda x: abs(x)))

"""

sorted()函数按照keys进行排序，并按照对应关系返回list相应的元素：

keys使用lambda函数排序结果 => [5, 9, 12, 21, 36]

| | | | |

最终结果 => [5, 9, -12, -21, 36]

"""

# 2、假设我们用一组tuple表示学生名字和成绩：

L = [('sean', 75), ('egon', 92), ('Jessie', 66), ('tank', 88)]

# 2.1 请用sorted()对上述列表分别按名字排序

print(sorted(L, key = lambda x : x[0]))

"""

1.sorted内部会遍历L，将遍历结果一一传给lambda的参数x

2.依据lambda的返回值依次进行排序，得到排序后的list列表

3.对外返回排序后的列表

"""

# 输出[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]

# 2.2 再按成绩从高到低排序

print(sorted(L, key = lambda x : x[1], reverse=True))

# 输出[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]

map 映射。将可迭代对象中的每一个值进行修改，然后映射到一个map 对象中，可将这个map 对象转换其他容器类型展示结果。只能转换一次

语法：map(函数对象,可迭代对象)

# 1、求列表[1,2,3,4,5,6,7,8,9],返回一个n*n 的列表

# 常规解决方案

list1 = [1,2,3,4,5,6,7,8,9]

li = []

for i in list1:

i = i ** 2

li.append(i)

print(li)

# 使用map 的解决方案

map_obj = map(lambda x: x * x, li)

print(map_obj) # 打印结果为 map对象

print(list(map_obj)) # 将map 对象转换成列表展示

print(tuple(map_obj)) # 打印为空 ？？？

从以上打印结果可以发现，map_obj 转换两次，再次打印的结果是空。这是咋了，放心，这个结果没被我吃掉！！！这是因为map对象本质是可迭代对象 。list(map_obj)或 for num in map_obj 这样的语句，就是调用了迭代器，执行了__ next __(),消耗了迭代对象。所以，再次使用map_obj后，会发现它已经空了。

reduce 合并。每次从可迭代对象中获取两个值进行累积计算。其效果就是：

reduce(func,[1,2,3]) 等同于 func(func(1,2),3)

语法：reduce(函数对象,可迭代对象,初始值)

注意：

使用reduce 函数，必须导包 from functools import reduce

在求和时，初始值默认为0；求乘积时，初始值为1

from functools import reduce

# 求1-100之内的和

res_sum = reduce(lambda x, y: x + y, range(1, 101), 0)

print(res)

# 求1-9的积

res_pro = reduce(lambda x, y: x * y, range(1, 10))

print(res_pro)

filter 过滤。根据函数中返回值是True还是False决定保留还是丢弃该元素。如果是True就“过滤出来”，并添加到filter 对象中。

语法：filter(函数对象，可迭代对象)

# 求列表['1A','2A','3C','4C','5A']中，返回不包含A的列表

key_list = ['1A','2A','3C','4C','5A']

filter_obj = filter(lambda key:key.endswith('C'),key_list)

print(filter_obj) # 打印filter 对象 ---->

print(list(filter_obj)) # 将filter 对象转换成列表展示

print(tuple(filter_obj)) # 打印出空元组，原理同map 对象

从上述代码可以发现，filter 对象本质上也是一个可迭代对象

扩展题

1、请利用filter()筛选出200以内的回数。回数是指从左向右读和从右向左读都是一样的数，例如12321，909

2、现有列表 L = ["1","2","3","5","7","8","4","9","6"]

1) 求列表中所有偶数组成的最大整数

2) 求列表中所有奇数组成的最小整数