一行挑出一堆新东西:Python 推导式与生成器
推导式先说要什么,生成器一次只吐一个。本文按 Python 官方教程第 5 章与第 9 章讲清楚:列表、字典、集合推导式,双重 for 与嵌套推导式,* 解包,yield 与生成器函数,生成器表达式,以及列表和生成器怎么选,另附虚构晨光书店记账脚本第六个月 100 次翻车的分布。

先把这篇的边界说清楚。这是「Python 基础」系列第六篇,接着前五篇往下走:第一篇讲了变量、类型和流程控制,第二篇讲了函数与模块,第三篇讲了类与继承,第四篇讲了异常处理,第五篇讲了文件读写。这篇讲列表推导式和生成器:把「从一堆东西里挑出、算出一堆新东西」写成一行,以及「一次只吐一个、现用现算」的办法。下面用到的「晨光书店」还是那个虚构的练手项目:一家街边小书店,店主的记账小脚本已经会算库存、会打折、会用类管书、会接住异常、会把账存进文件了。这篇要解决的新问题是:进货单读进来是一堆字典,挑出「库存不够 10 本的书」、算出「每本书打折后的价」,不用先建空列表、再循环 append() 写五六行,一行就写完。所有关于推导式与生成器的说法,都来自 Python 官方教程第 5 章《Data Structures》和第 9 章《Classes》的 9.9、9.10 两节,来源见每篇的 meta 信息与 evidence 记录;本文所有以晨光书店为例的操作、代码和数字,都是为了讲清楚做法编出来的,不是真实记录。读完这篇,你应该能做到五件事:会写带 if 过滤的列表推导式;会写双重 for、嵌套推导式,知道什么时候该停手;会写字典推导式和集合推导式;会写带 yield 的生成器函数,知道它和普通函数的区别;会用生成器表达式给 sum()、max() 现算现用。与第一篇的划界是:第一篇只提了一句「列表推导式」和「字典推导式」的名字、给了一个库存总价值的例子,没有讲语法、没有讲 if 过滤、没有讲生成器;这篇把完整语法和生成器一次讲透。与第三篇的划界是:第三篇用类写过 __iter__ 和 __next__ 的迭代器,这篇的生成器是同一件事的短写法,不重讲迭代器协议。
第一步:列表推导式——先建空列表再循环的短写法
官方教程 5.1.3 节说,列表推导式提供了一种简洁的办法来创建列表。最常见的用途是:把一个序列里的每个成员都算一遍,得到一个新列表;或者从中挑出满足某个条件的成员,组成一个子列表。官方例子是先算 0 到 9 的平方:
>>> squares = []
>>> for x in range(10):
... squares.append(x**2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
注意这段代码建了一个叫 x 的变量,循环跑完之后 x 还留在那里。官方说,不用任何副作用也能算出这张平方表:
squares = list(map(lambda x: x**2, range(10)))
或者等价地:
squares = [x**2 for x in range(10)]
官方的评价是:推导式更简洁、更易读。一个列表推导式由方括号组成,里面先写一个表达式,再跟一个 for 子句,然后是零个或多个 for 或 if 子句;结果是一个新列表,是在后面这些 for 和 if 子句的语境里求表达式的值得到的。书店的版本:库存总价值不用循环加了,第一篇那个例子的一行写法就是推导式:
books = [('三体', 59.0, 7), ('海底两万里', 39.5, 12), ('活着', 29.0, 5)]
totals = [price * stock for title, price, stock in books]
# totals 是 [413.0, 474.0, 145.0]
total = sum(totals) # 1032.0
三本书的库存价值分别是 413.0、474.0、145.0,加起来 1032.0,和第五篇手算、文件算的结果一致。推导式里的 title, price, stock 是在循环里顺手解包的,每行一个元组,拆开直接用。我的判断是:推导式不是「炫技的简写」,它是「把意图写在最前面」的写法——先写「要什么」,再写「从哪来、要满足什么条件」,读代码的人第一眼就知道这一行要产出什么。
第二步:加个 if——过滤,表达式里还能调函数
推导式后面可以跟 if 子句,只留下满足条件的成员。官方例子用了一个带负数的列表:
>>> vec = [-4, -2, 0, 2, 4]
>>> # create a new list with the values doubled
>>> [x*2 for x in vec]
[-8, -4, 0, 4, 8]
>>> # filter the list to exclude negative numbers
>>> [x for x in vec if x >= 0]
[0, 2, 4]
>>> # apply a function to all the elements
>>> [abs(x) for x in vec]
[4, 2, 0, 2, 4]
>>> # call a method on each element
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
表达式里可以放函数调用,也可以放方法调用:abs(x) 是对每个元素调函数,weapon.strip() 是对每个元素调方法。注意 freshfruit 那个例子里循环变量叫 weapon,是官方教程原文里就这么写的——变量名和内容对不上,但代码照样跑,算是个提醒:循环变量的名字要起得让人看懂,别学这个例子。书店的版本:挑出库存不够 10 本的书,再算每本打九折后的价:
books = [('三体', 59.0, 7), ('海底两万里', 39.5, 12), ('活着', 29.0, 5)]
low_stock = [title for title, price, stock in books if stock < 10]
# low_stock 是 ['三体', '活着']
discounted = [round(price * 0.9, 2) for title, price, stock in books if price > 50]
# discounted 是 [53.1],只有三体单价超过 50 元
titles = [title.strip() for title, price, stock in books]
# titles 是 ['三体', '海底两万里', '活着']
7 本的三体和 5 本的活着库存不够 10 本,12 本的海底两万里够了;单价超过 50 元的只有 59.0 元的三体,打九折是 53.1 元。我的判断是:if 写在推导式里,读法是「要这样的东西,从这里来,但只要满足这个条件的」——条件越具体,挑出来的东西越准;但一个推导式里别放两个以上的条件,条件多了就拆成两步写。
第三步:双重 for 与嵌套推导式——先会读,再决定用不用
推导式里可以有两个 for 子句。官方例子是把两个列表的元素两两配对,只要不相等的:
>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
它等价于两层循环加 append():
>>> combs = []
>>> for x in [1,2,3]:
... for y in [3,1,4]:
... if x != y:
... combs.append((x, y))
...
>>> combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
官方提醒:for 和 if 的顺序在两种写法里是一样的——先写哪个循环,后写哪个循环,推导式里就是这个顺序。如果表达式本身是个元组,比如这里的 (x, y),必须加括号;不加括号会报语法错误:
>>> [(x, x**2) for x in range(6)]
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]
>>> [x, x**2 for x in range(6)]
File "<stdin>", line 1
[x, x**2 for x in range(6)]
^^^^^^^
SyntaxError: did you forget parentheses around the comprehension target?
两个 for 还能把嵌套的列表拍平:
>>> vec = [[1,2,3], [4,5,6], [7,8,9]]
>>> [num for elem in vec for num in elem]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
推导式的开头表达式本身还可以是另一个推导式,这就是嵌套推导式。官方例子是把一个 3 行 4 列的矩阵转置:
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
内层推导式在外层 for 的语境里求值,整个式子等价于先循环列、再循环行。官方还补了一句实在话:现实里应该优先用内置函数,复杂的流程语句能不用就不用——这个转置用 zip() 写更合适:
>>> list(zip(*matrix))
[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]
书店的版本:进货单按类别分了三组,每组一个列表,拍平成一张总清单:
groups = [['三体', '海底两万里'], ['活着'], ['三体', '活着']]
all_titles = [title for group in groups for title in group]
# all_titles 是 ['三体', '海底两万里', '活着', '三体', '活着'],共 5 个
pairs = [(title, price) for title, price, stock in
[('三体', 59.0, 7), ('海底两万里', 39.5, 12)]]
# pairs 是 [('三体', 59.0), ('海底两万里', 39.5)]
我的判断是:双重 for 的推导式,读法是「外层循环在前、内层循环在后」,和写两层循环的顺序一模一样;嵌套推导式能看懂就行,别当成日常写法——超过两层,或者一行超过 80 个字符,就拆成普通循环,官方教程自己都说该用 zip() 的时候用 zip()。
第四步:字典推导式与集合推导式——换个括号,换种产出
推导式的括号换一换,产出的东西就换了。字典推导式用大括号加冒号,官方例子:
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
集合推导式用大括号、不带冒号,官方例子:
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
'abracadabra' 里去掉 a、b、c 之后剩下的不同字母只有 r 和 d,集合自动去重。注意一个空集合不能写 {}——那是空字典,空集合得写 set(),这是第 5 章 5.4 节的原话。字典还能用 ** 解包拼起来:
>>> odds = {i: i**2 for i in (1, 3, 5)}
>>> evens = {i: i**2 for i in (2, 4, 6)}
>>> {**odds, **evens}
{1: 1, 3: 9, 5: 25, 2: 4, 4: 16, 6: 36}
书店的版本:书名到单价的字典、书名到打折价的字典、所有出现过的书名集合:
books = [('三体', 59.0, 7), ('海底两万里', 39.5, 12), ('活着', 29.0, 5)]
prices = {title: price for title, price, stock in books}
# prices 是 {'三体': 59.0, '海底两万里': 39.5, '活着': 29.0}
sale_prices = {title: round(price * 0.9, 2) for title, price, stock in books if price > 50}
# sale_prices 是 {'三体': 53.1}
groups = [['三体', '海底两万里'], ['活着'], ['三体', '活着']]
seen = {title for group in groups for title in group}
# seen 是 {'三体', '海底两万里', '活着'},三体出现两次也只留一个
我的判断是:三种推导式记住一个对应关系就行——方括号产列表、大括号加冒号产字典、大括号不加冒号产集合;表达式和 for/if 的写法三者完全一样,学会一种就等于学会三种。字典推导式还有个特点:键重复了,后面的值会盖掉前面的,和直接给字典赋值是一样的规矩。
第五步:* 解包——能进列表,推导式里要看版本
官方教程 5.1.5 节讲了 * 解包:写在表达式前面,会把一个可迭代对象拆开,一个个放进正在建的列表里:
>>> x = [1, 2, 3]
>>> [0, *x, 4, 5, 6]
[0, 1, 2, 3, 4, 5, 6]
* 后面跟的必须是可迭代对象,跟个整数会报错:
>>> x = 1
>>> [0, *x, 2, 3, 4]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
[0, *x, 2, 3, 4]
TypeError: Value after * must be an iterable, not int
解包还有个版本上的坑,得先说清楚。官方教程 5.1.5 节还给了推导式里用解包的写法:
>>> x = [[1, 2, 3], [4, 5, 6], [], [7], [8, 9]]
>>> [*element for element in x]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
但这段代码在本地 Python 3.12 上跑不起来,会报 SyntaxError: iterable unpacking cannot be used in comprehension——推导式里用 * 解包,是官方 3.15 文档里的写法,老版本不认。想把几组书单拼成一张总清单,用第三步的双重 for 写法,所有版本都通用:
groups = [['三体', '海底两万里'], ['活着'], ['三体', '活着']]
all_titles = [title for group in groups for title in group]
# all_titles 是 ['三体', '海底两万里', '活着', '三体', '活着'],共 5 个
列表字面量里的解包没有版本问题,拼书架的时候照常用:
shelf = ['三体', *['海底两万里', '活着'], '三体']
# shelf 是 ['三体', '海底两万里', '活着', '三体'],共 4 个
官方还提醒:解包对任意可迭代对象都管用,不只是列表——字符串、字典也会被拆开:
>>> x = [[1, 2, 3], 'cat', {'spam': 'eggs'}]
>>> [*element for element in x]
[1, 2, 3, 'c', 'a', 't', 'spam']
这段也是官方 3.15 文档里的写法,同样只在新版本上跑得起来;'cat' 被拆成三个字母,字典被拆开只剩键 'spam'。我的判断是:* 解包本身没有版本问题,放进推导式里才有——写代码的时候先想清楚运行的是哪个 Python 版本;不确定的时候,用双重 for 拼,两个版本都认。
第六步:生成器函数——yield 一次只吐一个
推导式一次把整个列表造出来;生成器反过来,一次只吐一个,用完了再算下一个。官方教程 9.9 节:生成器是创建迭代器的简单而强大的工具,写法和普通函数一样,只是在想返回数据的地方用 yield 语句。每调一次 next(),生成器就从上次停下的地方接着跑——它记得所有的数据值和上次执行到哪条语句。官方例子是倒着吐出一个字符串:
def reverse(data):
for index in range(len(data)-1, -1, -1):
yield data[index]
>>> for char in reverse('golf'):
... print(char)
...
f
l
o
g
关键区别是:调用 reverse('golf') 不会立刻跑函数体,它只造出一个生成器对象;真正开始跑,是第一次调 next() 或者第一次进循环的时候。生成器跑完的时候,会自动抛 StopIteration——第三篇讲迭代器的时候提过这个名字,for 循环就是靠它知道什么时候停。官方还说,生成器能做的事,用带 __iter__ 和 __next__ 的类也能做;生成器胜在简洁,是因为 __iter__() 和 __next__() 方法是自动生成的,局部变量和执行状态也会在调用之间自动保存下来。书店的版本:一次只吐一本在库的书,库存为零的跳过:
def in_stock_books(books):
"""一次吐一本在库的书:库存为零的跳过。"""
for title, price, stock in books:
if stock > 0:
yield title
books = [('三体', 59.0, 7), ('海底两万里', 39.5, 12), ('活着', 29.0, 0)]
gen = in_stock_books(books)
next(gen) # '三体'
next(gen) # '海底两万里'
next(gen) # 抛 StopIteration,活着库存为零被跳过了
list(in_stock_books(books)) # ['三体', '海底两万里']
活着库存是 0,本来有三本书,生成器只吐了两本。我的判断是:生成器函数的身体是「写起来像普通函数,跑起来像排队取号」——每次 next() 只往前走一步,走到 yield 就停下等着;想一口气全拿出来,包一层 list() 就行,但那样就丢了「一次只算一个」的好处。
第七步:生成器表达式——推导式的括号换成圆括号
有些简单的生成器可以写得更短:用和列表推导式类似的语法,只是方括号换成圆括号,这就是生成器表达式。官方教程 9.10 节说,生成器表达式是为「生成器马上就被外层函数用掉」的场合设计的;它比完整的生成器定义更简洁、但没那么灵活,比等价的列表推导式更省内存。官方例子:
>>> sum(i*i for i in range(10)) # sum of squares
285
>>> xvec = [10, 20, 30]
>>> yvec = [7, 5, 3]
>>> sum(x*y for x,y in zip(xvec, yvec)) # dot product
260
>>> data = 'golf'
>>> list(data[i] for i in range(len(data)-1, -1, -1))
['f', 'l', 'o', 'g']
0 到 9 的平方和是 285:0+1+4+9+16+25+36+49+64+81;点积是 260:10 乘 7 是 70,20 乘 5 是 100,30 乘 3 是 90,加起来 260。注意括号的规矩:大多数情况下生成器表达式必须包在圆括号里;但作为函数的唯一参数传进去的时候(比如上面 sum()、list() 里的写法),不用再套一层括号——f(x for x in y) 和 f((x for x in y)) 意思完全一样。书店的版本:库存总价值不用先建列表,直接让 sum() 现算现加:
books = [('三体', 59.0, 7), ('海底两万里', 39.5, 12), ('活着', 29.0, 5)]
total = sum(price * stock for title, price, stock in books)
# total 是 1032.0
most_expensive = max(price for title, price, stock in books)
# most_expensive 是 59.0
low_titles = list(title for title, price, stock in books if stock < 10)
# low_titles 是 ['三体', '活着']
我的判断是:sum()、max()、min() 后面跟生成器表达式,是推导式之外最常用的「一行写法」——东西算完就用掉,不留下来占内存;但结果要反复用、要查下标、要数个数,就别用生成器表达式,老老实实写列表推导式。
第八步:列表还是生成器——按「用几次、占多少」选
推导式和生成器长得像,选错了会吃亏,分三点看。第一,用几次:列表可以反复用,生成器只能走一遍——走完了再走一遍,拿到的是空的:
gen = (x**2 for x in range(3))
list(gen) # [0, 1, 4]
list(gen) # [],已经走完了
第二,占多少内存:列表把所有结果一次造出来放着,生成器一次只算一个。官方教程 9.10 节的原话是,生成器表达式比等价的列表推导式更省内存。第五篇那个十年流水账的例子正好用上:文件对象本身就是一次一行往外吐的迭代器,for line in f 读大文件不占内存;想从大文件里现算现筛,生成器表达式接在后面就行:
# 假装 daily.txt 里每行是一个数字:不用先读出整个列表
with open('daily.txt', encoding='utf-8') as f:
total = sum(float(line.strip()) for line in f if line.strip())
第三,能不能查个数、下标:列表能 len()、能按下标取,生成器都不能——调 len(gen) 会直接报错,因为生成器自己都不知道后面还有几个。我的判断是:选的时候只问两个问题——「这个结果我要用几次?」「数据大不大?」用一次、数据大,用生成器;用多次、要查个数下标,用列表。两个答案打架的时候(比如数据大但要反复用),先用生成器算出结果存进列表,一次性的算账和反复用的清单就分开了。
第九步:三个坑——循环变量、副作用、嵌套太深
第一个坑是循环变量会不会「漏出来」。第一篇那个 for 循环会把 x 留在外面,推导式不会:
squares = [x**2 for x in range(10)]
# 推导式里的 x 不会漏到外面来
for x in range(3):
pass
# 这个 for 循环跑完,x 是 2,还留在外面
官方教程 5.1.3 节也提过:循环写法会留下一个叫 x 的变量,推导式没有这个副作用。所以别在推导式外面指望用到它里面的循环变量。第二个坑是副作用:推导式是用来「造新东西」的,别在里面写 append()、print() 这种只为副作用而跑的操作——表达式每跑一次就副作用一次,读代码的人还以为你在造列表。第三个坑是嵌套太深:第三步那个转置矩阵的嵌套推导式,看懂要花几秒钟;再套一层,基本没人能一眼看懂。我的判断是:推导式超过两层、或者一行超过 80 个字符,就拆成普通循环或者先拆成两步——省下来的那几行,不值得搭上可读性。
第十步:收尾——推导式是「要什么先说」,以及一张翻车分布图
最后把这篇和第五篇连起来:第五篇读进来的进货单是字典的列表,第六篇的推导式就是处理它的顺手工具——挑库存不够的、算打折价、拼书名集合,全是一行。完整的小例子:
import csv
with open('stock.csv', newline='', encoding='utf-8') as f:
rows = list(csv.DictReader(f))
low_stock = [row['title'] for row in rows if int(row['stock']) < 10]
# low_stock 是 ['三体', '活着']
total = sum(float(row['price']) * int(row['stock']) for row in rows)
# total 是 1032.0
prices = {row['title']: float(row['price']) for row in rows}
# prices 是 {'三体': 59.0, '海底两万里': 39.5, '活着': 29.0}
注意 DictReader 读出来的 price 和 stock 是字符串,推导式里要先 float()、int() 转好再算——这是第五篇第十步留下的尾巴。
最后是这篇的翻车分布图。示例:虚构晨光书店记账脚本学 Python 第六个月,100 次和推导式、生成器有关的翻车,原因分布如下。图里排第一的错,是生成器用完一遍、第二遍再用是空的。

