python生成器类型怎么输出_Python生成器和迭代器

一、列表生成式

如果有这样一个列表[1,2,3,4,5,6,7,8,9,10] ,现在需要将列表里的每个元素乘以2，应该怎么做呢？

方法一：

#-*-coding:utf-8-*-

a= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]for index,i inenumerate(a):

a[index]*= 2

print(a) #[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

方法二：

#-*- coding:utf-8 -*-

a= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]print(list(map(lambda x:x*2,a))) #[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

似乎已经可以实现了，但是还有没有其他方法呢？

答案当然是有的，而且还很简洁，功能更强，不信，接着看：

#！/usr/bin/env python3#-*- coding:utf-8 -*-

#列表生成式

a = [1,2,3,4,5,6,7,8]

a= [i if i< 4 else i*i for i in a] #前三个数不变，后面的数都平方

print(a) #输出：[1, 2, 3, 16, 25, 36, 49, 64]

注意：

[i if i< 4 else i*i for i in a]可视为两部分，i if i<4 else i*i 为三元运算,视为一个整体，

看成一个’变量‘，for i in a 和这个变量组成列表生成式，i每在列表a中被赋值一次，'变量'就运行一次。

变量得出的结果就是列表中的元素。

这种写法就是列表生成式。

二、生成器

1、生成器的由来：

通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，

不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？

这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

2、创建生成器的简单方法

L = [x*2 for x in range(10)]print(l) #[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 列表

g= (x * 2 for x in range(10))print(g) # at 0x1022ef630> 生成器

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

那我们怎样取出我们想要的值呢？

方法一：通过next()函数获得generator的下一个返回值。

g = (x * 2 for x in range(4))print(g) # at 0x1022ef630> 生成器

print(next(g)) #0

print(next(g)) #2

print(next(g)) #4

print(next(g)) #6

print(next(g)) #StopIteration 生成结束会报错

注意：generator保存的是算法，每次调用next(g)就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。

方法二(推荐)：使用for循环，因为generator也是可迭代对象，至于可迭代对象待会儿会说，现在你知道生成器可使用for循环就行了。

a = (i for i in range(3))for i in a: #for循环输出生成器完成后不会报错，但while和手动生成完后会报错

print(i)'''输出：

0

1

2'''

3、我们可以推测一下生成器有哪些特点：

主要是这样三个：取一次生成一个，只能向前，生成完成后报错误提示(StopIteration)。

4、生成器的实际运用

先看一个斐波那契数列是怎样用函数生成的。

deffib(max):

n,a,b= 0,0,1 #设置初始值

while n < max: #执行次数

print(b) #打印每次执行后的值

a,b = b,a+b #交换赋值

n += 1

return 'end' #退出

fib(6) #函数调用

那这和生成器有什么关系呢？其实原理是一样的。fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，推算出后续任意的元素，这种逻辑其实非常类似generator。

我们来稍微修改一下这个函数：

#斐波拉契数列 和 yield

deffib(max):

n,a,b= 0,0,1

while n

yield b #把函数的执行过程冻结在这一步，并且把b的值，返回给外面的next()

#print(b)

a,b = b,a+b

n+= 1

return 'Done'f= fib(6) #内部代码不执行，只是将函数转为生成器#循环输出#for i in f:#print(i)

print(next(f))#输出：1 # next()唤醒冻结的执行过程，继续执行，直到碰到下一个yield

print(next(f),type(f)) #输出：1

print(next(f)) #输出：2

print(f.__next__()) #输出：3 #f.__next__()等同于next(f)

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

函数和生成器执行流程的区别：函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，

在每次调用next()的时候执行，遇到yield语句返回，再次被next()调用时从上次返回的yield语句处继续执行。

deffunc(n):

count=0while count

sign= yield count #yield 把函数的执行过程冻结在这一步，并且把count的值，返回给外面的next()

print('--sign--',sign)

count+= 1

return 666f= func(3)print( next(f)) #0

print( next(f)) #1

print(f.send('pause')) # 发送消息,唤醒并继续执行

print( next(f)) #2 print( next(f)) #报错：StopIteration: 666

'''函数中有了yield之后

1、函数名加()就变成了一个生成器

2、return在生成器里，代表生成器的中止，直接报错

next 唤醒并继续执行，只能默认发送消息None

函数中有了send之后,send('pause')

1、唤醒并继续执行

2、发送一个消息到生成器内部'''

我们在循环过程中不断调用yield，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来。

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

for n in fib(6):print(n)'''1

1

2

3

5

8'''

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

g = fib(6)whileTrue:try:

x=next(g)print('g:', x)exceptStopIteration as e:print('Generator return value:', e.value)break

'''g: 1

g: 1

g: 2

g: 3

g: 5

g: 8

Generator return value: done'''

View Code

还可通过yield实现在单线程的情况下实现并发运算的效果。

#_*_coding:utf-8_*_

importtimedefconsumer(name):print("%s 准备吃包子啦!" %name)whileTrue:

baozi= yield

print("包子[%s]来了,被[%s]吃了!" %(baozi,name))defproducer(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("jack")

View Code

三、迭代器

1、定义：可以被next()函数调用并不断返回下一个值的对象称为迭代器，Iterator。

2、可直接作用于for循环的数据类型有以下几种：

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

一类是：generator,包括生成器和带yield的生成器函数

这样可直接作用于for 循环的对象统称为可迭代对象：Iterable

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

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

from collections importIterableprint(isinstance([],Iterable)) #True

print(isinstance('abc',Iterable)) #True

4、可以使用 isinstance()判断一个对象是否是Iterator(迭代器)

from collections importIteratorprint(isinstance((x for x in range(5)),Iterator)) #True

print(isinstance([],Iterator)) #False

5、可迭代对象和迭代器的区别：

list、dict、str等虽然都是Itrable，但并不是迭代器，可以通过 iter()函数把list,dict,str等变成迭代器。

from collections importIteratorprint(isinstance(iter([]),Iterator)) #True

print(isinstance(iter('abc'),Iterator)) #True

6、迭代器和生成器的区别：

迭代器包括生成器，生成器都是迭代器(Iterator),但迭代器不一定是生成器。

7、小结：

凡是可作用于for循环的对象都是可迭代对象(Iterable).

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列。

集合数据类型如list,dict,str等都是可迭代对象但不是迭代器，但可以通过iter()函数获得一个迭代器对象。

python3中 for循环本质上就是通过不断调用next()函数实现的。