Skip to main content

推导式

列表推导式​

列表推导式（List Comprehension）是 Python 中创建列表的简洁、可读的方式。它基于已有的可迭代对象（例如列表、元组、集合等）生成一个新列表。列表推导式通常更加简洁、明确。在多数其它语言中，创建一个复杂列表的唯一方法是使用循环或递归，但是在 Python 语言中，列表推导式是更好的方法。

列表推导式的基本格式如下： [expression for item in iterable if condition]，其中：

  • expression： 对当前元素的操作；
  • item： 当前迭代到的元素；
  • iterable： 要迭代的对象；
  • condition： 过滤条件（可选）。

以下是一些既精巧又实用的列表推导式示例：

基本用法​

创建一个新列表，其中包含 0 到 9 的平方。这需要使用 for 循环，遍历 0 到 9：

squares = [x**2 for x in range(10)]
print(squares)  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

在上面这段代码中： range(10) 是一个内置函数，用于生成一个包含 0 到 9 的整数序列。x**2 for x in range(10) 是列表推导式的核心部分，它表示对 range(10) 生成的每个元素 x，计算其平方 （x**2）。最外层的方括号表示将这个推导式的结果放入一个列表中。

过滤条件​

在上面程序的基础上，只保留偶数的平方。这需要使用关键字 if 添加过滤条件：

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 输出: [0, 4, 16, 36, 64]

多维列表​

生成一个乘法表，需要使用到嵌套的推导式生成二维列表：

multiplication_table = [[i * j for j in range(1, 10)] for i in range(1, 10)]
for row in multiplication_table:
    print(row)

上面的乘法表打印出来只有结果，我们可以使用字符串格式化表达式，把生成结果整理一下，把整个乘法表达式都打印出来：

print('\n'.join([' '.join(['%s*%s=%-2s' % (j, i, i * j) for j in range(1, i + 1)]) for i in range(1, 10)]))

程序运行结果如下：

1*1=1 
1*2=2  2*2=4 
1*3=3  2*3=6  3*3=9 
1*4=4  2*4=8  3*4=12 4*4=16
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

二维数组进行转置操作：

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

transpose = [[row[i] for row in matrix] for i in range(len(matrix[0]))]

print(transpose)

''' 输出：
[
    [1, 4, 7],
    [2, 5, 8],
    [3, 6, 9]
]
'''

多重循环​

上面的示例都是比较直观的，容易理解。相比之下，在列表推导式中使用嵌套循环需要稍微费一些脑筋，它虽然运行了多重循环，但并没有生成多维列表，而是把所有结果顺序放在了一维列表中。

排列组合：

a = ['a', 'b', 'c']
b = [1, 2, 3]
combinations = [(x, y) for x in a for y in b]
print(combinations)  # 输出: [('a', 1), ('a', 2), ('a', 3), ('b', 1), ('b', 2), ('b', 3), ('c', 1), ('c', 2), ('c', 3)]

二维列表平展为一维的操作：

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

flattened = [item for sublist in matrix for item in sublist]

print(flattened)  # 输出： [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用循环实现同样的功能，需要下面四行代码：
flattened = []
for sublist in matrix:
    for item in sublist:
        flattened.append(item)

配合切片操作，同样可以把一维列表转换成二维：

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

rows = 2  # 目标行数
cols = 5  # 目标列数

# 使用列表推导式转换为二维列表
two_dim_list = [lst[i * cols:(i + 1) * cols] for i in range(rows)]

print(two_dim_list)

从上面的示例可以看出，使用列表推导式对列表进行操作，比使用循环要简洁的多。但也需要注意，在生成大量数据时可能消耗大量内存，因为它会返回一个新列表。在这种情况下，使用生成器表达式（使用圆括号而不是方括号）可能更为合适。

复杂的列表推导式​

列表推导式的优点是代码简介。但是过于复杂的列表推导式可能会比较难以读懂，代码写的太简介的确也增加理解难度，这就好比古文比白话文难懂一样。当推导式变得复杂时，可以考虑使用传统的循环结构。下面给出一些比较复杂的列表推导式，Pythora 星球一般不会在产品中使用过于复杂列表推导式，但作为学习，理解它们可以帮助熟练掌握 Python 语言。

生成 100 以内的素数​

print([i for i in range(2, 100) if all(i % j != 0 for j in range(2, int(i ** 0.5) + 1))])

上面程序使用了一个 all 函数，它用于检查可迭代对象中的所有元素是否都为真值。如果可迭代对象中的值都为真，或可迭代对象为空，all 函数会返回 True。比如：

conditions = [True, True, False]
print(all(conditions))  # 输出：False

numbers = [1, 2, 3, 4]
print(all(n > 0 for n in numbers))  # 输出：True

与之类似的还有一个 any 函数，用于检查可迭代对象中是否至少有一个元素为真值。

生成前 30 个斐波那契数​

print([x[0] for x in [(y[i][0], y.append((y[i][1], y[i][0] + y[i][1]))) for y in [[[1,1]]] for i in range(30)]])

