Python基础（十六）——Lambda 表达式

1、Lambda 表达式是什么

lambda表达式其实就是Python的一个函数语法一样。所以也称为匿名函数。
所谓匿名函数，通俗地说就是没有名字的函数。
基本功能跟使用def所定义的python函数是一样的。
但是、和def所定义的区别是：

lambda表达式基本在一行以内就完整的表达了整个函数的运算逻辑。

我们直接看 和def的对应关系你就明白了。

2、和def所定义的python函数的区别

具体的，我们看一下def语句的函数定义与相应的lambda表达式之间的对应关系，你就能明白。

def 函数名(参数1, 参数2, ...):
    return 返回值

函数名 = lambda 参数1, 参数2, ...: 返回值

注意：Lambda 表达式中 lambda 在oython中是个关键字。

我们看实例：

# def定义的加法函数
def add_def(a, b=1):
    return a + b

# Lambda 表达式:定义的加法函数
# 这里为了区分方便阅读，函数名不太一致。
add_lambda = lambda a, b=1: a + b

实际的代码结果：

def add_def(a, b=1):
    return a + b

add_lambda = lambda a, b=1: a + b

print(add_def(4, 4))      # 8

print(add_def(4))         # 5

print(add_lambda(4, 4))   # 8

print(add_lambda(4))      # 5

对应关系你很清楚理解 Lambda 表达式是什么了。
现在我们看看 Lambda 表达式的定义。

3、Lambda 表达式的定义

lambda parameters: expression

• lambda：关键字
• parameters：参数列表，是可选的。参数列表的参数个数可以是零个或者多个，如果有多个，则用逗号分隔；其规则跟普通函数的规则一致，但不需要用括号。
• expression是一个估值表达式，这个表达式的估值结果就是lambda函数的返回值。expression不能包含分支或者循环（但可以是三目运算语句），也不能包含return或者yield语句。

所谓估值表达式，就是最终能被运算成一个值的表达，例如常量、变量、运算表达式、函数调用、列表切片，等等。

※关于【3、Lambda 表达式的定义】内容来自知乎作者：Python3基础：lambda表达式

虽然 Lambda 表达式 和def定义的函数 是一样的，但是Lambda 表达式 的使用是根据自己特点有限制的。
我们接下来看一下Lambda 表达式的特点。

3、Lambda 表达式的特点

1. 参数不受限，以接收任意多个参数 (包括可选参数)
   参数列表的参数个数可以是零个或者多个，如果有多个，则用逗号分隔；其规则跟普通函数的规则一致，但不需要用括号。

例：有四个参数，逗号隔开

add_lambda = lambda a, b, c=1, d=2: a + b + c + d

print(add_lambda(4, 4))           # 11

print(add_lambda(4, 4, 4, 4))     # 16

2. 功能简单。
   单行expression决定了lambda函数不可能完成复杂的逻辑，只能完成非常简单的功能。所有的函数逻辑必须一行之内完成。

3. 表达式有唯一性。
   lambda表达式只允许包含一个表达式，不能包含复杂语句，该表达式的运算结果就是函数的返回值。
   因为最终结果一定要被运算成一个值，例如常量、变量、运算表达式、函数调用、列表切片，等等。

也真因为第三个特点：最终结果一定要被运算成一个值。
因此基于这个特点，Lambda 表达式中可以包含三目运算语句，因为三目运算语句的结果就是一个值。

4、Lambda 表达式中用三目运算语句

关于三目运算语句请参照：三目运算语句

直接上代码：

get_odd_even = lambda x: '偶数' if x % 2 == 0 else '奇数'

print(get_odd_even(3))
# 奇数

print(get_odd_even(4))
# 偶数

等价以下语句：

def get_odd_even(x):
    if x % 2 == 0:
        str = "偶数"
    else:
        str = "奇数"
    return str

print(get_odd_even(3))
# 奇数

print(get_odd_even(4))
# 偶数

5、lambda的参数形式

5.1、Lambda 表达式直接调用。

直接看示例：

print((lambda a, b: a + b)(1, 2))    # 3

5.2、无参数

print((lambda: 100)())     # 100

5.3、一个参数

print((lambda a: a)('hello world'))    # hello world

5.3、默认参数

print((lambda a, b, c=100: a + b + c)(10, 20))    # 130

5.4、可变参数：**args

返回值是个元组。

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

5.5、可变参数：**kwargs

返回值是个字典。

print((lambda **kwargs: kwargs)(name='python', age=20))     # {'name': 'python', 'age': 20}

主要介绍 sorted()，sort()，max()，min()参数key中使用 Lambda 表达式。

6、排序中使用lambda表达式

6.1、列表排序（使用 Lambda 表达式）

6.1.1、列表排序（不指定 key）

TestList = ['Charle', 'Bob', 'Alice']

TestListSorted = sorted(TestList)

