迭代器与生成器（一）
1.手动遍历迭代器
你想遍历一个可迭代对象中的所有元素，但是却不想使用 for 循环。
为了手动的遍历可迭代对象，使用 next() 函数并在代码中捕获 StopIteration 异常。比如，下面的例子手动读取一个文件中的所有行：
def manual_iter():
with open('/etc/passwd') as f:
try:
while True:
line = next(f)
print(line, end='')
except StopIteration:
pass
通常来讲， StopIteration 用来指示迭代的结尾。然而，如果你手动使用上面演示的 next() 函数的话，你还可以通过返回一个指定值来标记结尾，比如 None 。下面是示例：
with open('/etc/passwd') as f:
while True:
line = next(f, None)
if line is None:
break
print(line, end='')
大多数情况下，我们会使用 for 循环语句用来遍历一个可迭代对象。但是，偶尔也需要对迭代做更加精确的控制，这时候了解底层迭代机制就显得尤为重要了。
下面的交互示例向我们演示了迭代期间所发生的基本细节：
>>> items = [1, 2, 3]
>>> # Get the iterator
>>> it = iter(items) # Invokes items.__iter__()
>>> # Run the iterator
>>> next(it) # Invokes it.__next__()
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
2.代理迭代
你构建了一个自定义容器对象，里面包含有列表、元组或其他可迭代对象。你想直接在你的这个新容器对象上执行迭代操作。
实际上你只需要定义一个 __iter__() 方法，将迭代操作代理到容器内部的对象上去。比如：
class Node:
def __init__(self, value):
self._value = value
self._children = []
def __repr__(self):
return 'Node({!r})'.format(self._value)
def add_child(self, node):
self._children.append(node)
def __iter__(self):
return iter(self._children)
# Example
if __name__ == '__main__':
root = Node(0)
child1 = Node(1)
child2 = Node(2)
root.add_child(child1)
root.add_child(child2)
# Outputs Node(1), Node(2)
for ch in root:
print(ch)
__repr__方法- 定义对象的字符串表示形式，方便调试和输出。
- 例如，如果
_value是3，打印该节点会显示Node(3)。 !r表示使用repr()方法格式化self._value，保留值的原始表示（如字符串会带引号）。
__iter__方法- 使
Node对象可迭代，可以直接遍历其子节点。 - 返回
self._children的迭代器，这样可以对子节点进行循环操作（如for child in node:）。
- 使
在上面代码中，__iter__() 方法只是简单的将迭代请求传递给内部的 _children 属性。
Python 的迭代器协议需要 __iter__() 方法返回一个实现了 __next__() 方法的迭代器对象。如果你只是迭代遍历其他容器的内容，你无须担心底层是怎样实现的。你所要做的只是传递迭代请求既可。
这里的 iter() 函数使用了简化的代码，iter(s) 只是简单的通过调用 s.__iter__() 方法来返回对应的迭代器对象，就跟 len(s) 会调用 s.__len__() 原理是一样的。
3.使用生成器创建新的迭代模式
你想实现一个自定义迭代模式，跟普通的内置函数比如 range()、reversed() 不一样。
如果你想实现一种新的迭代模式，使用一个生成器函数来定义它。下面是一个生产某个范围内浮点数的生成器：
def frange(start, stop, increment):
x = start
while x < stop:
yield x
x += increment
为了使用这个函数，你可以用 for 循环迭代它或者使用其他接受一个可迭代对象的函数（比如 sum()，list() 等）。示例如下：
>>> for n in frange(0, 4, 0.5):
... print(n)
...
0
0.5
1.0
1.5
2.0
2.5
3.0
3.5
>>> list(frange(0, 1, 0.125))
[0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875]
>>>
一个函数中需要有一个 yield 语句即可将其转换为一个生成器。跟普通函数不同的是，生成器只能用于迭代操作。下面是一个实验，向你展示这样的函数底层工作机制：
>>> def countdown(n):
... print('Starting to count from', n)
... while n > 0:
... yield n
... n -= 1
... print('Done!')
...
>>> # Create the generator, notice no output appears
>>> c = countdown(3)
>>> c
<generator object countdown at 0x1006a0af0>
>>> # Run to first yield and emit a value
>>> next(c)
Starting to count from 3
3
>>> # Run to the next yield
>>> next(c)
2
>>> # Run to next yield
>>> next(c)
1
>>> # Run to next yield (iteration stops)
>>> next(c)
Done!
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration
>>>
一个生成器函数主要特征是它只会回应在迭代中使用到的 next 操作。一旦生成器函数返回退出，迭代终止。我们在迭代中通常使用的 for 语句会自动处理这些细节，所以你无需担心。
4.实现迭代器协议
你想构建一个能支持迭代操作的自定义对象，并希望找到一个能实现迭代协议的简单方法。
目前为止，在一个对象上实现迭代最简单的方式是使用一个生成器函数。在第 2 小节中，使用 Node 类来表示树形数据结构。你可能想实现一个以深度优先方式遍历树形节点的生成器。
下面是代码示例：
class Node:
def __init__(self, value):
self._value = value
self._children = []
def __repr__(self):
return 'Node({!r})'.format(self._value)
def add_child(self, node):
self._children.append(node)
def __iter__(self):
return iter(self._children)
def depth_first(self):
yield self
for c in self:
yield from c.depth_first()
# Example
if __name__ == '__main__':
root = Node(0)
child1 = Node(1)
child2 = Node(2)
root.add_child(child1)
root.add_child(child2)
child1.add_child(Node(3))
child1.add_child(Node(4))
child2.add_child(Node(5))
for ch in root.depth_first():
print(ch)
# Outputs Node(0), Node(1), Node(3), Node(4), Node(2), Node(5)
在这段代码中，depth_first() 方法简单直观。它首先返回自己本身，并迭代每一个子节点，并通过调用子节点的 depth_first() 方法（使用 yield from 语句）返回对应元素。
Python 的迭代协议要求一个 __iter__() 方法返回一个特殊的迭代器对象，这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。但是，实现这些通常会比较繁琐。下面我们演示下这种方式，如何使用一个关联迭代器类重新实现 depth_first() 方法：
class Node2:
def __init__(self, value):
self._value = value
self._children = []
def __repr__(self):
return 'Node({!r})'.format(self._value)
def add_child(self, node):
self._children.append(node)
def __iter__(self):
return iter(self._children)
def depth_first(self):
return DepthFirstIterator(self)
class DepthFirstIterator(object):
'''
Depth-first traversal
'''
def __init__(self, start_node):
self._node = start_node
self._children_iter = None
self._child_iter = None
def __iter__(self):
return self
def __next__(self):
# 1. 如果是第一次访问，返回当前节点，并初始化子节点迭代器
if self._children_iter is None:
self._children_iter = iter(self._node) # 获取子节点的迭代器
return self._node # 返回当前节点
# 2. 如果正在遍历某个子节点，继续返回它的下一个节点
elif self._child_iter:
try:
nextchild = next(self._child_iter) # 尝试获取子节点的下一个节点
return nextchild
except StopIteration: # 如果子节点遍历完毕
self._child_iter = None # 重置子节点迭代器
return next(self) # 继续处理下一个子节点
# 3. 否则，获取下一个子节点，并开始深度遍历
else:
self._child_iter = next(self._children_iter).depth_first() # 递归调用
return next(self) # 继续处理
Node2类表示树节点，支持添加子节点和迭代子节点。DepthFirstIterator实现了深度优先遍历：- 先访问当前节点。
- 递归遍历第一个子节点，直到叶子节点。
- 回溯并继续遍历其他子节点。
- 这种实现方式适用于树形结构的遍历，例如文件目录、DOM 树等。
假设我们有如下树结构：
A
/ \
B C
/ \ \
D E F
深度优先遍历顺序：A → B → D → E → C → F
root = Node2('A')
b = Node2('B')
c = Node2('C')
d = Node2('D')
e = Node2('E')
f = Node2('F')
root.add_child(b)
root.add_child(c)
b.add_child(d)
b.add_child(e)
c.add_child(f)
# 深度优先遍历
for node in root.depth_first():
print(node) # 输出顺序: A → B → D → E → C → F
DepthFirstIterator 类和上面使用生成器的版本工作原理类似，但是它写起来很繁琐，因为迭代器必须在迭代处理过程中维护大量的状态信息。坦白来讲，没人愿意写这么晦涩的代码。将你的迭代器定义为一个生成器后一切迎刃而解。