Python入门基础（四）推导式、迭代器与生成器

一、推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

推导式（Comprehension）是 Python 的一种简洁、高效的语法结构，用于快速生成列表（List）、字典（Dict）、集合（Set）甚至生成器（Generator或称元组Tuple）。它的核心思想是：

用一行代码完成循环 + 条件判断 + 数据转换，生成一个新的数据结构。

推导式格式

所有推导式的通用结构如下：

1
[ 表达式 for 变量 in 可迭代对象 if 条件 ]
  • 表达式：对变量进行处理（如 x * 2）。
  • for 变量 in 可迭代对象：遍历数据源（如 for x in range(10)）。
  • if 条件（可选）：过滤数据（如 if x % 2 == 0）。
推导式类型 语法示例 用途
列表推导式（List Comprehension） [x for x in range(10)] 生成列表
字典推导式（Dict Comprehension） {k: v for k, v in zip(keys, values)} 生成字典
集合推导式（Set Comprehension） {x for x in range(10)} 生成集合
生成器/元组推导式（Generator Expression） (x for x in range(10)) 生成生成器（惰性计算，节省内存）

列表推导式

列表推导式格式：

1
2
3
4
5
6
7
8
[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]

或者

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

  • out_exp_res：列表生成元素表达式，可以是有返回值的函数。
  • for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
  • if condition：条件语句，可以过滤列表中不符合条件的值。

过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：

1
2
3
4
>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

计算 30 以内可以被 3 整除的整数：

1
2
3
>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

字典推导式

字典推导基本格式：

1
2
3
4
5
6
{ key_expr: value_expr for value in collection }

或

{ key_expr: value_expr for value in collection if condition }

使用字符串及其长度创建字典：

1
2
3
4
5
listdemo = ['Google','Runoob', 'Taobao']
# 将列表中各字符串值为键，各字符串的长度为值，组成键值对
>>> newdict = {key:len(key) for key in listdemo}
>>> newdict
{'Google': 6, 'Runoob': 6, 'Taobao': 6}

集合推导式

集合推导式基本格式：

1
2
3
{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }

计算数字 1,2,3 的平方数：

1
2
3
>>> setnew = {i**2 for i in (1,2,3)}
>>> setnew
{1, 4, 9}

判断不是 abc 的字母并输出：

1
2
3
4
5
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

生成器推导式（元组推导式）

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

元组推导式基本格式：

1
2
3
(expression for item in Sequence )
或
(expression for item in Sequence if conditional )

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。

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

1
2
3
4
5
6
>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)

二、迭代器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住的内容的对象。

迭代器 Python 中用于遍历数据集合的一种机制，它的核心特点是：

惰性访问（Lazy Access）：数据按需获取，不一次性加载全部内容，节省内存。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完成结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter()和next()。

字符串，列表或元组对象都可用于创建迭代器：

1
2
3
4
5
6
7
>>> list = [ 1 , 2 , 3 , 4 ]
>>> it = iter ( list )    #创建迭代器对象
>>> print ( next ( it ) )   # 输出迭代器的下一个元素
1
>>> print ( next ( it ) )
2
>>>

迭代器对象可以使用常规for语句进行遍历：

1
2
3
4
5
6
#!/usr/bin/python3
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

也可以使用 next() 函数：

1
2
3
4
5
6
7
8
9
10
11
12
#!/usr/bin/python3
 
import sys         # 引入 sys 模块
 
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
 
while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

它和迭代器关系密切，但功能更灵活、性能更好，非常适合处理 大数据流、懒加载、协程 等场景。

yield 是一个关键字，用于定义生成器函数，生成器函数是一种特殊的函数，可以在迭代过程中逐步产生值，而不是一次性返回所有结果。

跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。

当在生成器函数中使用 yield 语句时，函数的执行将会暂停，并将 yield 后面的表达式作为当前迭代的值返回。（与return类似）

然后，每次调用生成器的 next() 方法或使用 for 循环进行迭代时，函数会从上次暂停的地方继续执行，直到再次遇到 yield 语句。这样，生成器函数可以逐步产生值，而不需要一次性计算并返回所有结果。

调用一个生成器函数，返回的是一个迭代器对象。

下面是一个简单的示例，展示了生成器函数的使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def countdown(n):
    while n > 0:
        yield n
        n -= 1
 
# 创建生成器对象
generator = countdown(5)
 
# 通过迭代生成器获取值
print(next(generator))  # 输出: 5
print(next(generator))  # 输出: 4
print(next(generator))  # 输出: 3
 
# 使用 for 循环迭代生成器
for value in generator:
    print(value)  # 输出: 2 1

以上实例中，countdown 函数是一个生成器函数。它使用 yield 语句逐步产生从 n 到 1 的倒数数字。在每次调用 yield 语句时，函数会返回当前的倒数值，并在下一次调用时从上次暂停的地方继续执行。

通过创建生成器对象并使用 next() 函数或 for 循环迭代生成器，我们可以逐步获取生成器函数产生的值。在这个例子中，我们首先使用 next() 函数获取前三个倒数值，然后通过 for 循环获取剩下的两个倒数值。

生成器函数的优势是它们可以按需生成值，避免一次性生成大量数据并占用大量内存。此外，生成器还可以与其他迭代工具（如for循环）无缝配合使用，提供简洁和高效的迭代方式。

以下实例使用 yield 实现斐波那契数列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

执行以上程序，输出结果如下：

0 1 1 2 3 5 8 13 21 34 55