列表生成式,迭代器与生成器¶

列表生成式¶

需求

把列表里[0,1,2,3,4,5,6,7,8,9]每个值加1,如何实现?

>>> a = [0,1,2,3,4,5,6,7,8,9]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b = []
>>> for i in a:b.append(i+1)
...
>>> b
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> a = b
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 原值修改
>>> a = [0,1,2,3,4,5,6,7,8,9]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for index,i in enumerate(a): a[index] += 1
...
>>> print(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> a = [0,1,2,3,4,5,6,7,8,9]
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a = map(lambda x:x+1, a)
>>> a
<map object at 0x101be8128>
>>> for i in a:print(i)
...
1
2
3
4
5
6
7
8
9
10

还有一种写法:

>>> a = [i+1 for i in range(10)]
>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

这就叫列表生成

生成器¶

仅仅拥有生成某种东西的能力,如果不用__next__方法是获取不到值的.

通过列表生成式,我们可以直接创建一个列表.但是,受到内存限制,列表容量肯定有限.而且,创建一个包含100万个元素的列表,不仅占用很大的存储空间,如果我们仅需要访问前面几个元素,那后面绝大多数元素占用的空间都白白浪费了.

所以,如果列表元素可以按照某种算法推算出来,那我们是否可以循环的过程中不断推算出后续的元素呢?这样就不必创建完整的list,从而节省大量空间.在python中,这种一边循环一遍计算的机制,称为生成器: generator

生成器, 只有在调用时才会生成相应的数据.

创建生成器

()
yield

使用()创建生成器¶

要创建一个generator,有很多种方法,第一种方法很简单,只需要把一个列表生成式的[]改成(),就创建了一个generator

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

创建L和g的区别仅在于最外层的[] 和 () , L是一个list,而g是一个generator

我们可以直接打印出list的每一个元素,我们如何打印出generator的每一个元素?

使用next()函数,获得generator的下一个返回值

>>> next(g)
0
>>> next(g)
1
>>> next(g)
4
>>> next(g)
9
>>> next(g)
16
>>> next(g)
25
>>> next(g)
36
>>> next(g)
49
>>> next(g)
64
>>> next(g)
81
>>> next(g)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

generator保存的是算法那,每次调用next(g),就计算出g的下一个元素的值,知道计算到最后一个元素,没有更多的元素时,抛出一个StopIteration的错误.

使用next()实在是太变态了,正确的方法是使用for循环,因为generator也是可以迭代的对象

>>> g = (x * x for x in range(10))
>>> for n in g:
...   print(n)
...
0
1
4
9
16
25
36
49
64
81

但是用for循环调用generator时,发现拿不到generator的return语句的返回值.如果想要拿到返回值,必须捕获StopIteration错误,返回值包含在StopIteration的Value中.

>>> g = (x * x for x in range(5))
>>> while True:
...   try:
...     x = next(g)
...     print('g: ',x)
...   except StopIteration as e:
...     print("Generator return value: ",e.value)
...     break
...
g:  0
g:  1
g:  4
g:  9
g:  16
Generator return value:  None

yield¶

另一种创建方式,使用yield

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

>>> def scq():
...   print("11")
...   yield 1
...   print("22")
...   yield 2
...   print("33")
...   yield 3
...

把生成器赋值给一个对象

>>> r = scq()

查看r的数据类型并且输出r的值

>>> print(type(r),r)
<class 'generator'> <generator object scq at 0x101bd9eb8>

当执行生成器的__next__的时候,代码会按照顺序去执行,当执行到yield时会返回并退出,yield后面的值就是返回值,然后记录代码执行的位置,并退出.

>>> ret = r.__next__()
11

第二次执行的时候会根据上次代码执行的位置继续往下执行

>>> ret = r.__next__()
22
>>> ret = r.__next__()
33

如果__next__获取不到值得时候就会报StopIteration错误

>>> ret = r.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

利用生成器创建一个类似xrange的功能

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

# 创建一个生成器函数,函数名为range,n是传入的参数,也是输出的数的最大值
def range(n):
    # 默认从0开始
    start = 0
    # 进入while循环,如果最小值小于最大值就进入循环
    while start < n:
        # 第一次返回start,下面代码不执行
        yield start
        # 第二次进来的时候start += 1 ,然后进入下一次循环
        start += 1

# 停止的参数为5
obj = range(5)
# 第一个数赋值给n1
n1 = obj.__next__()
# 第一个数赋值给n2
n2 = obj.__next__()
n3 = obj.__next__()
n4 = obj.__next__()
n5 = obj.__next__()
# 输出这五个数
print(n1,n2,n3,n4,n5)

执行结果

➜  python_test python3 018-exercise-1.py
0 1 2 3 4

通过生成器实现协程并行运算

#_*_coding:utf-8_*_
__author__ = 'Alex Li'

import time
def consumer(name):
    print("%s 准备吃包子啦!" %name)
    while True:
       baozi = yield

       print("包子[%s]来了,被[%s]吃了!" %(baozi,name))


def producer(name):
    c = consumer('A')
    c2 = consumer('B')
    c.__next__()
    c2.__next__()
    print("老子开始准备做包子啦!")
    for i in range(10):
        time.sleep(1)
        print("做了2个包子!")
        c.send(i)
        c2.send(i)

producer("alex")

延迟计算¶

#列表解析
sum([i for i in range(100000000)])#内存占用大,机器容易卡死

#生成器表达式
sum(i for i in range(100000000))#几乎不占内存

迭代器¶

可直接用作for循环的数据类型有以下几种:

一类是集合数据类型,如list,tuple,dict,set,str等

一类是generator,包括生成器和带yield的generator function

这些可以直接作用于for循环的对象统称为可迭代对象: Iterable

可以使用isinstance()判断一个对象是否是Iterable对象:

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance("abc", Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100,Iterable)
False

而生成器不但可以作用于for循环,还可以被next()函数不断调用并返回下一个值,直到最后抛出StopIteration错误表示无法继续返回下一个值了.

可以被next()函数调用并不断返回下一个值的对象称为迭代器: Iterator

具有访问生成器的能力,可以访问到生成器的值,类似于生成器的__next__方法,一个值一个值的去迭代,只能够按照顺序的去查找

可以使用isinstance()判断一个对象是否是Iterator对象:

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance("abc", Iterator)
False

生成器都是Iterator对象,但是list,dict,str虽然是Iterable,却不是Iterator

把list,dict,str等Iterable变成Iterator可以使用iter()函数:

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

python的Iterator对象表示的是一个数据流,Iterator对象可以被next()函数调用并不断返回下一个数据,直到没有数据时抛出StopIteration错误.可以把这个数据流看作是一个有序序列,但我们却不能提前直到序列的长度,只能不断通过next()函数实现按需计算下一个数据,所以Iterator的计算是惰性的,只有在需要返回下一个数据时才会计算.

Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

特点:

访问者不需要关心迭代器内部的结果,仅需要通过next()方法不断去取下一个内容
不能随机访问集合中的某个值,只能从头到尾依次访问
访问到一半时不能往回退
便于循环比较大的数据集合,节省内存

优化上面range或xrange的生成器

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

def irange(start,stop,step=1):
    while start != stop:
        yield start
        start += step
    else:
        raise StopIteration

for n in irange(1,10):
    """for循环只要遇到StopIteration就会停止"""
    print(n)

ret = irange(1,20)
print(ret)  # 返回一个生成器,相当于只在内存中创建了一个值
print(list(ret))  # 如果想要得到全部的值,变成列表就可以

➜  python_test python3 018-exercise-2.py
1
2
3
4
5
6
7
8
9
<generator object irange at 0x101bd9990>
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

yield from¶

def gen1():
    for c in 'AB':
        yield c
    for i in range(3):
        yield i

print(list(gen1()))

def gen2():
    yield from 'AB'
    yield from range(3)

print(list(gen2()))

结果

['A', 'B', 0, 1, 2]
['A', 'B', 0, 1, 2]

小结¶

凡是可作用与for循环的对象都是Iterable类型
凡是可作用域next()函数的对象都是Iterator类型,它们表示一个惰性计算的序列
集合数据类型如list,dict,str等是Iterable但不是Iterator,不过可以通过iter()函数获得一个Iterator对象
python的for循环本质上就是通过不断调用next()函数实现的.

例如:

for x in [1, 2, 3, 4, 5]:
    pass

实际上完全等价于：

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break