我们在前面应该写过类似的代码
for i in [1,2,3,4,5]: print(i)
for in 语句看起来很直观,很便于理解,比起C++或Java早起的
for (int i = 0; i<n;i++) printf("d ",a[i])
是不是简洁清晰的多。但是我们有没有想过Python在处理for in语句的时候,具体发生了什么吗?什么样的对象可以被for in用来枚举呢?
所以,这一节我们就深入到Python的容器类型实现底层看一看,了解一下迭代器和生成器。
前面用过的容器、可迭代对象和迭代器
容器这个概念还是比较容易理解的,我们说过,Python中一切皆为对象,对象的抽象就是类,而对象的集合就是容器。
l = [0,1,2] t = (0,1,2) d = {0:0,1:1,2:2}
s = set([0,1,2])
上面的列表,元组、字典和集合都是容器。对于容器,我们可以很直观的想象成很多个元素在一起的单元;而不同容器的区别,正式在于内部数据结构的实现方法。然后我们就可以针对不同的场景,选择不同时间复杂度和空间复杂度的容器。
所有的容器都是可迭代的(iterable)。这里的迭代,和枚举是完全不同的,这里的迭代可以想象成去买个苹果,卖家并声明他有多少库存,这样,每次去买一个苹果的时候卖家采取的行为不外乎给你拿一个苹果,要么就是告诉你苹果已经卖完了,所以你并不需要知道卖家是怎么在仓库内存放苹果的。
严谨 都说,迭代器(iterator)提供了一个next的方法,调用这个方法后,要么叨叨容器的下一个对象,要么得到一个StopIteration的错误。我们并不需要想列表一样指定元素的索引,因为字典和集合是没有索引的说法的(字典采用哈希表实现)。我们只需要知道,next函数可以不重复不遗漏的拿到所有的元素就可以了。
而可迭代对象,是通过iter()函数返回一个迭代器,在通过next()函数就可以实现遍历。for in语句将这个过程隐式化,我们只需要大概知道他怎么做就行了。
我们再看看下面的代码,主要展示了如何判断一个对象是否可迭代。当然还有一种用法,是isinstance(obj,Iterable)。
def is_iterable(param): try: iter(param) return True except TypeError: return False params = [ '1234', 1234, [1,2,3,4], set([1,2,3,4]), {1:1,2:2,3:3}, (1,2,3,4) ] for param in params: print('{} is iterable?{}.'.format(param,is_iterable(param)))
1234 is iterable?True. 1234 is iterable?False. [1, 2, 3, 4] is iterable?True. {1, 2, 3, 4} is iterable?True. {1: 1, 2: 2, 3: 3} is iterable?True. (1, 2, 3, 4) is iterable?True.
通过上面的代码可以发现,在给出的类型中,只有数字1234是不可迭代的,其余数据类型都可以迭代。
what is 生成器?
那么生成器又是什么呢?在很多语言中,生成器都没有相对应的模型,所以这里只需要记住一点:生成器就是懒人版的迭代器。
如果想要在迭代器中枚举他的元素,这些元素要事先生成。这里,我们看看下面的例子
import os import psutil def show_memory_info(hint): pid = os.getpid() p = psutil.Process(pid) info = p.memory_full_info() memory = info.uss / 1024. /1024 print('{} memory used:{}MB'.format(hint,memory)) def test_iterator(): show_memory_info('initing iterator') list_1 = [i for i in range(100000000)] show_memory_info('after iterator initiated') print(sum(list_1)) def test_generator(): show_memory_info('intiting generator') list_2 = (i for i in range(100000000)) show_memory_info('after generator initiated') print(sum(list_2)) show_memory_info('after sum called') test_iterator() test_generator()
initing iterator memory used:7.21875MB after iterator initiated memory used:1848.28515625MB 4999999950000000 intiting generator memory used:1.7109375MB after generator initiated memory used:1.7421875MB 4999999950000000 after sum called memory used:2.109375MB
我们用[i for i in range(100000000)]声明了一个包含一个亿元素的列表(声明了一个迭代器),每个元素在生成以后都保存在内存里,通过代码可以发现他们占用了巨大的内存空间,如果内存不够的话就直接OOM错误了。
不过,我们并不需要在内存中同事保存这么多东西,比方元素求和,我们只需要知道每个元素相加的那一刻是多少就可以了,用完扔掉即可。
于是,生成器在这里就体现出作用了。在我们调用next()函数的时候,才会生成下一个变量,生成器在Python中的写法是用小括号括起来:
l = (i for i in range(100000000))
这样一来,可以清晰的看到生成器是不会像迭代器一样占用大量内存的,只有在被使用的时候才会调用,而且生成器在初始化的时候,并不需要一次生成操作,相比于例子中的第一个测试函数,第二个函数节省了一次生成一亿个元素的过程,因此耗时明显变短。
此外,生成器并不是单单节省了时间和计算机资源,我们可以看看下面的例子。
生成器还有什么作用?
数学中有一个恒等式:
(1+2+3+...+n)^2 = 1^3+2^3+3^3+...+n^3
如果我们想验证一下他,要怎么码代码呢?
def generator(k): i = 1 while True: yield i**k i += 1 gen_1 = generator(1) gen_3 = generator(3) print(gen_1) print(gen_3) def get_sum(n): sum_1 ,sum_3 = 0,0 for i in range(n): next_1 = next(gen_1) next_3 = next(gen_3) print('next_1 = {},next_3 = {}'.format(next_1,next_3)) sum_1 += next_1 sum_3 += next_3 print(sum_1*sum_1,sum_3) get_sum(10)
首先,可以注意一下generator()这个函数,他返回了一个生成器。
下面的yield可以说是程序的关键,因为函数运行到这里的时候,是会暂停的,然后跳出到next()函数处。而i**k则成了next()函数的返回值。
这样,每次next(gen)函数被调用的时候,暂停的程序就重新复活,从yield处向下继续执行,同时要注意的是,局部变量i并没有被清除掉,而是会继续累加,所以next_1和next_3是不停变化的。
所以说,这个生成器是可以无限制的一直进行下去。迭代器是一个有限的集合,而生成器则可以视为一个无限集合,我们只管调用next()就可以,生成器根据运算会自动生成新的元素返回,非常方便。
我们看看下面这段代码
def index_normal(L,target): result = [] for i,num in enumerate(L): if num == target: result.append(i) return result print(index_normal([1,2,3,4,5,6,7,8,2],2))
就是获取列表中和指定元素相同的索引值组成的列表,那我们用下面的方法是不是简单的多?
def index_generator(L,target): for i,num in enumerate(L): if num == target: yield i print(list(index_generator([1,2,3,4,5,6,7,8,2],2)))
到这里就不用多做解释了,唯一需要强调的是index_generator会返回一个Generator对象,需要用list转换为列表后才能打印。
这里有个事情要强调:
在Python的语言规范中,用更少,更加清晰的代码实现相同的功能一直是被推崇的办法。因为这样能够很有效的提高代码的可读性,减少出错概率,也能方便他人快速准确的理解作者的意图。但是,这里的“更少”的前提是清晰,而非使用更多的魔术操作,即便减少了代码反而增加了阅读的难度。
回归正题,我们看一看这样的问题,给定两个序列,判定第一个序列是不是第二个序列的子序列。(子序列,一个列表的元素在第二个列表中按顺序出现,注意按顺序,比方[1,3,5]是[1,2,3,4,5]的子序列,而[1,5,3]就不是)
a = ['a','c','d'] b = ['a','b','c','d','e'] def is_subsequence(list_1,list_2): if not list_1: return True else: for x in list_1: if not (x in list_2): return False else: if is_subsequence(list_1[list_1.index(x)+1:],list_2[list_2.index(x)+1:]): return 'list_1 is subsequence of list_2' else: return 'list_1 is not subsequence of list_2' print(is_subsequence(a,b))
上面的代码就是用了叫做‘贪心算法’的常规算法,我们维护两个指针指向两个列表的最开始,然后对第二个列表一路扫过去,如果某个数字和第一个指针指的一样,那么就把第一个指针前进一步。直到一个指针移出第一个序列。
那么我们要用生成器和迭代器的方法该怎么实现呢?
我们先看一个极简版的
a = ['a','c','d'] b = ['a','b','c','d','e'] a1 = ['a','d','c'] def is_subsequence(a,b): b = iter(b) return all(i in b for i in a) print(is_subsequence(a,b)) print(is_subsequence(a1,b))
看完是不是感觉一脸蒙逼?没关系,我们把他复杂化,一步一步看
a = ['a','c','d'] b = ['a','b','c','d','e'] def is_subsequence(a,b): b = iter(b) print(b) gen = (i for i in a) print(gen) for i in gen: print(i) gen = ((i in b)for i in a) print(gen) return all(((i in b)for i in a)) print(is_subsequence(a,b))
在函数开始,先把列表b转换成了迭代器,用途后面再讲
接下来的gen=。。。比较好理解,就是产生一个生成器,这个生成器用来变量列表a,所以可以输出a里的数据。而i in b就需要好好理解了,这里是不是能联想到 for in 语句?
没错,这里的i in b大概可以等价于下面的代码
while True: val = next(b) if val == i: yield True
所以这里就非常巧妙的利用都了生成器的特性,next()函数运行的时候,保存了当前的指针,再看看下面的示例:
b = (i for i in range(5)) print(2 in b) print(6 in b) ####输出#### True False
最后的all()函数就很简单了,他用来判断一个迭代器的元素是否全为True,如果是则返回True,否则就返回False。
总结
容器是可迭代对象,可迭代对象调用iter()函数,可以得到一个迭代器,迭代器可以通过next()获得下一个元素从而支持遍历。
生成器是一种特殊的迭代器(注意反向逻辑是不成立的)。使用生成器,可以写出来更加清晰的代码,合理使用生成器可以有效降低内存使用、优化程序结构、提高程序速度。
生成器在Python2的版本上是协程的一种重要实现方式,而在3.5引入asyncawait语法糖后,生成器实现协程的方式就已经落后了。
课后思考
对于一个有限元素的生成器,如果迭代完成后,继续调用next()会发生什么呢?生成器可以遍历多次么?