python列表生成器、迭代器和生成器的学习

转自：http://python.jobbole.com/81916/

谢谢作者

列表生成器

L=[]
for x in range(1,11):
	L.append(x*x)

print L

L=[x+x for x in range(1,11) if x%2==0]
print L

L=[m+n for m in 'ABC' for n in 'XYZ']
print L

import os
L=[d for d in os.listdir('.')]
print L

#使用内建的isinstance函数可以判断一个变量是不是字符串
x='abd'
print isinstance(x,str)

L1=['Hello','World',18,'Apple',None]
L=[ d.lower() for d in L1 if isinstance(d,str)==True]
print L

迭代器

可以直接作用于for循环的对象统称为可迭代对象(Iterable)。

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

所有的Iterable均可以通过内置函数iter()来转变为Iterator。

对迭代器来讲，有一个__next()就够了。在你使用for 和 in 语句时，程序就会自动调用即将被处理的对象的迭代器对象，然后使用它的next__()方法，直到监测到一个StopIteration异常。

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

>>> L = [ 1 , 2 , 3 ] >>> [ x * * 2 for x in L ] [ 1 , 4 , 9 ] >>> next ( L ) Traceback ( most recent call last ) :    File "<stdin>" , line 1 , in < module > TypeError : 'list' object is not an iterator >>> I = iter ( L ) >>> next ( I ) 1 >>> next ( I ) 2 >>> next ( I ) 3 >>> next ( I ) Traceback ( most recent call last ) :    File "<stdin>" , line 1 , in < module > StopIteration

上面例子中，列表L可以被for进行循环但是不能被内置函数next()用来查找下一个值，所以L是Iterable。

L通过iter进行包装后设为I，I可以被next()用来查找下一个值，所以I是Iterator。

题外话：

1. 内置函数iter()仅仅是调用了对象的__iter()方法，所以list对象内部一定存在方法iter__()
2. 内置函数next()仅仅是调用了对象的__next()方法，所以list对象内部一定不存在方法next__()，但是Itrator中一定存在这个方法。
3. for循环内部事实上就是先调用iter()把Iterable变成Iterator在进行循环迭代的。

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

>>> L = [ 4 , 5 , 6 ] >>> I = L . __iter__ ( ) >>> L . __next__ ( ) Traceback ( most recent call last ) :    File "<stdin>" , line 1 , in < module > AttributeError : 'list' object has no attribute '__next__' >>> I . __next__ ( ) 4 >>> from collections import Iterator , Iterable >>> isinstance ( L , Iterable ) True >>> isinstance ( L , Iterator ) False >>> isinstance ( I , Iterable ) True >>> isinstance ( I , Iterator ) True >>> [ x * * 2 for x in I ]      [ 25 , 36 ]

4.Iterator继承自Iterable，从下面的测试中可以很方便的看到Iterator包含__iter()和next()方法，而Iteratble仅仅包含iter__()。

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

>>> from collections import Iterator , Iterable >>> help ( Iterator ) Help on class Iterator :   class Iterator ( Iterable ) |    Method resolution order : |        Iterator |        Iterable |        builtins . object    | * *注解：从这里可以看出 Iterable继承自 object , Iterator继承自 Iterable。 |    Methods defined here : | |    __iter__ ( self ) | |    __next__ ( self ) |        Return the next item from the iterator . When exhausted , raise StopIteration . . . . . . >>> help ( Iterable ) Help on class Iterable :   class Iterable ( builtins . object ) |    Methods defined here : | |    __iter__ ( self ) . . . . . .

 

iterable需要包含有__iter()方法用来返回iterator，而iterator需要包含有next__()方法用来被循环

如果我们自己定义迭代器，只要在类里面定义一个 iter() 函数，用它来返回一个带 next() 方法的对象就够了。

直接上代码

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class Iterable :      def __iter__ ( self ) :          return Iterator ( )   class Iterator :      def __init__ ( self ) :          self . start = - 1      def __next__ ( self ) :          self . start += 2          if self . start > 10 :              raise StopIteration          return self . start   I = Iterable ( ) for i in I :      print ( i )

上面的代码实现的是找到10以内的奇数，代码中的类名可以随便取，不是一定需要使用我上面提供的类名的。

如果在Iterator的__next__方法中没有实现StopIteration异常，那么则是表示的全部奇数，那么需要在调用的时候设置退出循环的条件。

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Iterable :      def __iter__ ( self ) :          return Iterator ( )   class Iterator :      def __init__ ( self ) :          self . start = - 1      def __next__ ( self ) :          self . start += 2          return self . start   I = Iterable ( ) for count , i in zip ( range ( 5 ) , I ) :      #也可以用内置函数enumerate来实现计数工作。      print ( i )

