第14章可迭代的对象、迭代器和生成器#

[toc]

可迭代对象#

举个例子：

1
import re
2

3
re_word = re.compile(r'\w+')
4

5

6
class Sentence(object):
7
    def __init__(self, text):
8
        self.text = text
9
        self.word = re_word.findall(text)
10

11
    def __getitem__(self, item):
12
        return self.word[item]
13

14
    def __len__(self):
15
        return len(self.word)
16

17
    def __str__(self):
18
        return 'Sentence(%s)' % self.word
19

20

21
if __name__ == "__main__":
22

23
    s = Sentence("Today is Tuesday")
24
    print(s)
25

26
    for word in s:
27
        print(word)

返回结果：

1
Sentence(['Today', 'is', 'Tuesday'])
2
Today
3
is
4
Tuesday

我们知道一个对象可以迭代是因为实现了__iter__方法，但是在Sentence中并没有实现__iter__方法。那为什么可以迭代呢。

原因在于在python中实现了iter和getitem的都是可迭代的。首先会检查是否实现了iter方法，如果实现了则调用，如果没有但是实现了__getitem__方法。

Python就会创建一个迭代器。

尝试按照顺序获取元素。如果尝试失败则会抛出typeerror异常，提示object is not iterable.

因此：

如果对象实现了能返回迭代器的__iter__方法，那么对象就是可迭代的。如果实现了__getitem__方法，而且其参数是从零开始的索引。

这种对象也可以迭代。

我们用__iter__方法来改造之前的Sentence。在__iter__中返回一个可迭代对象iter(self.word)。当执行for word in s的时候就会调用__iter__方法

1
import re
2

3
re_word = re.compile(r'\w+')
4

5

6
class Sentence(object):
7
    def __init__(self, text):
8
        self.text = text
9
        self.word = re_word.findall(text)
10

11
    def __iter__(self):
12
        return iter(self.word)
13

14
    def __len__(self):
15
        return len(self.word)
16

17
    def __str__(self):
18
        return 'Sentence(%s)' % self.word
19

20

21
if __name__ == "__main__":
22

23
    s = Sentence("Today is Tuesday")
24
    print(s)
25

26
    for word in s:
27
        print(word)

再来看下next, next的作用是返回下一个元素，如果没有元素了，抛出stopIteration异常。

我们来看下next的使用方法。如果要遍历一个字符串，最简单的方法如下：

1
s = 'abc'
2

3
for char in s:
4
    print(char)

如果不用for方法，代码需要修改如下：

1
s = 'abc'
2

3
it = iter(s)
4

5
while True:
6
    try:
7
        print(next(it))
8
    except StopIteration:
9
        del it
10
        break

首先将s变成一个iter对象，然后不断调用next获取下一个字符，如果没有字符了，则会抛出StopIteration异常释放对it的引用

1
s = 'abc'
2

3
it = iter(s)
4

5
print(next(it))
6
print(next(it))
7
print(next(it))
8
print(next(it)) # StopIteration

因为只有3个字符，但是调用了4次it.next()导致已经找不到字符因此抛出异常。

总结：

可迭代对象：实现了__iter__方法，就是可迭代的，可以返回自身作为迭代器。也可以返回其他一个可迭代对象

迭代器#

迭代器是什么#

迭代器：在Python2中实现了next方法，在python3中实现了__next__方法。

首先要让x通过iter变成一个可迭代对象，然后使用迭代器来调用元素

使用迭代器好处就是：每次只从对象中读取一条数据，不会造成内存的过大开销。

Alt text

迭代器内存消耗检测#

可以看看它的内存占用：

使用python2.7.15+:

1
import sys
2
i = iter(range(1000000))
3
print sys.getsizeof(i)
4

5

6
r = range(1000000)
7
print sys.getsizeof(r)
8

9

10
y = xrange(1000000)    # 注意 xrange跟range的区别： xrange是range的迭代器的表达方式
11
print sys.getsizeof(y)

结果返回:

使用python 3.6+

1
import sys
2
i = iter(range(1000000))
3
print (sys.getsizeof(i))
4

5

6
r = range(1000000)
7
print (sys.getsizeof(r))

返回结果：

这里有个问题：为什么在python2跟Python3的运行结果相差这么大呢？ 这是因为python3内部机制已经将range转换成了一个迭代器了。

这里可以看的出来适合大的数据，比如好几个G的数据，使用了迭代器内存使用大幅度减少，这是迭代器最大的优点。

总结下：我们简单说迭代器就是访问集合元素，迭代器就是有一个next()方法的对象，而不是通过索引来计数的。

迭代器使用#

那么我们怎么能访问迭代器里面的元素呢？

迭代器有两个方法，分别是**iter()和next()**方法

这两个方法是迭代器最基本的方法一个用来获得迭代器对象，一个用来获取容器中的下一个元素。

itertools是python提供的非常高效创建与使用迭代器的模块

1
from itertools import chain
2
test = chain.from_iterable('ABCDEFG')
3
# print(test)
4
# print(dir(test)) # 查看类具体方法
5

6
print(test.__next__())  # 'A'
7
print(test.__next__())  # 'B'
8
print(test.__next__())  # 'C'
9

10
test2 = chain('AB', 'CDE', 'F')
11
print(list(test2))  # ['A', 'B', 'C', 'D', 'E', 'F']

