Python 常见 Iterable 可迭代对象（建议收藏）

我们知道，可以直接作用于for循环的对象，像 list，tuple，dict 等；

统称为 可迭代对象：Iterable。

那 Python 中有哪些常见的 可迭代对象呢？

一、字符串 str

 本质上是字符数组。所以当然是可迭代的。可以用 isinstance() 函数判断一个对象是否是 Iterable 对象。

from collections.abc import Iterable

s = 'ABCDEFG'
for x in s:
    print(x, end=" ")

if isinstance(s, Iterable):
    print('字符串是可迭代对象')

二、列表 list

from collections.abc import Iterable

L = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
for x in L:
    print(x, end=" ")

if isinstance(L, Iterable):
    print('列表是可迭代对象')

三、列表生成式 List Comprehensions

本质上还是列表，列表生成式更像是 Python 提供的一种语法糖，在运行时替换为生成的列表。

from collections.abc import Iterable

L = [ chr(x) for x in range(65, 72)]
for x in L:
    print(x, end=" ")

if isinstance(L, Iterable):
    print('列表生成式是可迭代对象')

扩展：

1、两层的列表生成式

print( [ m+n for m in 'ABC' for n in 'XYZ' ] )

等效于

# 等效于
L = []
for m in 'ABC':
    for n in 'XYZ':
        L.append(m+n)
# 打印
print(L)

2、for 循环后面加上 if 判断的列表生成式

print( [ m+n for m in 'ABC' if m != 'A' for n in 'XYZ' if n != 'X' ] )

等效于

# 等效于
L = []
for m in 'ABC':
    if m != 'A':
        for n in 'XYZ':
            if n != 'X':
                L.append(m+n)
# 打印
print(L)

3、for 循环前面加上 if 判断的列表生成式

print( [ m+n if m != 'A' and n != 'X' else None for m in 'ABC' for n in 'XYZ' ] )

等效于

# 等效于
L = []
for m in 'ABC':
    for n in 'XYZ':
        if m != 'A' and n != 'X':
            L.append(m+n)
        else:
            L.append(None)
# 打印
print(L)

4、为什么 for 循环后面的 if 不需要 else，而 for 循环前面的 if 需要 else?

因为 for 循环后面的 if 表示的是一种过滤条件，它只需要过滤掉不需要的元素，不让它进入下一级 for 语句 或者 for 前面的表达式就行。它是一种单分支的条件判断。

就好像你去报考清华，清华招生办只需要知道你的分数是否达标，不达标就过滤掉了，他不会考虑你不达标之后的去处，是去北大，还是去农大。

而 for 循环前面是 表达式语句。是表达式就需要有结果。

m+n if m != 'A' and n != 'X' else None

m+n 是 if 成立的结果，那 if 不成立的结果呢？你要告诉它。

for 循环前面的 表达式语句 有点类似于Java的三目运算符。

四、range 对象

无需多言，Python 迭代开始的地方。

from collections.abc import Iterable

r = range(65, 72)
# print(r)
for x in r:
    print(chr(x), end=" ")

if isinstance(r, Iterable):
    print('range是可迭代对象')

扩展：一些特殊值

class range(stop) 默认
class range(start, stop[, step])

1、stop = 0

2、start = stop

3、start > stop

五、元组 tuple

不可变的列表，当然也是可迭代的。

from collections.abc import Iterable

t = ( 'A', 'B', 'C', 'D', 'E', 'F', 'G' )
for x in t:
    print(x, end=" ")

if isinstance(t, Iterable):
    print('元组是可迭代对象')

六、字典 dict

from collections.abc import Iterable