生成集合的幂集​

所谓幂集，是原集合中所有的子集（包括全集和空集）构成的集合，比如集合 {1,2} 的幂集是 {{}, {1}, {2}, {1,2}}。Python 中集合的元素只能是不可变数据，所以集合不能作为另一个集合的元素，但我们可以用一个元素为集合的列表表示最终结果：

s = {1,2,3}
print(([c.extend([b | {a} for b in c]) or c for c in [[set()]] for a in s] or [[set()]])[0])

# 输出： [set(), {1}, {2}, {1, 2}, {3}, {1, 3}, {2, 3}, {1, 2, 3}]

字典推导式​

基本用法​

与列表推导式类似，字典推导式可以创建字典。字典推导式的基本格式：

{key_expr: value_expr for item in iterable}

与列表推导式的区别在于，字典推导式中要提供两个数据：键和值。

下面的简单例子，将一个列表的值映射为其平方：

numbers = [1, 2, 3, 4, 5]
squared = {x: x**2 for x in numbers}
print(squared)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

下面示例是对已有字典中的数据做修改，然后生成新字典：

fruits = {'苹果': 0.5, '香蕉': 0.25, '桔子': 0.75}
discounted_price = {fruit: price * 0.9 for fruit, price in fruits.items()}
print(discounted_price)  # 输出：{'苹果': 0.45, '香蕉': 0.225, '桔子': 0.675}

过滤条件​

字典推导式也可以添加条件语句来过滤出符合条件的元素：

numbers = [1, 2, 3, 4, 5]
even_squares = {x: x**2 for x in numbers if x % 2 == 0}
print(even_squares)  # 输出：{2: 4, 4: 16}

多个可迭代对象​

通过使用 zip，可以将多个不同的可迭代对象换为一个字典：

keys = ['a', 'b', 'c']
values = [1, 2, 3]
dictionary = {k: v for k, v in zip(keys, values)}
print(dictionary)  # 输出：{'a': 1, 'b': 2, 'c': 3}

多重循环：​

可以在字典推导式中使用多个循环,比如生成一个以字典格式存储的乘法表：

product_dict = {(i, j): i*j for i in range(1, 5) for j in range(1, 5)}

print(product_dict)

赋值表达式​

基本用法​

赋值表达式（Assignment Expression）使用运算符 := 来为变量赋值。它也被你称为“海象运算符”，因为它看起来就像是海象的眼睛和大牙。与 Python 中的赋值语句（使用等号，比如 a = 5）相比，赋值语句是一个“语句”，它不能出现在需要表达式的地方，比如在 if 或 while 语句的条件中，或者作为其他表达式的一部分。但赋值表达式，是一个表达式，它可以出现在任何使用表达式的地方。

海象运算符可以避免重复运算，提高代码的简洁性。比如，在不使用海象运算符的情况下，如果一个值在逻辑判断和后续代码中都要使用，那么通常需要分两步写：先计算一次赋值给变量，然后在逻辑判断和后续代码中使用这个变量。海象运算符允许在逻辑判断中进行赋值，并在后续代码中直接使用这个赋值结果。

比如在 while 循环中：

# 不使用海象运算符：
line = input("请输入文字：")
while line != "结束":
    print(f'您输入的内容是：{line}')
    line = input("请输入文字：")
    

# 使用海象运算符：
while (line := input("请输入文字：")) != "结束":
    print(f'您输入的内容是：{line}')

因为列表推导式一般希望写的简洁，不希望创建额外变量，所以海象运算符在列表推导式中更有用：

# 不使用海象运算符， complicated_function 被调用两遍
results = [complicated_function(x) for x in data if complicated_function(x) > 0]


# 使用海象运算符， complicated_function 只会被调用一次
results = [y for x in data if (y := complicated_function(x)) > 0]

更具体一些的例子，比如要计算列表中每个元素的平方，但只保留那些结果大于 5 的平方值，使用海象运算符可以只计算一次平方：

numbers = [1, 2, 3, 4, 5]
squares = [square for x in numbers if (square := x*x) > 5]

注意事项​

海象运算符很容易破坏程序的可读性，因为它经常要和其它的运算符一起使用，很容易搞不清楚不同运算符的优先级。尤其是它与赋值表达式长得太像了，很容易让人不自觉的把赋值表达式的规则套用上来。为了提高程序可读性，可以在所有使用海象运算符的地方都用括号套起来，这样就容易区分计算的优先级了。下面看几个例子，大家可以先猜测一下程序输出是什么：

if x := 5 == 5:
    print(x)

输出是 True，因为 == 比 := 的优先级更高。这里如果把程序写成 if (x := 5) == 5: 或者 if x := (5 == 5): 就容易理解了。

在看一个例子：

x, y = 1, 2
(x, y := 3, 4)
print(y)

输出是 3，因为 := 比 , 的优先级更高。清晰的代码应该这样写： (x, (y := 3), 4) 或者 (x, y := (3, 4))。但是不能写成 ((x, y) := (3, 4))，因为海象运算符不支持自动解包。