我们知道迭代器是不支持索引的，原因就是索引需实现明元素确占用的内存地址，而迭代器是用到元素的时候才会创建。如下：

1
i = iter(range(3))  # 创建迭代器
2
# i.index(2)  # 获取元素为2的索引
3
# AttributeError: 'range_iterator' object has no attribute 'index'
4

5
# 列表
6
l = range(3)
7
print(l.index(2))  # 获取索引2

这个时候可以使用内建函数enumerate(),这个函数很重要。

1
for i, j in enumerate(iter(['A', 'B', 'C'])):
2
    # for i, j in enumerate(['A', 'B', 'C']):
3
    print(i, j)

运行结果返回：

可以看下这个函数的源码是怎么写的 ```python class enumerate(Iterator[Tuple[int, _T]], Generic[_T]): def __init__(self, iterable: Iterable[_T], start: int = ...) -> None: ... def __iter__(self) -> Iterator[Tuple[int, _T]]: ... if sys.version_info >= (3,): def __next__(self) -> Tuple[int, _T]: ... else: def next(self) -> Tuple[int, _T]: .. ```

生成器#

生成器是迭代器，但你只能遍历它一次(iterate over them once)

因为生成器并没有将所有值放入内存中，而是实时地生成这些值

1
mygenerator = (x * x for x in range(3))  # 生成器
2
# mygenerator = [x * x for x in range(3)] # 列表
3
for i in mygenerator:
4
    print("i=", i)
5

6
for i in mygenerator:
7
    print("New=", i)

运行结果：

1
i= 0
2
i= 1
3
i= 4

注意，你不能执行for i in mygenerator第二次，因为每个生成器只能被使用一次

yield生成器#

在Python中，使用生成器可以很方便的支持迭代器协议。

生成器通过生成器函数产生，生成器函数可以通过常规的def语句来定义，但是不用return返回，而是用yield一次返回一个结果，在每个结果之间挂起和继续它们的状态，来自动实现迭代协议。

也就是说，yield是一个语法糖，内部实现支持了迭代器协议

同时yield内部是一个状态机，维护着挂起和继续的状态。

下面看看生成器的使用：

1
def Zrange(n):
2
    i = 0
3
    while i < n:
4
        yield i
5
        i += 1
6

7

8
zrange = Zrange(3)
9
print(zrange)  # <generator object Zrange at 0x000002997DE75468>
10
print([i for i in zrange])  # [0, 1, 2]

在这个例子中，定义了一个生成器函数，函数返回一个生成器对象，然后就可以通过for语句进行迭代访问了。

其实，生成器函数返回生成器的迭代器。 “生成器的迭代器”这个术语通常被称作”生成器”。要注意的是生成器就是一类特殊的迭代器。作为一个迭代器，生成器必须要定义一些方法，其中一个就是next()。

如同迭代器一样，我们可以使用next()函数来获取下一个值。

生成器执行过程#

例子：

1
def Zrange(n):
2
    print("begin of Zrange")
3
    i = 0
4
    while i < n:
5
        print("before yield:", i)
6
        yield i
7
        i += 1
8
        print("after yield:", i)
9

10
    print("begin of Zrange")
11

12

13
zrange = Zrange(3)
14
# print(zrange)
15

16
print(zrange.__next__())
17
print("-" * 10)
18
print(zrange.__next__())
19
print("-" * 10)
20
print(zrange.__next__())
21
# print(zrange.__next__()) # StopIteration

运行结果：

1
begin of Zrange
2
before yield: 0
3
0
4
----------
5
after yield: 1
6
before yield: 1
7
1
8
----------
9
after yield: 2
10
before yield: 2
11
2

通过结果可以看到：

当调用生成器函数的时候，函数只是返回了一个生成器对象，并没有执行。
当next()方法第一次被调用的时候，生成器函数才开始执行，执行到yield语句处停止
next()方法的返回值就是yield语句处的参数（yielded value）
当继续调用next()方法的时候，函数将接着上一次停止的yield语句处继续执行，并到下一个yield处停止；如果后面没有yield就抛出StopIteration异常

总结：生成器是迭代器的一种，但功能方法比迭代器多

生成器创建#

生成器的创建可以使用yield关键字，也可以使用生成器表达式

1
(x*2 for i in range(10))

生成器判断#

判断是否为生成器函数可用isgeneratorfunction, 判断是否为生成器对象可用isgenerator

1
from inspect import isgeneratorfunction, isgenerator
2

3
g = (i for i in range(3))
4
print(isgenerator(g))  # True
5

6

7
def demo():
8
    yield 1
9

10

11
print(isgenerator(demo()))  # True
12
print(isgeneratorfunction(demo()))  # False
13
print(isgeneratorfunction(demo))  # True

yield与协程#

1
def coroutine():
2
    print("coroutine start...")
3
    result = None
4
    while True:
5
        s = yield result
6
        result = 'result:{}'.format(s)
7

8

9
c = coroutine()
10
c.send(None)  # coroutine start...
11

12
print(c.send("first"))  # result:first
13
print(c.send("second"))  # result:second
14

15
c.close()
16

17
# c.send("hello")  # StopIteration

第14章 可迭代的对象、迭代器和生成器#