Python3之路

Python3 CookBook学习笔记 -- 迭代器与生成器

2018-03-02  本文已影响28人  faris_shi

1. 手动遍历迭代器

你想遍历一个可迭代对象中的所有元素，但是却不想使用for循环。

请使用 next() 函数并在代码中捕获 StopIteration 异常。我们也可提供默认值用于标记结尾。

>>> items = [1, 2, 3]
>>> it = iter(items) # Invokes items.__iter__()
>>> 
>>> 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
>>> 
>>> next(it, None)

何为可迭代对象，需要这个对象中实现了 __iter__() 以及 __next__()两个函数。

2. 代理迭代

class Node:

    def __init__(self, value):
        self._value = value
        self._children=[]

    def __repr__(self):
        return 'Node({!r})'.format(self._value)

    def add_child(self, child):
        self._children.append(child)

    def __iter__(self):
        return iter(self._children)


if __name__ == '__main__':
    root=Node(0)
    child1=Node(1)
    child2=Node(2)
    root.add_child(child1)
    root.add_child(child2)
    print(root)
    for child in root:
        print(child)

Python 的迭代器协议需要 __iter__() 方法返回一个实现了 __next__() 方法的迭代器对象。 如果你只是迭代遍历其他容器的内容，你无须担心底层是怎样实现的。你所要做的只是传递迭代请求既可。

这里的 iter() 函数的使用简化了代码， iter(s) 只是简单的通过调用 s.__iter__() 方法来返回对应的迭代器对象， 就跟 len(s) 会调用 s.__len__() 原理是一样的。

3. 使用生成器创建新的迭代模式

如果我们想用函数实现生成器函数，那么函数中需要有一个 yield 语句即可将其转换为一个生成器。 跟普通函数不同的是，生成器只能用于迭代操作，且只能使用一次。

>>> def countdown(n):
...     print('Starting to count from', n)
...     while n > 0:
...             yield n
...             n -= 1
...     print('Done!')
... 
>>> 
>>> c=countdown(3)
>>> c
<generator object countdown at 0x101aa93b8>
>>> 
>>> next(c)
Starting to count from 3
3
>>> next(c)
2
>>> next(c)
1
>>> next(c)
Done!
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

生成器只能使用一次

>>> n=(n*n for n in range(0, 10))
>>> 
>>> 
>>> sum(n)
285
>>> sum(n)
0

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, child):
        self._children.append(child)

    def __iter__(self):
        return iter(self._children)

    def depth_first(self):
        yield self
        for c in self:
            yield from c.depth_first()

Python 的迭代协议要求一个 __iter__() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。 但是，实现这些通常会比较繁琐。

我们实现这个深度优先的递归遍历树形节点的生成器，最直接的方式就是使用 yield 、yield from 将函数变成生成器函数。

5. 反向迭代

反方向迭代一个序列，需要使用reversed()函数。

>>> a = [1, 2, 3, 4]
>>> for x in reversed(a):
...     print(x)
...
4
3
2
1

反向迭代需要两个条件：

如果两者都不符合，那你必须先将对象转换为一个 list 才行。

>>> f = open('/Users/faris/Desktop/docker.txt')
>>> 
>>> for line in reversed(list(f)):
...     print(line, end='')

在自定义类上实现 __reversed__() 方法来实现反向迭代，会使代码更加的高效，因为不用再转化成 list后再反向迭代。

class Countdown:
    def __init__(self, start):
        self.start = start
    def __iter__(self):
        n = self.start
        while n > 0 :
            yield n
            n = n - 1
    def __reversed__(self):
        n = 0
        while n <= self.start:
            yield n
            n = n + 1

