py8 列表生成式 迭代器 生成器

时间  2019-12-07
标签 py8 列表 生成 迭代 成器 繁體版
原文   原文链接

列表生成式，迭代器&生成器

列表生成式

列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],我要求你把列表里的每一个值加1，你怎么实现？你可能会想到2种方式html

普通青年版node

>>> 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]

原值修改python

a = [1,3,4,6,7,7,8,9,11]

for index,i in enumerate(a):
    a[index] +=1
print(a)

文艺青年算法

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

还有一种叫作列表生成式并发

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

生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。app

要建立一个generator，有不少种方法。第一种方法很简单，只要把一个列表生成式的[]改为()，就建立了一个generator：ide

>>> 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 0x1022ef630>

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

咱们能够直接打印出list的每个元素，但咱们怎么打印出generator的每个元素呢？spa

若是要一个一个打印出来，能够经过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(g)实在是太变态了，正确的方法是使用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

因此，咱们建立了一个generator后，基本上永远不会调用next()，而是经过for循环来迭代它，而且不须要关心StopIteration的错误。

generator很是强大。若是推算的算法比较复杂，用相似列表生成式的for循环没法实现的时候，还能够用函数来实现。

好比，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数均可由前两个数相加获得：

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

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

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

注意，赋值语句：

?
1
a, b = b, a + b

至关于：

?
1
2
3
t = (b, a + b) # t是一个tuple
a = t[ 0 ]
b = t[ 1 ]

但没必要显式写出临时变量t就能够赋值。

上面的函数能够输出斐波那契数列的前N个数：

?
1
2
3
4
5
6
7
8
9
10
11
12
>>> fib( 10 )
1
1
2
3
5
8
13
21
34
55
done 
 
 
仔细观察，能够看出，fib函数其实是定义了斐波拉契数列的推算规则，能够从第一个元素开始，推算出后续任意的元素，这种逻辑其实很是相似generator。
 
 
也就是说，上面的函数和generator仅一步之遥。要把fib函数变成generator，只须要把print(b)改成yield b就能够了：
 
 
 
  
 
   复制代码 
  
 
  
def fib(max):
    n,a,b = 0,0,1

    while n < max:
        #print(b)
        yield  b
        a,b = b,a+b

        n += 1

    return 'done' 
 
  
 
   复制代码 
  
 
 
 
 
这就是定义generator的另外一种方法。若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator：
 
 
 
  
>>> f = fib(6)
>>> f
<generator object fib at 0x104feaaa0>
 
 
 
 
这里，最难理解的就是generator和函数的执行流程不同。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回（会把yield后的内容输出后保存断点返回），再次执行时从上次返回的yield语句处继续执行。
 
 
 
  
 
   复制代码 
  
 
  
data = fib(10)
print(data)

print(data.__next__())
print(data.__next__())
print("干点别的事")
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())
print(data.__next__())

#输出
<generator object fib at 0x101be02b0>
1
1
干点别的事
2
3
5
8
13
 
  
 
   复制代码 
  
 
 
 
 
在上面fib的例子，咱们在循环过程当中不断调用yield，就会不断中断。固然要给循环设置一个条件来退出循环，否则就会产生一个无限数列出来。
 
 
一样的，把函数改为generator后，咱们基本上历来不会用next()来获取下一个返回值，而是直接使用for循环来迭代：
 

 

 
 
 
  复制代码 
 
 
 
>>> for n in fib(6):
...     print(n)
...
1
1
2
3
5
8
 
 
 
  复制代码 
 
 

 

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

 
 
 
  
 
   
 
    ? 
   
 
   
 
     
     
 
       
       

         1 
       
 
       

         2 
       
 
       

         3 
       
 
       

         4 
       
 
       

         5 
       
 
       

         6 
       
 
       

         7 
       
 
       

         8 
       
 
       

         9 
       
 
       

         10 
       
 
       

         11 
       
 
       

         12 
       
 
       

         13 
       
 
       

         14 
       
 
       

         15 
       
 
       

         16 
       
 		 
       
       
 
        
 
         >>> g  
         = 
         fib( 
         6 
         ) 
        
 
        
 
         >>>  
         while 
         True 
         : 
        
 
        
 
         ...      
         try 
         : 
        
 
        
 
         ...         x  
         = 
         next 
         (g) 
        
 
        
 
         ...          
         print 
         ( 
         'g:' 
         , x) 
        
 
        
 
         ...      
         except 
         StopIteration 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 
        
 
       
 		 
     
 
     
   
 
  
 
 
 

 

