【Python】推导式（列表推导式、元组推导式、字典推导式、集合推导式）详解

爱被打了一巴掌 2022-08-30 14:55 21阅读 0赞

### 列表推导式、元组推导式、字典推导式、集合推导式 ###

*  列表推导式
 *  元组推导式
 *  字典推导式
 *  集合推导式

`推导式（又称解析器）`，是 Python 独有的一种特性。

使用推导式可以快速生成列表、元组、字典以及集合类型的数据，因此推导式又可细分为列表推导式、元组推导式、字典推导式以及集合推导式。

# 列表推导式 #

列表推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的列表。

列表推导式的语法格式如下：

[表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] ]

此格式中，`[if 条件表达式]` 不是必须的，可以使用，也可以省略。

通过列表推导式的语法格式，明显会感觉到它和 for 循环存在某些关联。

其实，除去 `[if 条件表达式]` 部分，其余各部分的含义以及执行顺序和 for 循环是完全一样的（表达式其实就是 for 循环中的循环体），即它的执行顺序如下所示：

for 迭代变量 in 可迭代对象
        表达式

可以这样认为，它只是对 for 循环语句的格式做了一下简单的变形，并用 `[]` 括起来而已，只不过最大的不同之处在于，列表推导式最终会将循环过程中，计算表达式得到的一系列值组成一个列表。

a_range = range(10)
    # 对a_range执行for表达式
    a_list = [x * x for x in a_range]
    # a_list集合包含10个元素
    print(a_list)
    
    输出结果：
    [0 , 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64, 81]

上面代码的第 3 行会对 a\_range 执行迭代，由于 a\_range 相当于包含 10 个元素，因此程序生成的 a\_list 同样包含 10 个元素，且每个元素都是 a\_range 中每个元素的平方（由表达式 `x * x` 控制）。

不仅如此，我们还可以在列表推导式中`添加 if 条件`语句，这样列表推导式将只迭代那些符合条件的元素。例如：

b_list = [x * x for x in a_range if x % 2 == 0]
    # a_list集合包含5个元素
    print(b_list)
    
    输出结果：
    [0 ,4 , 16, 36, 64]

这里给列表推导式增加了 if 条件语句，这会导致推导式只处理 range 区间的偶数，因此程序生成的 b\_list 只包含 5 个元素。

另外，以上所看到的列表推导式都只有一个循环，实际上它可使用多个循环，就像嵌套循环一样。例如如下代码：

d_list = [(x, y) for x in range(5) for y in range(4)]
    # d_list列表包含20个元素
    print(d_list)

上面代码中，x 是遍历 range(5) 的迭代变量（计数器），因此该 x 可迭代 5 次；y 是遍历 range(4) 的计数器，因此该 y 可迭代 4 次。因此，该（x,y）表达式一共会迭代 20 次。上面的 for 表达式相当于如下嵌套循环：

dd_list = []
    for x in range(5):
        for y in range(4):
            dd_list.append((x, y))
    
    输出结果：
    [(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)]

当然，也支持类似于三层嵌套的 for 表达式，例如如下代码：

e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)]
    # e_list列表包含120个元素
    print(e_list)

对于包含多个循环的 for 表达式，同样可指定 if 条件。

假如我们有一个需求：

*  程序要将两个列表中的数值按“`能否整除`”的关系配对在一起。
 *  比如 src\_a 列表中包含 30，src\_b 列表中包含 5，其中 30 可以整除 5，那么就将 30 和 5 配对在一起。对于上面的需求使用 for 表达式来实现非常简单，例如如下代码：

src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121]
    src_b = [3, 5, 7, 11]
    # 只要x能整除y，就将它们配对在一起
    result = [(x, y) for x in src_a for y in src_b if x % y == 0]
    print(result)
    
    输出结果：
    [(30, 3), (30, 5), (12, 3), (66, 3), (66, 11), (39, 3), (78, 3), (36, 3), (57, 3), (121, 11)]

# 元组推导式 #

元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。

元组推导式的语法格式如下：

