python中的迭代、生成器等等

时间:2021-12-25 03:04:54

本人对编程语言实在是一窍不通啊。。。今天看了廖雪峰老师的关于迭代,迭代器,生成器,递归等等,word天,这都什么跟什么啊。。。

1.关于迭代

  如果给定一个list或tuple,我们可以通过for循环来遍历这个list或tuple,这种遍历我们称为迭代(Iteration)(Iteration的中文意思就是:反复、重复、迭代等)。而这些for循环所遍历的对象(list or tuple 等)成为可迭代对象(Iterable)。

  也就是说“迭代”就是一个动作或者过程,可以把list或tuple中的元素一个个检查一遍(遍历)。如下:

1 >>> for i in range(0,10):
2        print  (i)

 

结果会是  0   1 2 3 4  5 6 7 8 9    这个过程就是迭代,而这里的range(0,10)就是可迭代对象(Iterable)。所以,当我们使用for循环时,只要作用于一个可迭代对象,for循环就可以正常运行,而我们不太关心该对象究竟是list还是其他数据类型。

 

  1.1 判断一个对象是否是可迭代对象

  通过collections模块的Iterable类型来判断:

1 >>>from collections import Iterable
2 >>>isinstance('abc',Iterable)  #str 'abc' 是否可迭代(Iterable)
3   True
4 >>>isinstance([1,2,3],Iterable) #list [1,2,3] 是否可迭代(Iterable)
5   True
6 >>>isinstance(123,Iterable) # 整数123 是否可迭代

2.生成器

   在Python中,一边循环一边计算的机制,称为生成器:generator。定义generator有两种方式。

  2.1 定义generator的第一种方法

1 >>> L = [x * x for x in range(10)]
2 >>> L
3 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4 >>> g = (x * x for x in range(10))
5 >>> g
6 <generator object <genexpr> at 0x1022ef630>

 

这一种方法很简单,把一个列表生成式[]改成(),就创建了generator。这里创建Lg的区别仅在于最外层的[]()L是一个list,而g是一个generator。如果要一个一个把g里面的元素打印出来,可以通过next()函数获得generator的下一个返回值:

 1 >>> next(g)
 2 0
 3 >>> next(g)
 4 1
 5 >>> next(g)
 6 4
 7 >>> next(g)
 8 9
 9 >>> next(g)
10 16
11 >>> next(g)
12 25
13 >>> next(g)
14 36
15 >>> next(g)
16 49
17 >>> next(g)
18 64
19 >>> next(g)
20 81
21 >>> next(g)
22 Traceback (most recent call last):
23   File "<stdin>", line 1, in <module>
24 StopIteration

 

 generator保存的是算法,每次调用next(g),就计算出g的下一个元素的值,直到计算到最后一个元素,没有更多的元素时,抛出StopIteration的错误。但是,我们创建了一个generator后,基本上永远不会调用next(),而是通过for循环来迭代它:

 1 >>> g = (x * x for x in range(10))
 2 >>> for n in g:
 3 ...     print(n)
 4 ... 
 5 0
 6 1
 7 4
 8 9
 9 16
10 25
11 36
12 49
13 64
14 81

 

  2.1 定义generator的第二种方法

第二种方法是通过函数来定义。

著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到:

1, 1, 2, 3, 5, 8, 13, 21, 34, ...

斐波拉契数列用列表生成式写不出来,但是,用函数把它打印出来却很容易:

1 def fib(max):
2     n, a, b = 0, 0, 1
3     while n < max:
4         print(b)
5         a, b = b, a + b #这里指的是a=b,b=a+b
6         n = n + 1
7     return 'done'

 我现在才知道为什么要加一个max参数,利用n<max 正好可以使a+b的次数等于输入的max,例如fib(10),那么结束循环的时候a+b正好10次。

测试代码如下:

fib(6):
1
1
2
3
5
8
'done'

仔细观察,可以看出,fib函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任意的元素,这种逻辑其实非常类似generator。

也就是说,上面的函数和generator仅一步之遥。要把fib函数变成generator,只需要把print(b)改为yield b就可以了:

1 def fib(max):
2     n, a, b = 0, 0, 1
3     while n < max:
4         yield b
5         a, b = b, a + b
6         n = n + 1
7     return 'done'

这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字,那么这个函数就不再是一个普通函数,而是一个generator

1 >>> f = fib(6)
2 >>> f
3 <generator object fib at 0x104feaaa0>

把函数改成generator后,我们基本上从来不会用next()来获取下一个返回值,而是直接使用for循环来迭代:

1 >>> for n in fib(6):
2 ...     print(n)
3 ...
4 1
5 1
6 2
7 3
8 5
9 8

 

这里,最难理解的就是generator和函数的执行流程不一样。函数是顺序执行,遇到return语句或者最后一行函数语句就返回。而变成generator的函数,在每次调用next()的时候执行,遇到yield语句返回,再次执行时从上次返回的yield语句处继续执行。

 

 

再看下面这个例子:

1 def odd():
2     print('step 1')
3     yield 1
4     print('step 2')
5     yield(3)
6     print('step 3')
7     yield(5)

调用该generator时,首先要生成一个generator对象,然后用next()函数不断获得下一个返回值:

 1 >>> o = odd()
 2 >>> next(o)
 3 step 1
 4 1
 5 >>> next(o)
 6 step 2
 7 3
 8 >>> next(o)
 9 step 3
10 5
11 >>> next(o)
12 Traceback (most recent call last):
13   File "<stdin>", line 1, in <module>
14 StopIteration

可以看到,odd不是普通函数,而是generator,在执行过程中,遇到yield就中断下次又继续执行。执行3次yield后,已经没有yield可以执行了,所以,第4次调用next(o)就报错。