print(TestListSorted)
# ['Alice', 'Bob', 'Charle']

6.1.2、列表排序（指定 key）

本例：在参数key中指定返回字符数的内置函数 len()，从而按字符数降序排序。

TestList = ['Charle', 'Bob', 'Alice']

TestListSorted = sorted(TestList, key=len)

print(TestListSorted)
# ['Bob', 'Alice', 'Charle']

6.1.3、列表排序

这时我们把 key 执行成 Lambda 表达式。可以将任意函数应用于各元素，并根据其结果进行排序。
例如，当将用于获取第二个字符的lambda表达式【lambda x: x[1]】指定为key时，按照第二个字符的字母顺序进行排序。
下面示例可以看的更清楚：
1、首先我们要知道：

lambda x: x[0]

是在取列表各个元素对应下标的值。

print((lambda x: x[0])([1, 2, 3]))     # 1
print((lambda x: x[1])([1, 2, 3]))     # 2
print((lambda x: x[2])([1, 2, 3]))     # 3

print((lambda x: x[0])('ABC'))         # A
print((lambda x: x[1])('ABC'))         # B
print((lambda x: x[2])('ABC'))         # C

2、所以我们直接看例子：

TestList = ['CEG', 'BFH', 'ADI']

# 以列表中列表的第一个字母排序
print(sorted(TestList, key=lambda x: x[0]))
# ['ADI', 'BFH', 'CEG']

# 以列表中列表的第二个字母排序
print(sorted(TestList, key=lambda x: x[1]))
# ['ADI', 'CEG', 'BFH']

# 以列表中列表的第三个字母排序
print(sorted(TestList, key=lambda x: x[2]))
# ['CEG', 'BFH', 'ADI']

6.1.4、列表内嵌套列表排序（使用 Lambda 表达式）。

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

# 以列表中列表的第一个数排序
print(sorted(Testlist, key=lambda x: x[0]))
# [[1, 5, 6], [4, 2, 9], [7, 8, 3]]

# 以列表中列表的第二个数排序
print(sorted(Testlist, key=lambda x: x[1]))
# [[4, 2, 9], [1, 5, 6], [7, 8, 3]]

# 以列表中列表的第三个数排序
print(sorted(Testlist, key=lambda x: x[2]))
# [[7, 8, 3], [1, 5, 6], [4, 2, 9]]

# 以列表中列表的第一个数排序，且降序
print(sorted(Testlist, key=lambda x: x[0], reverse=True))
# [[7, 8, 3], [4, 2, 9], [1, 5, 6]]

6.2、字典排序

6.2.1、字典排序（键（key）排序）

dict = {'c': 1, 'b': 2, 'a': 3}

print(sorted(dict))
# ['a', 'b', 'c']

print(sorted(dict, reverse=True))
# ['c', 'b', 'a']

6.2.2、字典排序（值（value）排序）（使用 Lambda 表达式）

dict = {'c': 1, 'b': 2, 'a': 3}

print(sorted(dict, key=lambda x: dict[x]))
# ['c', 'b', 'a']

print(sorted(dict, key=lambda x: dict[x], reverse=True))
# ['a', 'b', 'c']

6.2.3、字典内嵌套字典排序（使用 Lambda 表达式）

dict = {
        'a': {'x': 3, 'y': 2, 'z': 1},
        'b': {'x': 2, 'y': 1, 'z': 3},
        'c': {'x': 1, 'y': 3, 'z': 2}
        }

# 以内部字典的'x'对应的值排序
print(sorted(dict, key=lambda x: dict[x]['x']))
# ['c', 'b', 'a']

# 以内部字典的'y'对应的值排序
print(sorted(dict, key=lambda x: dict[x]['y']))
# ['b', 'a', 'c']

# 以内部字典的'z'对应的值排序
print(sorted(dict, key=lambda x: dict[x]['z']))
# ['a', 'c', 'b']

# 以内部字典的'x'对应的值排序,并降序
print(sorted(dict, key=lambda x: dict[x]['x'], reverse=True))
# ['a', 'b', 'c']

7、lambda表达式作为map ()的第一参数

list = [0, 1, 2, 3]

map_square = map(lambda x: x**2, list)

print(map_square)
# 

print(list(map_square))
# [0, 1, 4, 9]

等同于以下语句：

list = [0, 1, 2, 3]

l_square = [x**2 for x in list]

print(l_square)
# [0, 1, 4, 9]

8、lambda表达式作为filter ()的第一参数

list = [0, 1, 2, 3]

filter_even = filter(lambda x: x % 2 == 0, list)

print(list(filter_even))
# [0, 2]

等同于：

list = [0, 1, 2, 3]

l_even = [x for x in list if x % 2 == 0]

print(l_even)
# [0, 2]

如果有问题，请指出，或者copy了谁的，也请指出。
会及时更正。