>>> a=Countdown(10)
>>> [n for n in a]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> 
>>> [n for n in reversed(a)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

6. 迭代器切片

标准的切片操作，需要知道所切对象的长度，因此迭代器与生成器不能使用标准切片。

函数 itertools.islice() 正好适用于在迭代器和生成器上做切片操作

>>> a=[10, 20, 30]
>>> 
>>> a[1:]
[20, 30]
>>>  
>>> b=(n for n in a)
>>> 
>>> b[1:]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'generator' object is not subscriptable
>>> 
>>> b=(n for n in a)
>>> for x in itertools.islice(b, 1, 2):
...     print(x)
... 
20

7. 跳过可迭代对象的开始部分

你想遍历一个可迭代对象，但是它开始的某些元素你并不感兴趣，想跳过它们。

itertools.dropwhile() 函数，你给它传递一个函数对象和一个可迭代对象，它会返回一个迭代器对象。

>>> from itertools import dropwhile
>>> 
>>> with open('/etc/passwd') as f:
...     for line in dropwhile(lambda line: line.startswith('#'), f):
...         print(line, end='')

如果想跳过前几个元素的话，可以使用上一节的 itertools.islice()

>>> from itertools import islice
>>> 
>>> a=[10, 20, 30, 40, 50]
>>> for n in islice(a, 3, None):
...     print(n)
... 
40
50

或者我们仍然可以使用生成器来完成。

>>> with open('/etc/passwd') as f:
...     lines = (line for line in f if not line.startswith('#'))
...     for line in lines:
...         print(line, end='')

8. 排列组合的迭代

迭代遍历一个集合中元素的所有可能的排列或组合。

8.1 itertools.permutations()

可以得到输入序列的所有排列组合

>>> from itertools import permutations
>>> 
>>> items = ['a', 'b', 'c']
>>> 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')

也可以选择可排列的个数

>>> from itertools import permutations
>>> 
>>> items = ['a', 'b', 'c']
>>> for p in permutations(items, 2):
...     print(p)
... 
('a', 'b')
('a', 'c')
('b', 'a')
('b', 'c')
('c', 'a')
('c', 'b')

8.2 itertools.combinations()

可以得到输入序列的所有组合。（不关心顺序）

>>> from itertools import combinations
>>> 
>>> items = ['a', 'b', 'c']
>>> for p in combinations(items, 2):
...     print(p)
... 
('a', 'b')
('a', 'c')
('b', 'c')

8.3 itertools.combinations_with_replacement()

在组合时，允许同一元素在不同位置重复出现

>>> from itertools import combinations_with_replacement
>>> 
>>> items = ['a', 'b', 'c']
>>> for p in combinations_with_replacement(items, 2):
...     print(p)
... 
('a', 'a')
('a', 'b')
('a', 'c')
('b', 'b')
('b', 'c')
('c', 'c')

9. 序列上索引值迭代

你想在迭代一个序列的同时跟踪正在被处理的元素索引。

内置的 enumerate() 函数可以很好的解决这个问题:

>>> my_list = ['a', 'b', 'c']
>>> 
>>> for n in enumerate(my_list):
...     print(n)
... 
(0, 'a')
(1, 'b')
(2, 'c')

你可以传递一个开始索引参数:

>>> my_list = ['a', 'b', 'c']
>>> 
>>> for n in enumerate(my_list, 2):
...     print(n)
... 
(2, 'a')
(3, 'b')
(4, 'c')

这样在你处理错误是很好定位的。

def parse_data(filename):
    with open(filename, 'rt') as f:
        for lineno, line in enumerate(f, 1):
            fields = line.split()
            try:
                count = int(fields[1])
            except ValueError as e:
                print('Line {}: Parse error: {}'.format(lineno, e))

另外需要注意：

序列元素本身就是元组的时候，取值应该是这样子的。

>>> data = [ (1, 2), (3, 4), (5, 6), (7, 8) ]
>>> 
>>> for no, (x, y) in enumerate(data):
...     print(no, x, y)
... 
0 1 2
1 3 4
2 5 6
3 7 8

10. 展开嵌套的序列

你想将一个多层嵌套的序列展开成一个单层列表。

我们可以写一个包含 yield from 语句的递归生成器来轻松解决这个问题:

>>> from collections import Iterable
>>> 
>>> def flatten(items, ignore_types=(str, bytes)):
...     for n in items:
...         if isinstance(n, Iterable) and not isinstance(n, ignore_types):
...             yield from flatten(n)
...         else:
...             yield  n
... 
>>> 
>>> items = [1, 2, [3, 4, [5, 6], 7], 8, 'faris']
>>> 
>>> print([n for n in flatten(items)])
[1, 2, 3, 4, 5, 6, 7, 8, 'faris']

isinstance 用来判断类型。

11. 顺序迭代合并后的排序迭代对象

你有一系列排序序列，想将它们合并后得到一个排序序列并在上面迭代遍历。

可以使用 heapq.merge。由于它不会立即合并，所以我们可以在很长的序列上使用它，也不会带来很大的开销。

但是要求所有序列必须是排过序的。

>>> import heapq
>>> a = [1, 4, 7, 10]
>>> b = [2, 5, 6, 11]
>>> 
>>> for n in heapq.merge(a, b):
...     print(n)
... 
1
2
4
5
6
7
10
11

如果有一个序列没有排序，它不会检查，则会直接输出：

>>> import heapq
>>> a = [1, 4, 7, 10]
>>> b = [ 6, 11, 2, 5]
>>> 
>>> for n in heapq.merge(a, b):
...     print(n)
... 
1
4
6
7
10
11
2
5
上一篇 下一篇

猜你喜欢

热点阅读