lambda 表达式（也叫 lambda 函数）又叫匿名函数，就是说函数没有具体的名称。如果一个函数有一个返回值，且只有一句代码，可以使用 lambda 简化。

使用 lambda 表达式可以省去定义函数的过程，让代码更加简洁，不需要考虑函数命名问题，节省内存空间。

如果我们在短时间内需要一个函数，比如说想要将某个函数作为参数传给其他函数（即高阶函数）时，可以选择使用 lambda 函数。

lambda 表达式语法

语法格式：

lambda [参数列表]: 表达式

# 表达式只能有一个，且必须有返回值

1）参数列表 —– lambda 表达式的参数可有可无，和 def 定义函数时书写的参数是一样的。

2）表达式 —– 条件表达式或知悉表达式，它只能有一个，该表达式的计算结果就是函数的返回值。

注意：lambda 表达式可以接收任何数量的参数但是只能返回一个表达式的值。

例如：求任意两个数的和。

# 函数有一个返回值，且只有一句代码，可以使用lambda表达式实现
def add(x,y):
    return x+y

print(add(10,20))

上面的求和函数 add 只有一句代码，且只有一个返回值，像这样的就可以使用 lambda 表达式去简化上面的代码。

lambda 可以直接赋给一个变量，使用的时候像一般函数那样调用即可。

# 使用lambda表达式实现，sum1相当于给这个匿名函数取了一个别名
sum1 = lambda x,y: x+y    # x,y是参数列表；x+y是表达式，它只有一个返回值。

# 直接输出的是lambda的内存地址
print(sum1)   # <function <lambda> at 0x00000227B506B1C0>

# lambda是一个匿名函数，要得到它的返回值，可以调用这个函数
print(sum1(10,20))   # 30

注意：lambda 表达式直接打印得到的是 lambda 的内存地址。而 lambda 是一个匿名函数，要想得到它的返回值，就要调用函数。

lambda 表达式的参数形式

1）无参数

语法格式：lambda :表达式

fun1 = lambda :100
print(fun1())   # 100

输出结果：100

2）一个参数

语法格式： lambda 参数:表达式

fun2 = lambda a:a*2
print(fun2(5))  # 10

输出结果：10

3）默认参数（缺省参数）

语法格式： lambda key=value:表达式

# 参数c有一个默认值100
fun3 = lambda a,b,c=100: a+b+c

# 如果不给默认参数传值，则使用默认参数原有的值：即10+20+100
print(fun3(10,20))  # 130

# 如果给默认参数传值，则覆盖默认参数原有的值：即10+20+30
print(fun3(10,20,30))   # 60

4）个数可变的位置参数

语法格式： lambda *args:表达式

返回的是一个元组。

fun4 = lambda *args:args
print(fun4(10,20,30,40))    # (10, 20, 30, 40)
print(fun4(10,20))    # (10, 20)

5）个数可变的关键字参数

语法格式：lambda **kargs:表达式

返回的是一个字典。

fun5 = lambda **kargs: kargs

print(fun5(a = 10, b = 20)) # {'a': 10, 'b': 20}

print(fun5(name = '张三',age = 20,iphone = 13356789098))  # {'name': '张三', 'age': 20, 'iphone': 13356789098}

实例1：比较两个数的大小

fun6 = lambda a,b:a if a>b else b

print(fun6(100,200))    # 200

输出结果：200

lambda 表达式和高阶函数搭配使用

lambda 函数和高阶函数搭配使用时，通常是把 lambda 函数作为参数传入。

1）lambda 函数和 sort()/sorted() 结合使用

实例2：按照字典 key 的值给列表排序。

students = [
    {'name': 'Tom', 'age': 20},
    {'name': 'Alice', 'age': 21},
    {'name': 'Job', 'age': 19}
]

# key这个参数是用来指定排序标准的函数
students.sort(key=lambda x:x['name'])     # 升序
print(students)

# students.sort(key=lambda x:x['name'],reverse=True)  # 降序
new_stu = sorted(students,key=lambda x:x['name'],reverse=True)
print(new_stu)

students.sort(key=lambda x:x['age'])
print(students)

2）lambda 函数和 filter 过滤器结合使用

实例3：过滤掉列表中的偶数。

lst = [1,12,13,54,21,56,32]

# 使用lambda表达式
new_lst1 = filter(lambda x : x%2, lst)

print(list(new_lst1))

输出结果：[1, 13, 21]

3）lambda 函数和 map() —> 根据提供的函数对指定的序列做映射

lst1 = map(lambda x:x**2,range(10))

print(list(lst1))   # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

输出结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

上面的代码是将 range(10)，也就是 [0,1,2,3,4,5,6,7,8,9] 中的每一个元素都做 2 次幂处理。

4）lambda 函数和 reduce()

from functools import reduce

result = reduce(lambda x,y: x*y,range(1,6))
print(result)

输出结果：120

上面的代码是首先将 [1,2,3,4,5] 中的第1、2个元素，也就是 1 和 2 传入 lambda 函数中进行计算，再将他们计算的结果 2 （1*2）和第 3 个元素 3，一起传入 lambda 函数中进行计算（2*3），以此类推，最后将计算的结果返回。

注意：在 python 3.x 中，reduce() 被移到了 functools 模块中，要使用它，需要导入 functools 模块，然后调用 reduce() 函数。