萌新学 Python 之 lambda 函数

lambda *args : args 表达式

1. *args 属于可变的参数，相当于形式参数

2. 表达式可以结合 if 语句使用，不使用嵌套

3. lambda 函数只能使用单个表达式，不能直接嵌套 for 语句，可以使用推导式

lambda 函数赋值给变量：

案例 1：计算 n 的 n 次方

''' lambda 函数赋值给变量 '''
# 计算n的n次方
num_pom = lambda x : x ** x
print(num_pom(2))

lambda x : x ** x 中，前面的 x 是形式参数，后面的 x ** x 是参数的表达式

把前面的 x 传过来之后，做了 x ** x 的幂次方

将 x 传到表达式里面，结果返回赋值给变量 num_pom

相当于 lambda x : x ** x 是一个函数，所以参数 num_pom 就是一个函数

调用的时候需要使用小括号

因为 lambda 函数赋值给变量，作为函数使用，变量的后面需要有一对小括号

小括号里面传的值就是实参

案例 2：结合 if 语句，输入一个字符串，判断长度，小于 6 位全部转大写，大于 6 位输出

# 结合if语句，输入一个字符串，判断长度，小于6位全部转大写，大于6位输出
input_num = input('输入字符串：')
str1 = lambda x : x if len(x) > 6 else x.upper()
print(str1(input_num))

lambda x : x if len(x) > 6 else x.upper() 中前面的 x 是形参

形参传到了后面的变量 x if len(x) > 6 else x.upper()

变量是个 if 语句，且是三元运算，判断前面 x 传过来一个值到 len(x)，再判断长度

如果长度大于 6，返回给 x，否则返回大写 x.upper()

lambda 函数最后返回的就是两个值，为真是 x，为假是 x.upper()

将函数结果保存到变量 str1，相当于变量 str1 是一个函数对象

调用的时候，通过变量 str1 后面加小括号，括号里面就是实际参数

实参传的值是 input_num 输入的值

案例 3：结合 for 推导式，从一个列表中找出大于 20 的元素，返回列表

# 结合for推导式，从一个列表中找出大于20的元素，返回列表
lst = [10, 20, 30, 40, 50]
new_list = lambda x : [i for i in x if i > 20]
print(new_list(lst))     # [30, 40, 50]

lambda x : [i for i in x if i > 20] 中，前面的 x 是形参

把形参传给变量 [i for i in x if i > 20]，变量是一个推导式

通过 for 推导式生成列表元素

它的条件就是从传的参数 x 里面读取你的值 i

读取出来后，再通过 if 语句过滤，找到大于 20 的值，返回给 for 前面的 i，i 最终生成列表

lambda 函数相当于 i 的列表返回到变量 new_list

调用的时候就是把上面的 lst 列表值传到 new_list(lst) 函数里面去，就可以返回了

lambda 函数应用在列表、字典中处理数据：

''' lambda 函数应用在列表、字典中处理数据 '''
# 对元组列表进行降序排序
tup_list = [('zhangsan', 10), ('lisi', 20), ('wangwu', 30)]
# lambda当作参数传给key，t是形参，传的是tup_list元素，又是元组，可以通过下标去取元组的值
tup_list.sort(key = lambda t : t[1], reverse=True)
print(tup_list)   # [('wangwu', 30), ('lisi', 20), ('zhangsan', 10)]

# 对字典列表进行降序排序
dict_list = [{'name': 'zhangsan', 'age': 18},
             {'name': 'lisi', 'age': 20},
             {'name': 'wangwu', 'age': 16}]
# d是形参，传进来字典，通过键获取年龄，最终返回年龄
dict_list.sort(key = lambda d : d['age'], reverse=True)
print(dict_list)   # [{'name': 'lisi', 'age': 20}, {'name': 'zhangsan', 'age': 18}, {'name': 'wangwu', 'age': 16}]

lambda 函数作为参数经常与内置函数一起使用，比如 sorted、filter、map、max、min、any、all 等

sorted 排序函数：sorted(可迭代对象, key = lambda, reverse = False)

filter 过滤函数：filter(lambda, 可迭代对象)，返回 filter 对象

max|min 最大最小值：max(可迭代对象, key=lambda 函数)、min(可迭代对象, key=lambda 函数)

map 映射函数：map(lambda, 可迭代对象)，返回是 map 对象

any 某一个 | all 全部：any(可迭代对象)、all(可迭代对象)，判断迭代对象返回布尔值

''' lambda 函数作为参数经常与内置函数一起使用，比如 sorted、filter、map、max、min、any、all 等 '''
# sorted 排序函数：sorted(可迭代对象, key = lambda, reverse = False)
# 案例：对字典列表进行升序排序
dict_list = [{'name': 'zhangsan', 'age': 20},
             {'name': 'lisi', 'age': 18},
             {'name': 'wangwu', 'age': None}]
# float('-inf')是负无穷，if的三元运算符一定要有else
print(sorted(dict_list, key = lambda d : d['age'] if d['age'] is not None else float('-inf')))
# [{'name': 'wangwu', 'age': None}, {'name': 'lisi', 'age': 18}, {'name': 'zhangsan', 'age': 20}]

# filter 过滤函数：filter(lambda, 可迭代对象)，返回 filter 对象
# 案例：过滤字典列表中的None
print(list(filter(lambda d : d['age'] is not None, dict_list)))
# [{'name': 'zhangsan', 'age': 20}, {'name': 'lisi', 'age': 18}]

# max|min 最大最小值：max(可迭代对象, key=lambda 函数)、min(可迭代对象, key=lambda 函数)
# 案例：以 max 为例，找出最大的用户信息，数据中有None先过滤
filter_none = list(filter(lambda d : d['age'] is not None, dict_list))
print(filter_none)    # [{'name': 'zhangsan', 'age': 20}, {'name': 'lisi', 'age': 18}]

print(max(filter_none, key=lambda d : d['age']))          # {'name': 'zhangsan', 'age': 20}

# 只能找一个值
print(max(filter_none, key=lambda d : d['age'])['age'])   # 20

# 多个相同值时用下述方法
print([d for d in filter_none if d['age'] == max(filter_none, key=lambda d : d['age'])['age']])  # [{'name': 'zhangsan', 'age': 20}]
print(list(filter(lambda d : d['age'] == max(filter_none, key=lambda d : d['age'])['age'], filter_none)))   # [{'name': 'zhangsan', 'age': 20}]

# map 映射函数：map(lambda, 可迭代对象)，返回是 map 对象
# 案例：使用 map 函数给字典列表中每个用户信息后新增一个键
dict_list = [{'name': 'zhangsan', 'age': 20},
             {'name': 'lisi', 'age': 18},
             {'name': 'wangwu', 'age': 16}]
# {**d, 'birth': 2025-d['age'] 是一个字典解析式，复制原字典，将新的键值 map 映射到字典中
print(list(map(lambda d : {**d, 'birth': 2025-d['age']}, dict_list)))
# [{'name': 'zhangsan', 'age': 20, 'birth': 2005}, {'name': 'lisi', 'age': 18, 'birth': 2007}, {'name': 'wangwu', 'age': 16, 'birth': 2009}]

# any 某一个 | all 全部：any(可迭代对象)、all(可迭代对象)，判断迭代对象返回布尔值
# 案例：以 all 为例，使用 all 判断年龄有没有大于18岁的用户
print('没有成年的' if all(map(lambda d : d['age'] > 18, dict_list)) else '有成年的')   # 有成年的