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） 求列表中所有奇数组成的最小整数