手机版
你好,游客 登录 注册 搜索
背景:
阅读新闻

Python迭代器与生成器详解

[日期:2017-09-30] 来源:Linux社区  作者:deeper [字体: ]

1. 迭代器

迭代器是访问集合元素的一种方式。迭代器对象从集合的第一个元素开始访问,直到所有的元素被访问完结束。迭代器只能往前不会后退,不过这也没什么,因为人们很少在迭代途中往后退。另外,迭代器的一大优点是不要求事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代到某个元素时才计算该元素,而在这之前或之后,元素可以不存在或者被销毁。这个特点使得它特别适合用于遍历一些巨大的或是无限的集合,比如几个G的文件。

特点:

a)访问者不需要关心迭代器内部的结构,仅需通过next()方法或不断去取下一个内容

b)不能随机访问集合中的某个值 ,只能从头到尾依次访问

c)访问到一半时不能往回退

d)便于循环比较大的数据集合,节省内存

e)也不能复制一个迭代器。如果要再次(或者同时)迭代同一个对象,只能去创建另一个迭代器对象。enumerate()的返回值就是一个迭代器,我们以enumerate为例:

 a = enumerate(['a','b'])

for i in range(2):    #迭代两次enumerate对象
     for x, y in a:
         print(x,y)
     print(''.center(50,'-')) 

结果:

0 a
1 b
--------------------------------------------------
--------------------------------------------------

可以看到再次迭代enumerate对象时,没有返回值;

我们可以用linux的文件处理命令vim和cat来理解一下:

a) 读取很大的文件时,vim需要很久,cat是毫秒级;因为vim是一次性把文件全部加载到内存中读取;而cat是加载一行显示一行

b) vim读写文件时可以前进,后退,可以跳转到任意一行;而cat只能向下翻页,不能倒退,不能直接跳转到文件的某一页(因为读取的时候这个“某一页“可能还没有加载到内存中)

正式进入Python迭代器之前,我们先要区分两个容易混淆的概念:可迭代对象和迭代器;

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

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

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

1)可迭代对象

首先,迭代器是一个对象,不是一个函数;是一个什么样的对象呢?就是只要它定义了可以返回一个迭代器的__iter__方法,或者定义了可以支持下标索引的__getitem__方法,那么它就是一个可迭代对象。

python中大部分对象都是可迭代的,比如list,tuple等。如果给一个准确的定义的话,看一下list,tuple类的源码,都有__iter__(self)方法。

常见的可迭代对象:

a) 集合数据类型,如listtupledictsetstr等;

b) generator,包括生成器和带yield的generator function。

注意:生成器都是Iterator对象,但listdictstr虽然是Iterable,却不是Iterator,关于生成器,继续往下看

如何判断一个对象是可迭代对象呢?可以通过collections模块的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

2)迭代器

一个可迭代对象是不能独立进行迭代的,Python中,迭代是通过for ... in来完成的。

for循环在迭代一个可迭代对象的过程中都做了什么呢?

a)当for循环迭代一个可迭代对象时,首先会调用可迭代对象的__iter__()方法,然我们看看源码中关于list类的__iter__()方法的定义:

def __iter__(self, *args, **kwargs): # real signature unknown
    """ Implement iter(self). """
    pass

__iter__()方法调用了iter(self)函数,我们再来看一下iter()函数的定义:

def iter(source, sentinel=None): # known special case of iter
    """
    iter(iterable) -> iterator
    iter(callable, sentinel) -> iterator
    
    Get an iterator from an object.  In the first form, the argument must
    supply its own iterator, or be a sequence.
    In the second form, the callable is called until it returns the sentinel.
    """
    pass

iter()函数的参数是一个可迭代对象,最终返回一个迭代器

b) for循环会不断调用迭代器对象的__next__()方法(python2.x中是next()方法),每次循环,都返回迭代器对象的下一个值,直到遇到StopIteration异常。

>>> lst_iter = iter([1,2,3])
>>> lst_iter.__next__()
1
>>> lst_iter.__next__()
2
>>> lst_iter.__next__()
3
>>> lst_iter.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

这里注意:这里的__next__()方法和内置函数next(iterator, default=None)不是一个东西;(内置函数next(iterator, default=None)也可以返回迭代器的下一个值)

 c) 而for循环可以捕获StopIteration异常并结束循环;

总结一下:

a)for....in iterable,会通过调用iter(iterable)函数(实际上,首先调用的对象的__iter__()方法),返回一个迭代器iterator;

b)每次循环,调用一次对象的__next__(self),直到最后一个值,再次调用会触发StopIteration

c)for循环捕捉到StopIteration,从而结束循环

上面说了这么多,到底什么是迭代器Iterator呢?

任何实现了__iter____next__()(python2中实现next())方法的对象都是迭代器,__iter__返回迭代器自身,__next__返回容器中的下一个值;

既然知道了什么迭代器,那我们自定义一个迭代器玩玩:

 1 class Iterator_test(object):
 2     def __init__(self, data):
 3         self.data = data
 4         self.index = len(data)
 5 
 6     def __iter__(self):
 7         return self
 8 
 9     def __next__(self):
10         if self.index <= 0 :
11             raise StopIteration
12         self.index -= 1
13         return self.data[self.index]
14 
15 iterator_winter = Iterator_test('abcde')
16 
17 for item in iterator_winter:
18     print(item)

如何判断一个对象是一个迭代器对象呢?两个方法:

1)通过内置函数next(iterator, default=None),可以看到next的第一个参数必须是迭代器;所以迭代器也可以认为是可以被next()函数调用的对象