我们通过range来实现打印多少个元素，这里表示打印5个元素，返回结果和上面一致。

当然，我们可以把这两个类合并在一起，这样实现程序的简练。
最终版本如下

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Iterable :      def __iter__ ( self ) :          return self      def __init__ ( self ) :          self . start = - 1      def __next__ ( self ) :          self . start += 2          if self . start > 10 :              raise StopIteration          return self . start   I = Iterable ( ) for i in I :      print ( i )

 

复制迭代器

迭代器是一次性消耗品，使用完了以后就空了，请看。

Python

1 2 3 4 5 6 7 8 9 10

>>> L = [ 1 , 2 , 3 ] >>> I = iter ( L ) >>> for i in I : . . .      print ( i , end = '-' ) . . . 1 - 2 - 3 - >>> next ( I ) Traceback ( most recent call last ) :    File "<stdin>" , line 1 , in < module > StopIteration

当循环以后就殆尽了，再次使用调用时会引发StopIteration异常。

我们想通过直接赋值的形式把迭代器保存起来，可以下次使用。
但是通过下面的范例可以看出来，根本不管用。

Python

1 2 3 4 5 6 7 8 9 10 11 12

>>> I = iter ( L ) >>> J = I >>> next ( I ) 1 >>> next ( J ) 2 >>> next ( I ) 3 >>> next ( J ) Traceback ( most recent call last ) :    File "<stdin>" , line 1 , in < module > StopIteration

那怎么样才能达到我们要的效果呢？

我们需要使用copy包中的deepcopy了，请看下面：

Python

1 2 3 4 5 6 7 8 9

>>> import copy >>> I = iter ( L ) >>> J = copy . deepcopy ( I ) >>> next ( I ) 1 >>> next ( I ) 2 >>> next ( J ) 1

补充：迭代器不能向后移动, 不能回到开始。

所以需要做一些特殊的事情才能实现向后移动等功能

为了理解yield的机制，我们需要理解什么是生成器。在此之前先介绍迭代器iterables。

Iterables

当你创建一个list,你可以一个一个的获取，这种列表就称为迭代：

>>> mylist = [1, 2, 3]
>>> for i in mylist:
...    print(i)
1
2
3

Mylist 是一个迭代器. 当你理解它为一个list，它便是可迭代的:

>>> mylist = [x*x for x in range(3)]
>>> for i in mylist:
...    print(i)
0
1
4

任何可以用 for in 来迭代读取的都是迭代容器，例如lists,strings,files.这些迭代器非常的便利，因为你可以想取多少便取多少，但是你得存储所有的值，其中很多值都完全没有必要每次都保持在内存中。

Generators

列表元素可以按照某个算法推算出来，在循环中不断通过算法推算出来下一个值，不必建立完整的list,可以节省大量的空间。生成器即是一边循环一边计算。

Generators(生成器)也是可迭代的，但是你每次只能迭代它们一次，因为不是所有的迭代器都被一直存储在内存中的，他们临时产生这些值：

>>> mygenerator = (x*x for x in range(3))
>>> for i in mygenerator:
...    print(i)
0
1
4

生成器

生成器几乎和迭代器是相同的，除了符号[]变为()。但是你无法用两次，因为他们只生成一次：他们生成0然后丢弃，继续统计1，接着是4，一个接着一个。

使用for循环来迭代。

L=[x*x for x in range(10)]
print L

g=(x*x for x in range(10))
print g
print next(g)

for n in g:
	print n

Yield的用法，转自http://blog.csdn.net//article/details/43410079

Yield的用法有点像return,除了它返回的是一个生成器，例如：

>>> def createGenerator():
...    mylist = range(3)
...    for i in mylist:
...        yield i*i
...
>>> mygenerator = createGenerator() # create a generator
>>> print(mygenerator) # mygenerator is an object!
<generator object createGenerator at 0xb7555c34>
>>> for i in mygenerator:
...     print(i)
0
1
4

上面的例子几乎非常积累，但是它很好的阐释了yield的用法，我们可以知道createGenerator()生成的是一个生成器。

为了掌握yield的精髓，你一定要理解它的要点：当你调用这个函数的时候，你写在这个函数中的代码并没有真正的运行。这个函数仅仅只是返回一个生成器对象。有点过于奇技淫巧:-)

然后，你的代码会在每次for使用生成器的时候run起来。

现在是解释最难的地方：

当你的for第一次调用函数的时候，它生成一个生成器，并且在你的函数中运行该循环，知道它生成第一个值。然后每次调用都会运行循环并且返回下一个值，知道没有值返回为止。该生成器背认为是空的一旦该函数运行但是不再刀刀yield。之所以如此是因为该循环已经到达终点，或者是因为你再也不满足“if/else”的条件。