(表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] )

其中，用 \[\] 括起来的部分，可以使用，也可以省略。

通过和列表推导式做对比，你会发现，除了`元组推导式是用 () 圆括号`将各部分括起来，而`列表推导式用的是 []`，其它完全相同。不仅如此，元组推导式和列表推导式的用法也完全相同。

例如，我们可以使用下面的代码生成一个包含数字 1~9 的元组：

a = (x for x in range(1,10))
    print(a)
    
    输出结果：
    <generator object <genexpr> at 0x000001C6E5F97748>

从上面的执行结果可以看出，使用元组推导式生成的结果并不是一个元组，而是一个生成器对象，这一点和列表推导式是不同的。

如果我们想要使用元组推导式获得新元组或新元组中的元素，有以下三种方式：

1.  使用 tuple() 函数，可以直接将生成器对象转换成元组，例如：

a = (x for x in range(1,10))
    print(tuple(a))
    
    运行结果为：
    (1, 2, 3, 4, 5, 6, 7, 8, 9)

1.  直接使用 for 循环遍历生成器对象，可以获得各个元素，例如：

a = (x for x in range(1,10))
    for i in a:
        print(i,end=' ')
    print(tuple(a))
    
    输出结果：
    1 2 3 4 5 6 7 8 9 ()

1.  使用 `__next__()` 方法遍历生成器对象，也可以获得各个元素，例如：

a = (x for x in range(3))
    print(a.__next__())
    print(a.__next__())
    print(a.__next__())
    a = tuple(a)
    print("转换后的元组：",a)
    
    输出结果：
    0
    1
    2
    转换后的元组： ()

注意，无论是使用 `for 循环`遍历生成器对象，还是使用 `__next__()` 方法遍历生成器对象，遍历后原生成器对象将不复存在，这就是遍历后转换原生成器对象却得到空元组的原因。

# 字典推导式 #

Python 中，使用字典推导式可以借助列表、元组、字典、集合以及 range 区间，快速生成符合需求的字典。

字典推导式的语法格式如下：

{
        表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}

可以看到，和其它推导式的语法格式相比，唯一不同在于，字典推导式用的是`大括号{}`。

listdemo = ['Jack','Tom']
    #将列表中各字符串值为键，各字符串的长度为值，组成键值对
    newdict = {
        key:len(key) for key in listdemo}
    print(newdict)
    
    输出结果：
    {
        'Jack': 4, 'Tom': 3}

交换现有字典中各键值对的键和值。

olddict={
        'Jack': 4, 'Tom': 3}
    newdict = {
        v: k for k, v in olddict.items()}
    print(newdict)
    
    输出结果：
    {
        4: 'Jack', 3: 'Tom'}

使用 if 表达式筛选符合条件的键值对。

olddict={
        'Jack': 4, 'Tom': 3}
    newdict = {
        v: k for k, v in olddict.items() if v>3}
    print(newdict)
    
    输出结果：
    {
        4: 'Jack'}

# 集合推导式 #

集合推导式的语法格式和字典推导式完全相同，如下所示：

{
         表达式 for 迭代变量 in 可迭代对象 [if 条件表达式] }

集合推导式和字典推导式的格式完全相同，那么给定一个类似的推导式，如何判断是哪种推导式呢？

最简单直接的方式，就是根据表达式进行判断，如果表达式以键值对（`key：value`）的形式，则证明此推导式是字典推导式；反之，则是集合推导式。

setnew = {
        i**2 for i in range(3)}
    print(setnew)
    
    输出结果：
    {
        0, 1, 4}

既然生成的是集合，那么其保存的元素必须是唯一的。

tupledemo = (1,1,2,3,4,5,6,6)
    setnew = {
        x**2 for x in tupledemo if x%2==0}
    print(setnew)
    
    输出结果：
    {
        16, 4, 36}

dictdemo = {
        '1':1,'2':2,'3':3}
    setnew = {
        x for x in dictdemo.keys()}
    print(setnew)
    
    输出结果：
    {
        '2', '1', '3'}