概述#

本文记录遇到的部分迭代技巧

迭代工具函数#

其作用是生成可迭代对象

zip(iter1, iter2, …)#

返回一个zip对象，此对象可以生成一个元组，其中的元素分别由iter1、iter2、…等中的元素组成，且该元组的长度由最小的可迭代对象决定

enumerate(iter, start=0)#

生成带索引的枚举对象，默认索引值从0开始，也可指定一个值

代码示例#

1
nums = [110, 120, 119, 911]
2
names = ['警察', '医院', '消防']
3

4
for thing in zip(nums, names):
5
    print(thing)
6

7
> (110, '警察')
8
> (120, '医院')
9
> (119, '火警')
10

11
for ph, name in zip(nums, names):
12
    print('{0}的电话是：{1}'.format(str(name), str(ph)))
13

14
> 警察的电话是：110
15
> 医院的电话是：120
16
> 火警的电话是：119
17

18
for thing in zip(range(2), nums, names):
19
    print(thing)
20

21
> (0, 110, '警察')
22
> (1, 120, '医院')
23

24
d = dict(zip(nums, names)) # 可组成字典
25
print(d)
26

27
> {110:'警察', 120:'医院', 119:'火警'}
28

29
for thing in enumerate(names):
30
    print(thing)
31

32
> (0, '警察')
33
> (1, '医院')
34
> (2, '火警')
35

36
for thing in enumerate(names, 100):
37
    print(thing)
38

39
> (100, '警察')
40
> (101, '医院')
41
> (102, '火警')

yield函数#

一个例子：斐波那契数列#

斐波那契数列（Fibonacci）是这样一个数列，其任意一个数等于该数前两个数的和。

斐波那契数列的简单实现#

一般可用如下代码实现该数列：

1
def fibonacci(num):
2
    n, a, b = 0, 0, 1
3
    while n < num:
4
        print(b)
5
  a, b = b, a + b
6
  n += 1
7

8
fibonacci(5)
9

10
> 1
11
> 1
12
> 2
13
> 3
14
> 5

斐波那契数列实现的进一步讨论#

对于上面的实现函数，其实用性较差，因为这里直接print出数字，其返回值为None。其他函数无法获得该函数生成的数列。

因此，我们可以改进该函数，使其返回一个list：

1
def fabonacci(num):
2
    n, a, b = 0, 0, 1
3
    result = []
4
    while n < num:
5
        result.append(b)
6
  a, b = b, a + b
7
  n += 1
8
    return result
9

10
fab = fabonacci(5)
11
for n in fab:
12
    print(n)
13

14
> 1
15
> 1
16
> 2
17
> 3
18
> 5

使用yield函数改进#

对于上面的改进版本，当传入的参数num的值很大时，其生成的list也很大，很占内存。要进一步改进，我们可以用迭代器，不用list保存中间结果，而是用iterable对象来迭代。可以通过写一个类，重载该类的__iter__函数和__next__函数来实现。

但这样显然十分繁琐，yield函数就提供了这样一种功能：

1
def fabonacci(num):
2
    n, a, b = 0, 0, 1
3
    while n < num:
4
        yield b
5
  a, b = b, a + b
6
  n += 1
7

8
for n in fabonacci(5):
9
    print(n)
10

11
> 1
12
> 1
13
> 2
14
> 3
15
> 5

仅仅通过把print(b)改成yield b就可以了，十分的简洁、高效。

一个带有yield的函数就是一个generator。这样的函数与普通函数的不同在于，对该函数进行调用时不会执行任何函数代码，直到对其调用next才开始执行（for循环中自动调用next）。

yield的另一个应用场景#

文件读取时，若直接对文件对象使用read()函数，会导致不可预测的内存占用。可以通过设定一定大小的缓冲区来不断读取文件内容：

1
def read_file(file_path, block_size=1024):
2
    with open(file_path, 'rb') as f:
3
        while True:
4
      block = f.read(block_size)
5
      if block:
6
          yield block
7
      else:
8
          return