回头看这篇的十步,其实只讲了三件事。第一,推导式是「要什么先说」:方括号产列表、大括号加冒号产字典、大括号不加冒号产集合,表达式在前、for 和 if 在后;双重 for 的顺序和两层循环一样,嵌套超过两层就拆开。第二,生成器是「一次只吐一个」:函数里写 yield 就变成了生成器函数,调用它不会立刻跑,next() 一次往前走一步,跑完自动抛 StopIteration;生成器表达式是方括号换成圆括号的短写法,给 sum()、max() 现算现用最顺手。第三,选哪个看用法:用一次、数据大,用生成器;用多次、要查个数下标,用列表;生成器只能走一遍,推导式里的循环变量不会漏出来。下一篇留给字典与集合的深挖:推导式产出的字典和集合,键能不能用列表、去重之后顺序还在不在、get() 和 setdefault() 怎么分工——到时候这篇的字典推导式和集合推导式会再回来。
评论 (0)
原始来源
相关文章
账只存在内存里,程序一关就全没了。本文按 Python 官方教程第 7 章与 csv 模块文档讲清楚:f 字符串与 format、str 与 repr、open 的 r/w/a/r+ 四种模式、with、五种读法、write 与 tell/seek、JSON 整存整取、CSV 的 DictReader/DictWriter,另附虚构晨光书店记账脚本第五个月 100 次翻车的分布。
异常不是程序坏了,是 Python 在用有名字的办法告诉你哪里出了问题。本文按 Python 官方教程第 8 章讲清楚:语法错误与异常、try/except、except 按继承匹配、哪些错该接哪些不该接、raise、else、finally、with、自定义异常、异常链与 ExceptionGroup,另附虚构晨光书店记账脚本第四个月 100 次翻车的分布。
类是把数据和规矩打包在一起的办法:一个 Book 类做出每本书自己的状态,方法让对象自己干活,继承让电子书站在纸书肩膀上。本文按 Python 官方教程第 9 章讲清楚:class 与 __init__、self、方法、类变量与实例变量、属性查找、继承与覆盖、super()、下划线私有约定、dataclass、__iter__ 与 __next__,另附虚构晨光书店记账脚本第三个月 100 次翻车的分布。