1.手动遍历迭代器
遍历一个可迭代对象中的所有元素，但是却不想使用for循环
为了手动的遍历可迭代对象，使用 next() 函数并在代码中捕获 StopIteration 异常。 比如，下面的例子手动读取一个文件中的所有行：
def manual_iter():
with open('/etc/passwd') as f:
try:
while True:
line = next(f)
print(line, end='')
except StopIteration:
passStopIteration 用来指示迭代的结尾。 然而，如果你手动使用上面演示的 next() 函数的话，你还可以通过返回一个指定值来标记结尾，比如 None 。
with open('/etc/passwd') as f:
while True:
line = next(f, None)
if line is None:
break
print(line, end='')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)
'''
Node(1)
Node(2)
'''3.使用生成器创建新的迭代模式
def frange(start, stop, increment):
x = start
while x < stop:
yield x #yield 语句即可将函数转换为一个生成器
x += increment
>>> 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]
>>>一个生成器函数主要特征是它只会回应在迭代中使用到的?next?操作。 一旦生成器函数返回退出，迭代终止。
4. 实现迭代器协议
实现一个以深度优先方式遍历树形节点的生成器
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)
#Python的迭代协议要求一个 __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成
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)5.反向迭代
反向迭代仅仅当对象的大小可预先确定或者对象实现了?__reversed__()?的特殊方法时才能生效
（1）对象为列表且大小已知
>>> a = [1, 2, 3, 4]
>>> for x in reversed(a):
... print(x)
...
4
3
2
1（2）如果两者都不符合，那你必须先将对象转换为一个列表才行
# Print a file backwards
f = open('somefile')
for line in reversed(list(f)):
print(line, end='')6.带有外部状态的生成器函数
关于生成器，很容易掉进函数无所不能的陷阱。 如果生成器函数需要跟你的程序其他部分打交道的话(比如暴露属性值，允许通过方法调用来控制等等)， 可能会导致你的代码异常的复杂。 如果是这种情况的话，可以考虑使用上面介绍的定义类的方式。 在?__iter__()?方法中定义你的生成器不会改变你任何的算法逻辑。 由于它是类的一部分，所以允许你定义各种属性和方法来供用户使用。
from collections import deque
class linehistory:
def __init__(self, lines, histlen=3):
self.lines = lines
self.history = deque(maxlen=histlen)
def __iter__(self):
for lineno, line in enumerate(self.lines, 1):
self.history.append((lineno, line))
yield line
def clear(self):
self.history.clear()7.迭代器切片
函数?itertools.islice()?正好适用于在迭代器和生成器上做切片操作
>>> def count(n):
... while True:
... yield n
... n += 1
...
>>> c = count(0)
>>> c[10:20]#迭代器和生成器不能使用标准的切片操作，因为它们的长度事先我们并不知道(并且也没有实现索引)。
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'generator' object is not subscriptable
>>> # Now using islice()
>>> import itertools
>>> for x in itertools.islice(c, 10, 20):#函数 islice() 返回一个可以生成指定元素的迭代器，它通过遍历并丢弃直到切片开始索引位置的所有元素。 然后才开始一个个的返回元素，并直到切片结束索引位置
... print(x)
...
10
11
12
13
14
15
16
17
18
19
>>>8.跳过可迭代对象的开始部分
?（1）itertools.dropwhile()?函数 使用时，你给它传递一个函数对象和一个可迭代对象。 它会返回一个迭代器对象，丢弃原有序列中直到函数返回Flase之前的所有元素，然后返回后面所有元素
>>> with open('/etc/passwd') as f:
... for line in f:
... print(line, end='')
...
##
# User Database
#
# Note that this file is consulted directly only when the system is running
# in single-user mode. At other times, this information is provided by
# Open Directory.
...
##
nobody:*:-2:-2:Unprivileged User:/var/empty:/usr/bin/false
root:*:0:0:System Administrator:/var/root:/bin/sh
...
>>>
>>> from itertools import dropwhile
>>> with open('/etc/passwd') as f:
'''
要么传入lambda的函数形式 要么进行判断筛选可迭代对象
lines = (line for line in f if not line.startswith('#'))
for line in lines:
'''
... for line in dropwhile(lambda line: not line.startswith('#'), f):
... print(line, end='')
...
nobody:*:-2:-2:Unprivileged User:/var/empty:/usr/bin/false
root:*:0:0:System Administrator:/var/root:/bin/sh
...
>>>（2）已经明确知道了要跳过的元素的序号的话，那么可以使用?itertools.islice()?来代替
>>> from itertools import islice
>>> items = ['a', 'b', 'c', 1, 4, 10, 15]
>>> for x in islice(items, 3, None):
... print(x)
...
4
10
15
>>>9.排列组合的迭代
迭代遍历一个集合中元素的所有可能的排列或组合
（1）排列：itertools.permutations()?， 它接受一个集合并产生一个元组序列，每个元组由集合中所有元素的一个可能排列组成
>>> items = ['a', 'b', 'c']
>>> from itertools import permutations
>>> for p in permutations(items):
... print(p)
...
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')
>>>
#到指定长度的所有排列，你可以传递一个可选的长度参数
>>> for p in permutations(items, 2):
... print(p)
...
('a', 'b')
('a', 'c')
('b', 'a')
('b', 'c')
('c', 'a')
('c', 'b')
>>>（2）组合：使用?itertools.combinations()?可得到输入集合中元素的所有的组合
>>> from itertools import combinations
>>> for c in combinations(items, 3):
... print(c)
...
('a', 'b', 'c')
>>> for c in combinations(items, 2):
... print(c)
...
('a', 'b')
('a', 'c')
('b', 'c')
>>> for c in combinations(items, 1):
... print(c)
...
('a',)
('b',)
('c',)
>>>10.序列上索引值迭代
内置的?enumerate()?函数可以在迭代一个序列的同时获取到正在被迭代的元素索引
>>> my_list = ['a', 'b', 'c']
>>> for idx, val in enumerate(my_list):
... print(idx, val)
...
0 a
1 b
2 c应用：在你遍历文件时想在错误消息中使用行号定位
def parse_data(filename):
with open(filename, 'rt') as f:
for lineno, line in enumerate(f, 1):#行号从1开始
fields = line.split()
try:
...
except ValueError as e:
print('Line {}: Parse error: {}'.format(lineno, e))enumerate()?函数返回的是一个?enumerate?对象实例， 它是一个迭代器，返回连续的包含一个计数和一个值的元组， 元组中的值通过在传入序列上调用?next()?返回
11.同时迭代多个序列
目的：同时迭代多个序列，每次分别从一个序列中取一个元素
>>> xpts = [1, 5, 4, 2, 10, 7]
>>> ypts = [101, 78, 37, 15, 62, 99]
>>> for x, y in zip(xpts, ypts):
... print(x,y)
...
1 101
5 78
4 37
2 15
10 62
7 99
>>>zip(a,?b)?会生成一个可返回元组?(x,?y)?的迭代器，其中x来自a，y来自b。 一旦其中某个序列到底结尾，迭代宣告结束。 因此迭代长度跟参数中最短序列长度一致。
如果想让迭代长度以最长的一致，需要自动填充补齐
>>> from itertools import zip_longest
>>> for i in zip_longest(a,b):
... print(i)
...
(1, 'w')
(2, 'x')
(3, 'y')
(None, 'z')
>>> for i in zip_longest(a, b, fillvalue=0):
... print(i)
...
(1, 'w')
(2, 'x')
(3, 'y')
(0, 'z')
>>>使用zip()可以让你将它们打包并生成一个字典
headers = ['name', 'shares', 'price']
values = ['ACME', 100, 490.1]
s = dict(zip(headers,values))
print(s)
'''
{'name': 'ACME', 'shares': 100, 'price': 490.1}
'''12.不同集合上元素的迭代
想在多个对象执行相同的操作，但是这些对象在不同的容器中，希望代码在不失可读性的情况下避免写重复的循环
itertools.chain()?接受一个或多个可迭代对象作为输入参数。 然后创建一个迭代器，依次连续的返回每个可迭代对象中的元素。 这种方式要比先将序列合并再迭代要高效的多
>>> from itertools import chain
>>> a = [1, 2, 3, 4]
>>> b = ['x', 'y', 'z']
>>> for x in chain(a, b):
... print(x)
...
1
2
3
4
x
y
z
>>>13.创建数据处理管道
以数据管道(类似Unix管道)的方式迭代处理数据。 比如，你有个大量的数据需要处理，但是不能将它们一次性放入内存中。
import os
import fnmatch
import gzip
import bz2
import re
def gen_find(filepat, top):
'''
Find all filenames in a directory tree that match a shell wildcard pattern
'''
for path, dirlist, filelist in os.walk(top):
for name in fnmatch.filter(filelist, filepat):
yield os.path.join(path,name)
def gen_opener(filenames):
'''
Open a sequence of filenames one at a time producing a file object.
The file is closed immediately when proceeding to the next iteration.
'''
for filename in filenames:
if filename.endswith('.gz'):
f = gzip.open(filename, 'rt')
elif filename.endswith('.bz2'):
f = bz2.open(filename, 'rt')
else:
f = open(filename, 'rt')
yield f
f.close()
def gen_concatenate(iterators):
'''
Chain a sequence of iterators together into a single sequence.
'''
for it in iterators:
yield from it
def gen_grep(pattern, lines):
'''
Look for a regex pattern in a sequence of lines
'''
pat = re.compile(pattern)
for line in lines:
if pat.search(line):
yield line
lognames = gen_find('access-log*', 'www')
files = gen_opener(lognames)
lines = gen_concatenate(files)
pylines = gen_grep('(?i)python', lines)
for line in pylines:
print(line)#为了查找包含单词python的所有日志行14.展开嵌套的序列
将一个多层嵌套的序列展开成一个单层列表
from collections import Iterable
def flatten(items, ignore_types=(str, bytes)):
for x in items:
if isinstance(x, Iterable) and not isinstance(x, ignore_types):
#isinstance(x, Iterable)检查某个元素是否是可迭代的。 如果是的话， yield from 就会返回所有子例程的值
#额外的参数 ignore_types用来将字符串和字节排除在可迭代对象外，防止将它们再展开成单个的字符。
yield from flatten(x)#在生成器中调用其他生成器作为子例程
else:
yield x
>>> items = ['Dave', 'Paula', ['Thomas', 'Lewis']]
>>> for x in flatten(items):
... print(x)
...
Dave
Paula
Thomas
Lewis
>>>15.顺序迭代合并后的排序迭代对象
有一系列排序序列，想将它们合并后得到一个排序序列并在上面迭代遍历
>>> import heapq
>>> a = [1, 4, 7, 10]
>>> b = [2, 5, 6, 11]
>>> for c in heapq.merge(a, b):
... print(c)
...
1
2
4
5
6
7
10
1116.迭代器代替while无限循环
CHUNKSIZE = 8192
def reader(s):
while True:
data = s.recv(CHUNKSIZE)
if data == b'':
break
process_data(data)
#通常可以使用 iter() 来代替
def reader2(s):
for chunk in iter(lambda: s.recv(CHUNKSIZE), b''):#它会创建一个迭代器， 这个迭代器会不断调用 callable 对象直到返回值和标记值相等为止，即data == b''时 break。
pass
# process_data(data)
