Python入门（四）

集合与迭代#

1
numbers = [1, 2, 3, 4, 5]
2
for number in numbers:
3
    print(number)
4
else:
5
    print("Finished printing all numbers.")

Python里while和for是可以接else的，循环正常结束就会执行，如果循环内部因异常终止的话就不执行。

1
letters = ["a", "b", "c"]
2

3
first_iterator = letters.__iter__()
4
second_iterator = letters.__iter__()
5

6
print(type(first_iterator)) # <class 'list_iterator'>
7

8
print(first_iterator.__next__()) # a
9
print(first_iterator.__next__()) # b
10
print(second_iterator.__next__()) # a
11
print(first_iterator.__next__()) # c
12
try:
13
    print(first_iterator.__next__()) # Raises StopIteration
14
except StopIteration:
15
    print("StopIteration raised for first_iterator")
16

17
iterator = iter(letters)
18
print(next(iterator)) # a
19
print(next(iterator)) # b
20
print(next(iterator)) # c
21
print(next(iterator, "No more")) # No more

可以直接用__iter__和__next__来获取和使用迭代器。

但总是应该使用Python提供的公共API。功能、类型检查、错误信息都会更强大。比如next()可以提供第二个参数，在没有下一个元素时不抛异常，而是返回默认值。

1
class Queue:
2
    def __init__(self):
3
        self._queue = []
4

5
    def enqueue(self, item):
6
        self._queue.append(item)
7

8
    def __iter__(self):
9
        return QueueIterator(self._queue)
10

11
    def __len__(self):
12
        return len(self._queue)
13

14
class QueueIterator:
15
    def __init__(self, queue):
16
        self._queue = queue
17
        self._index = 0
18

19
    def __iter__(self):
20
        return self
21

22
    def __next__(self):
23
        if self._index < len(self._queue):
24
            item = self._queue[self._index]
25
            self._index += 1
26
            return item
27
        else:
28
            raise StopIteration
29

30

31
queue = Queue()
32
queue.enqueue(1)
33
queue.enqueue(2)
34
for item in queue:
35
    print(item)

需要自定义可迭代类时，一个简单的写法如上。

生成器和推导式#

1
import time
2

3
slow_list = [1, time.sleep(1), 2, time.sleep(1), 3]
4
# Wait for 2 seconds
5

6
print(slow_list) # [1, None, 2, None, 3]

迭代器的思想本质是惰性求值，当要使用值的时候再进行计算，而不是定义值时就计算。

上面的例子模拟了一个在定义时进行耗时计算的列表。打印语句需要等待两秒。

如果这里的计算极端耗资源，可能卡死，可能Out of Memory。在Python里处理这种情况的最好方法就是惰性求值。

1
from itertools import product
2

3
def get_license_plate():
4
    for letter in product('ABCDEFGHIJKLMNOPQRSTUVWXYZ', repeat=3):
5
        for number in product('0123456789', repeat=3):
6
            yield ''.join(letter) + ''.join(number)
7

8
license_plate_generator = get_license_plate()
9
print(next(license_plate_generator)) # AAA000
10
print(next(license_plate_generator)) # AAA001

迭代器的一个强大替代品是生成器。含有yield语句的函数就是生成器函数。调用它时，会返回一个生成器对象。

每次调用next，就会从上次暂停的地方开始执行，直到又碰到yield，暂停，返回值。

当生成器函数终止时，不管是执行到末尾，还是提前return，都会触发异常StopIteration。

可以将迭代器看成一种协议，要求对象实现__iter__和__next__。而生成器Generator对象实现了这个协议，是迭代器的子集，对代码编写者来说用起来更方便。

Generator对象内部维护了一个frame，存储了指令指针、局部变量、栈。调用next()会恢复frame从上次停下的字节码位置继续执行。yield完又会冻结frame。

1
from random import randint, choice
2

3
colors = ["red", "green", "blue", "yellow", "purple"]
4
vehicles = ["car", "bike", "truck", "bus", "scooter"]
5

6
# 生成一个有2到10辆随机颜色的摩托车的车队
7
def biker_gang():
8
    for _ in range(randint(2, 10)):
9
        color = choice(colors)
10
        yield f"{color} motorcycle"
11

12
# 百分之二的概率生成摩托车队
13
def traffic():
14
    while True:
15
        if randint(1, 50) == 50:
16
            yield from biker_gang()
17
            continue
18
        vehicle = choice(vehicles)
19
        color = choice(colors)
20
        yield f"{color} {vehicle}"

yield from会把执行流转交给另一个生成器。

1
# def license_plates():
2
#     for num in range(10):
3
#         yield f'ABC {num:03}'
4

5
# license_plates = license_plates()
6

7
license_plates = (
8
    f'ABC {num:03}' for num in range(10)
9
)
10

11
for plate in license_plates:
12
    print(plate)

没被注释掉的版本是生成器表达式写法，是语法糖。写起来像把for倒过来写。

1
g = (x * 2 for x in range(5))
2

3
l = [x * 2 for x in range(5)]
4

5
s = {x * 2 for x in range(5)}
6

7
d = {x: x * 2 for x in range(5)}
8

9
print(g)  # <generator object <genexpr> at 0x1002eab50>
10
print(l)  # [0, 2, 4, 6, 8]
11
print(s)  # {0, 2, 4, 6, 8}
12
print(d)  # {0: 0, 1: 2, 2: 4, 3: 6, 4: 8}

把生成器表达式的括号变一下就变成了推导式。推导式只是语法糖，也没有惰性求值。

1
def echo():
2
    while True:
3
        received = yield
4
        print(f"收到: {received}")
5

6
gen = echo()
7
gen.send(None)
8
gen.send("hello")  # 收到: hello
9
gen.send("world")  # 收到: world

yield出现在等式右边时也可以接收值。这是简单协程的写法，现代Python基本没人用了。