脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 脚本专栏 → python → Python Iterable可迭代对象

Python常见Iterable可迭代对象(建议收藏)

 更新时间：2025年12月17日 09:36:54   作者：matrixlzp  
本文介绍了Python中常见的可迭代对象,包括字符串、列表、列表生成式、range对象、元组、字典、字典生成式、集合、集合生成式、生成器、生成器函数和迭代器,感兴趣的可以了解一下

我们知道，可以直接作用于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('生成器函数是迭代器')

 

十二、迭代器 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` 语句或函数结束。生成器可以用于生成大量数据或处理无限序列，例如斐波那契数列和素数序列等。

到此这篇关于Python常见Iterable可迭代对象(建议收藏)的文章就介绍到这了,更多相关Python Iterable可迭代对象内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • 使用Python去除字符串中某个字符的多种实现方式比较

    使用Python去除字符串中某个字符的多种实现方式比较

    python中字符串是不可变的,所以无法直接删除字符串之间的特定字符,下面这篇文章主要给大家介绍了关于使用Python去除字符串中某个字符的多种实现方式比较的相关资料,需要的朋友可以参考下
    2022-06-06
  • Python数据分析之 Matplotlib 3D图详情

    Python数据分析之 Matplotlib 3D图详情

    本文主要介绍了Python数据分析之Matplotlib 3D图详情，Matplotlib提供了mpl_toolkits.mplot3d工具包来进行3D图表的绘制，下文总结了更多相关资料，需要的小伙伴可以参考一下
    2022-05-05
  • Python中模块pymysql查询结果后如何获取字段列表

    Python中模块pymysql查询结果后如何获取字段列表

    pymsql是Python中操作MySQL的模块，其使用方法和MySQLdb几乎相同。下面这篇文章主要给大家介绍了关于Python中模块pymysql查询结果后如何获取字段列表的相关资料，文中介绍的非常详细，需要的朋友可以参考借鉴，下面来看看详细的介绍。
    2017-06-06
  • python写入已存在的excel数据实例

    python写入已存在的excel数据实例

    下面小编就为大家分享一篇python写入已存在的excel数据实例，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
    2018-05-05
  • python flask实现分页效果

    python flask实现分页效果

    这篇文章主要为大家详细介绍了python flask实现分页效果，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2017-06-06
  • 使用 Python 获取 Linux 系统信息的代码

    使用 Python 获取 Linux 系统信息的代码

    在本文中，我们将会探索使用Python编程语言工具来检索Linux系统各种信息,需要的朋友可以参考下
    2014-07-07
  • Python实现享元模式的示例代码

    Python实现享元模式的示例代码

    享元模式是一种结构型设计模式,旨在通过共享尽可能多的相似对象来减少内存使用,提高性能,下面我们就来看看如何使用Python实现享元模式吧
    2024-02-02
  • python登录QQ邮箱发信的实现代码

    python登录QQ邮箱发信的实现代码

    python登录QQ邮箱发信的代码，有需要的朋友可以参考下
    2013-02-02
  • TensorFlow隐藏操作探索(张量操作和定制模型算法)

    TensorFlow隐藏操作探索(张量操作和定制模型算法)

    这篇文章主要为大家介绍了TensorFlow隐藏操作探索(张量操作和定制模型算法),有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
    2023-11-11
  • NumPy性能优化的实例技巧

    NumPy性能优化的实例技巧

    NumPy 提供了一些工具和技巧，帮助用户优化代码以提高执行效率，本文主要介绍了NumPy性能优化，具有一定的参考价值，感兴趣的可以了解一下
    2024-01-01

最新评论