d = { 'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5, 'F': 6, 'G': 7 }
for x in d:
    print(x, end=" ")

if isinstance(d, Iterable):
    print('字典是可迭代对象')

 这种方式只会迭代出字典的 key

字典的更多迭代方式，可以看我的另外一篇博文 遍历字典

七、字典生成式 dict comprehensions

from collections.abc import Iterable

keys = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G' ]
values = [ 1, 2, 3, 4, 5, 6, 7]

d = { k : v for k, v in zip(keys, values) }
print(d)
for x in d:
    print(x, end=" ")

if isinstance(d, Iterable):
    print('字典生成式是可迭代对象')

八、集合 set

from collections.abc import Iterable

s = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' }
for x in s:
    print(x, end=" ")

if isinstance(s, Iterable):
    print('集合是可迭代对象')

 集合是无序的，所以打印出来的元素并没有按照定义时的顺序。

九、集合生成式 set comprehensions

from collections.abc import Iterable

s = { x for x in 'ABCDEFGHIJ' if x not in 'HIJ' }
print( s )
for x in s:
    print(x, end=" ")

if isinstance(s, Iterable):
    print('集合生成式是可迭代对象')

十、生成器 generator

通过各种生成式，可以很方便的生成各种集合数据结构。不过生成式有一个缺点，就是所有元素都是一次性生成，然后放在内存中的。内存容量总归是有限的。

如果元素可以按照某种算法推算出来，那我们就可以在循环的过程中不断推算出后续的元素，而不用一次性全部生成。

Python中，这种一边循环一边计算的机制，称为生成器：generator。

创建生成器的一种简单的方法，就是把各种 生成式 外面的 [] 或 {} 改成 ()

把第三节的列表生成式改造一下，就可以得到一个列表生成器：

from collections.abc import Iterable

g = ( chr(x) for x in range(65, 72) )
print( g )
for x in g:
    print(x, end=" ")

if isinstance(g, Iterable):
    print('列表生成器是可迭代对象')

from collections.abc import Iterable

keys = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G' ]
values = [ 1, 2, 3, 4, 5, 6, 7]

g = ( { k : v } for k, v in zip(keys, values) )
print(g)
for x in g:
    print(x, end=" ")

if isinstance(g, Iterable):
    print('字典生成器是可迭代对象')

from collections.abc import Iterable

g = ( { x } for x in 'ABCDEFGHIJ' if x not in 'HIJ' )
print(g)
for x in g:
    print(x, end=" ")

if isinstance(g, Iterable):
    print('集合生成器是可迭代对象')

from collections.abc import Iterable

L1 = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G' ]
L2 = [ 1, 2, 3, 4, 5, 6, 7]

g = ( ( x , y ) for x, y in zip(L1, L2) )
print(g)
for x in g:
    print(x, end=" ")

if isinstance(g, Iterable):
    print('元组生成器是可迭代对象')

 生成器 除了用 for in 迭代外，还可以通过next()函数获得生成器的下一个返回值。

每次调用 next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

g = ( chr(x) for x in range(65, 72) )
print( next(g), end=" " )
print( next(g), end=" " )
print( next(g), end=" " )
print( next(g), end=" " )
print( next(g), end=" " )
print( next(g), end=" " )
print( next(g), end=" " )
print( next(g), end=" " )

 十一、生成器函数

创建生成器的另一种方式，是使用生成器函数。

生成器函数是一种特殊的函数，使用 `yield` 语句来返回一个值，并暂停函数的执行，等待下一次调用。每次调用生成器函数时，它会从上一次暂停的位置继续执行，直到遇到下一个 `yield` 语句或函数结束。

 我们来看一个杨辉三角的生成器函数：

from collections.abc import Iterator
from collections.abc import Iterable

def triangles():
    L = [1]
    while True:
        # 第一次调用 next，保留函数现场 L=[1] 返回 [1]
        yield L
        # 第二次调用 next，从这里开始，取出函数现场 L=[1] 执行，然后循环
        # 直到碰到 yield 关键字，继续保留函数现场，然后返回
        L = [1] + [ L[i]+L[i+1] for i in range( len(L)-1 ) ] + [1]

g = triangles()
print(g)
if isinstance( g, Iterable):
    print('生成器函数是可迭代对象')
if isinstance( g, Iterator):
    print('生成器函数是迭代器')

关于杨辉三角生成器的更多知识，可以移步我的博文 Python generator 生成杨辉三角

十二、迭代器 Iterator

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

而生成器是一种特殊的迭代器。像我们上面建的那些生成器，统统都是迭代器。

from collections.abc import Iterator

lg = ( chr(x) for x in range(65, 72) )
if isinstance(lg, Iterator):
    print('列表生成器是迭代器')

keys = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G' ]
values = [ 1, 2, 3, 4, 5, 6, 7]
dg = ( { k : v } for k, v in zip(keys, values) )
if isinstance(dg, Iterator):
    print('字典生成器是迭代器')

sg = ( { x } for x in 'ABCDEFGHIJ' if x not in 'HIJ' )
if isinstance(sg, Iterator):
    print('集合生成器是迭代器')

L1 = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G' ]
L2 = [ 1, 2, 3, 4, 5, 6, 7]
tg = ( ( x , y ) for x, y in zip(L1, L2) )
if isinstance(tg, Iterator):
    print('元组生成器是迭代器')

字符串、集合数据结构，包括它们的生成式，都不是迭代器。

from collections.abc import Iterator

if isinstance( 'ABC', Iterator):
    print('字符串是迭代器')
else:
    print('字符串不是迭代器')

if isinstance( range(5), Iterator):
    print('range对象是迭代器')
else:
    print('range对象不是迭代器')

if isinstance( [], Iterator):
    print('列表是迭代器')
else:
    print('列表不是迭代器')

if isinstance( [ chr(x) for x in range(65, 72)], Iterator):
    print('列表生成式是迭代器')
else:
    print('列表生成式不是迭代器')

if isinstance( (1,), Iterator):
    print('元组是迭代器')
else:
    print('元组不是迭代器')

if isinstance( { }, Iterator):
    print('字典是迭代器')
else:
    print('字典不是迭代器')

if isinstance( { x : x**2 for x in range(5) }, Iterator):
    print('字典生成式是迭代器')
else:
    print('字典生成式不是迭代器')

if isinstance( { 1 }, Iterator):
    print('集合是迭代器')
else:
    print('集合不是迭代器')

if isinstance( { x for x in range(5) }, Iterator):
    print('集合生成式是迭代器')
else:
    print('集合生成式不是迭代器')

为什么list、dict、str等数据类型不是Iterator？

"这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。"

集合数据类型虽然不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的。

 列表的 for 循环：

L = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
for x in L:
    print(x, end=" ")

print('\n等效于')
it = iter(L)
while True:
    try:
        x = next(it)
        print(x, end=" ")
    except StopIteration:
        break

字典生成器 for 循环：

g = ( { x : x**2} for x in range(5) )
for x in g:
    print(x, end=" ")

print('\n等效于')
# 注意，在第一次 for 循环以后，生成器 g 的元素已经被遍历完了
# 所以需要重新新建一个生成器
g = ( { x : x**2} for x in range(5) )
while True:
    try:
        x = next(g)
        print(x, end=" ")
    except StopIteration:
        break

十三、Iterable、Iterator、集合数据结构之间的关系

GitHub Copilot: 迭代器和生成器都是Python中用于处理可迭代对象的工具。

迭代器是一个实现了迭代器协议的对象，它可以被 `next()` 函数调用来返回下一个值，如果没有更多的值可以返回，那么就会抛出 `StopIteration` 异常。迭代器可以用于遍历序列、集合和其他可迭代对象，例如列表、元组、字典和文件等。Python中的内置函数 `iter()` 可以将一个可迭代对象转换为一个迭代器。

生成器是一种特殊的迭代器，它可以通过函数来创建。生成器函数使用 `yield` 语句来返回一个值，并暂停函数的执行，等待下一次调用。每次调用生成器函数时，它会从上一次暂停的位置继续执行，直到遇到下一个 `yield` 语句或函数结束。生成器可以用于生成大量数据或处理无限序列，例如斐波那契数列和素数序列等。

作者：matrixlzp