PEP 342 添加了 .throw(...) 和 .close() 方法（前者的做用是让调用方抛出异常，在生成器中处理；后者的做用是终止生成器）
 

 
 

关于如何捕获错误，后面的错误处理还会详细讲解。
 

还可经过yield实如今单线程的状况下实现并发运算的效果　　
 

 
  
  
 
 
  
 
   复制代码 
  
 
  
#_*_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")
 
  
 
   复制代码 
  
 
 
 
 经过生成器实现协程并行运算 

 

关于yield的别的解析部分：
 

（1）yield后面能够加多个数值（能够是任意类型），但返回的值是元组类型的。
 

 
 
def get():
    m = 0
    n = 2
    l = ['s',1,3]
    k = {1:1,2:2}
    p = ('2','s','t')
    while True:
        m += 1
        yield m
        yield m ,n ,l ,k ,p
        
it = get()
print(next(it)) #1
print(next(it)) #(1, 2, ['s', 1, 3], {1: 1, 2: 2}, ('2', 's', 't'))

print(next(it)) #2
print(type(next(it))) #<class 'tuple'>
 

 

若是再加一句:
 

 
 
print(type(next(it))) #<class 'int'>  #返回的是整形
 

 

因此返回值的类型，应该是当前调用时，yield 返回值的类型。
 

（2）关于原函数的return部分return的东西变成了StopIteration异常的值。
 

在一个 generator function 中，若是没有 return，则默认执行至函数完毕，若是在执行过程当中 return，则直接抛出 StopIteration 终止迭代。
 

 
 
def fib(max): #10
    n, a, b = 0, 0, 1
    while n < max: #n<10
        #print(b)
        yield b
        a, b = b, a + b
        n = n + 1
    return '---done---'

#f= fib(10)
g = fib(6)
while True:
    try:
        x = next(g)
        print('g:', x)
    except StopIteration 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---

 

 

 
 

 
 
def gen(max):
    b = 123
    a = 0
    while a < max:
        a += 1
        yield a
        return 'done'
    return 'done---'

g = gen(5)
print(next(g))  # 这里在yield断点那，还没执行return
next(g)  # 返回断点，执行return，抛出异常


1  # next（）的返回值：yield后面跟的参数
Traceback (most recent call last):
  File "H:/python/workspace/day04/generator.py", line 17, in <module>
    next(g)
StopIteration: done   # 异常的值为return 后的值
 

 

（3）yield 能够还可以接受参数
 

send()和next()的区别就在于send可传递参数给yield表达式，这时候传递的参数就会做为yield表达式的值，因此也能够认为next（）等同于send(None)。
 

send()和next()都有返回值，他们的返回值是当前迭代遇到的yield的时候，yield后面表达式的值，其实就是当前迭代yield后面的参数。
 

 
 
def f(maxx):
    n, a, b = 0, 1, 1
    while n < maxx:
        # print(b)
        y = yield b
        a, b = b, a + b
        n += 1
        print(y)
    return 'error_name'  # 原函数的return变成了迭代完报出错误的值(value)  


fi = f(6)  # 将一个函数变成生成器，并赋值给fi，每次迭代的值都是yield右边的值
print(fi.__next__())  # 运行一次生成器，到yield处中断，运行下面的程序
print(fi.send('Done'))  # 回到第一次运行的生成器的yield中断处，并把Done赋予yield，而后执行下面的程序，到yield再次中止
fi.send('Done')  # 若是这句换成print(fi.send('Done')),则会输出3 
print(fi.send('Done'))  # next和send的返回值都是fi迭代器本次的值