2)通过collection中的Iterator类型判断

>>> from collections import Iterator
>>>
>>> isinstance([1,2,3], Iterator)
False
>>> isinstance(iter([1,2,3]), Iterator)
True
>>> isinstance([1,2,3].__iter__(), Iterator)
True
>>>

这里大家会不会有个疑问:

对于迭代器而言,看上去作用的不就是__next__方法嘛,__iter__好像没什么卵用,干嘛还需要__iter__方法呢?

我们知道,python中迭代是通过for循环实现的,而for循环的循环对象必须是一个可迭代对象Iterable,而Iterable必须是一个实现了__iter__方法的对象;知道为什么需要__iter__魔术方法了吧;

那么我就是想自定义一个没有实现__iter__方法的迭代器可以吗?可以,像下面这样:

class Iterable_test(object):
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return Iterator_test(self.data)

class Iterator_test(object):
    def __init__(self, data):
        self.data = data
        self.index = len(data)

    def __next__(self):
        if self.index <= 0 :
            raise StopIteration
        self.index -= 1
        return self.data[self.index]

iterator_winter = Iterable_test('abcde')

for item in iterator_winter:
    print(item)

先定义一个可迭代对象(包含__iter__方法),然后该对象返回一个迭代器;这样看上去是不是很麻烦?是不是同时带有__iter__和__next__魔术方法的迭代器更好呢!

同时,这里要纠正之前的一个迭代器概念:只要__next__()(python2中实现next())方法的对象都是迭代器;

既然这样,只需要迭代器Iterator接口就够了,为什么还要设计可迭代对象Iterable呢?

这个和迭代器不能重复使用有关,下面同意讲解:

3)总结和一些重要知识点

a) 如何复制迭代器

之前在使用enumerate时,我们说过enumerate对象通过for循环迭代一次后就不能再被迭代:

>>> e = enumerate([1,2,3])
>>>
>>> for x,y in e:
...   print(x,y)
...
0 1
1 2
2 3
>>> for x,y in e:
...   print(x,y)
...
>>>

这是因为enumerate是一个迭代器;

迭代器是一次性消耗品,当循环以后就空了。不能再次使用;通过深拷贝可以解决;

>>> import copy
>>>
>>> e = enumerate([1,2,3])
>>>
>>> e_deepcopy = copy.deepcopy(e)
>>>
>>> for x,y in e:
...   print(x,y)
...
0 1
1 2
2 3
>>> for x,y in e_deepcopy:
...   print(x,y)
...
0 1
1 2
2 3
>>>

b)为什么不只保留Iterator的接口而还需要设计Iterable呢?

因为迭代器迭代一次以后就空了,那么如果list,dict也是一个迭代器,迭代一次就不能再继续被迭代了,这显然是反人类的;所以通过__iter__每次返回一个独立的迭代器,就可以保证不同的迭代过程不会互相影响。而生成器表达式之类的结果往往是一次性的,不可以重复遍历,所以直接返回一个Iterator就好。让Iterator也实现Iterable的兼容就可以很灵活地选择返回哪一种。

总结说,Iterator实现的__iter__是为了兼容Iterable的接口,从而让Iterator成为Iterable的一种实现。

另外,迭代器是惰性的,只有在需要返回下一个数据时它才会计算。就像一个懒加载的工厂,等到有人需要的时候才给它生成值返回,没调用的时候就处于休眠状态等待下一次调用。所以,Iterator甚至可以表示一个无限大的数据流,例如全体自然数。而使用list是永远不可能存储全体自然数的。

c)通过__getitem__来实现for循环

前面关于可迭代对象的定义是这样的:定义了可以返回一个迭代器的__iter__方法,或者定义了可以支持下标索引的__getitem__方法,那么它就是一个可迭代对象。

但是如果对象没有__iter__,但是实现了__getitem__,会改用下标迭代的方式。

class NoIterable(object):
    def __init__(self, data):
        self.data = data
    def __getitem__(self, item):
        return self.data[item]

no_iter = NoIterable('abcde')
for item in no_iter:
    print(item)
 
当for发现没有__iter__但是有__getitem__的时候,会从0开始依次读取相应的下标,直到发生IndexError为止,这是一种旧的迭代方法。iter方法也会处理这种情况,在不存在__iter__的时候,返回一个下标迭代的iterator对象来代替。
d)一张图总结迭代器
e)使用迭代器来实现一个斐波那契数列
 1 class Fib(object):
 2     def __init__(self, limit):
 3         self.a, self.b = 0, 1
 4         self.limit = limit
 5 
 6     def __iter__(self):
 7         return self
 8 
 9     def __next__(self):
10         self.a, self.b = self.b, self.a+self.b
11         while self.a > self.limit:
12             raise StopIteration
13         return self.a
14 
15 for n in Fib(1000):
16     print(n)

更多详情见请继续阅读下一页的精彩内容http://www.linuxidc.com/Linux/2017-09/147206p2.htm

linux
相关资讯       Python生成器  Python迭代器 
本文评论   查看全部评论 (0)
表情: 表情 姓名: 字数

       

评论声明
  • 尊重网上道德,遵守中华人民共和国的各项有关法律法规
  • 承担一切因您的行为而直接或间接导致的民事或刑事法律责任
  • 本站管理人员有权保留或删除其管辖留言中的任意内容
  • 本站有权在网站内转载或引用您的评论
  • 参与本评论即表明您已经阅读并接受上述条款