1
Done
2
Done
Done
5
 

 

（4）调用一次next是从上次yield到下一次yield结束，并不必定是只走一遍生成器中的循环
 

 
 
def fun(num):
    i = 1
    while i < num:
        if (i % 2):
            yield i
        i += 1


f = fun(15)
print(next(f))
print(next(f))  # 每一次next不定只走一遍fun的循环，这里走了两次
print(f.__next__())

for i in f:  # for循环迭代生成器同理
    print(i)

1
3
5
7
9
11
13
 

 

迭代器
 

咱们已经知道，能够直接做用于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。
 

可使用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
 

 

你可能会问，为何list、dict、str等数据类型不是Iterator？
 

这是由于Python的Iterator对象表示的是一个数据流，Iterator对象能够被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。能够把这个数据流看作是一个有序序列，但咱们却不能提早知道序列的长度，只能不断经过next()函数实现按需计算下一个数据，因此Iterator的计算是惰性的，只有在须要返回下一个数据时它才会计算。
 

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

 
 

经过__iter__/__next__获得一些类（容器）中迭代器的理解
 

Python的迭代器协议须要 __iter__() 方法返回一个实现了 __next__() 方法的迭代器对象。 若是你只是迭代遍历其余容器的内容，你无须担忧底层是怎样实现的。你所要作的只是传递迭代请求既可。
 

 
 
class squares:
    def __init__(self, start, stop):
        self.flag = start - 1
        self.value = self.flag
        self.stop = stop
    def __iter__(self):
        self.value = self.flag
        return self  # 返回一个实现了__next__()方法的迭代器对象
    def __next__(self):
        if self.value == self.stop:
            raise StopIteration
        self.value += 1
        return self.value

a = squares(1,5)
b = squares(1,5)
s = 0
while s<=41:
    for i in a:  # 这里会调用__iter__()而后返回获得一个迭代器对象，而后一直调用__next__()直到报StopIteration后，循环没有结束的话从新调用__iter__()返回迭代器对象，而后next
        s= s + i
        print(s)

1
3
6
10
15  #
16
18
21
25
30  #
31
33
36
40
45
 

 

到时迭代器中止工做，实现了三圈循环。
 

 
 
    能够得出：
 
 
迭代器走完一轮，抛出异常后，再次调用会先进行__iter__(),再进行__next__()。
 
 
 
  
class Node:
    def __init__(self, value):
        self._value = value
        self._children = []

    def __repr__(self):
        return 'Node({!r})'.format(self._value)

    def add_child(self, node):
        self._children.append(node)

    def __iter__(self):
        return iter(self._children)

# Example
if __name__ == '__main__':
    root = Node(0)
    child1 = Node(1)
    child2 = Node(2)
    root.add_child(child1)
    root.add_child(child2)
    # Outputs Node(1), Node(2)
    for ch in root:  # root会先调用__iter__()而后获得了一个可迭代对象
        print(ch)
 
 
 这里的 iter() 函数的使用简化了代码， iter(s) 只是简单的经过调用 s.__iter__() 方法来返回对应的迭代器对象， 就跟 len(s) 会调用 s.__len__() 原理是同样的。  

 

迭代器要注意一点，迭代器只能单次循环
 

 

上图可见，for循环只能输出一次，第二次什么也不能输出，由于迭代器是一个单向的容器，走到尾部以后，不会自动再回到开始位置。
 

生成器不保留前面的数，只能next取下一个，因此遍历一遍完了就没了
 

关于range和xrange ：
 

在python2中，有range和xrange之分，range是把数生成列表形式，xrange吧数生成迭代器形式，在python3中，只有range，py3中的range就是py2中的xrange，生成迭代器形式
 

小结
 

凡是可做用于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
 
 
 
  复制代码 
 
 



        

            

        	





    

		

            
相关文章

            

                

                

                    

                

            


            
相关标签/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公众号
    

    

           欢迎关注本站公众号,获取更多信息

        
    




    

    




	


	







    

        联系我们
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程