【python】带你深入了解“迭代器“

个人简介

      作者简介：大家好，我是姐姐划船吗？运维领域创作者，阿里云ACE认证高级工程师
      ✒️个人主页：姐姐划船吗？
      支持我：点赞+收藏⭐️+留言
      格言：你未必出类拔萃，但一定与众不同！

系列专栏：
                 阶段一：windows基础
                 阶段二：Linux基础知识
                 阶段三：shell基础+shell高级
                 阶段四：学会python，逆天改命
                 阶段五：Linux网络服务
                 阶段六：集群原理及架构
                 阶段七：云计算虚拟化技术

迭代器

迭代，正如大家已知，对序列（列表、元组）、字典和文件都可以用 iter() 方法生成迭代对象，然后用 next() 方法访 问。当然，这种访问不是自动的，如果用 for 循环，就可以自动完成上述访问了。 如果用 dir(list) , dir(tuple) , dir(file) , dir(dict) 来查看不同类型对象的属性，会发现它们都有一个名为 __iter__ 的东西。这个应该引起读者的关注，因为它和迭代器（iterator）、内置的函数 iter() 在名字上是一样的，除了前后的双下划线。望文生义，我们也能猜出它肯定是跟迭代有关的东西。当然，这种猜测也不是没有根据的，其重要根据就是英文单词，如果它们之间没有一点关系，肯定不会将命名搞得一样。 猜对了。 __iter__ 就是对象的一个特殊方法，它是迭代规则(iterator potocol)的基础。或者说，对象如果没有 它，就不能返回迭代器，就没有 next() 方法，就不能迭代。

提醒注意：

如果读者用的是 Python3.x，迭代器对象实现的是 __next__() 方法，不是 next() 。并且，在 Py

thon3.x 中有一个内建函数 next()，可以实现 next(it) ，访问迭代器，这相当于于 python2.x 中的 it.next() （it 是迭代对象）。

那些类型是 list、tuple、file、dict 对象有 __iter__() 方法，标着他们能够迭代。这些类型都是 Python 中固有的，我们能不能自己写一个对象，让它能够迭代呢？ 当然呢！要不然 python 怎么强悍呢。

#!/usr/bin/env Python
# coding=utf-8

"""
the interator as range()
"""
class MyRange(object):
    def __init__(self, n):
        self.i = 0
        self.n = n
    def __iter__(self):
        return self
    def next(self):
        if self.i < self.n:
            i = self.i
            self.i += 1
            return i
        else:
            raise StopIteration()
if __name__ == "__main__":
    x = MyRange(7)
    print "x.next()==>", x.next()
    print "x.next()==>", x.next()
    print "------for loop--------"
    for i in x:
        print i

将代码保存，并运行，结果是：

$ python 21401.py
x.next()==> 0
x.next()==> 1
------for loop--------
2
3
4
5
6

以上代码的含义，是自己仿写了拥有 range() 的对象，这个对象是可迭代的。分析如下： __iter__() 是类中的核心，它返回了迭代器本身。一个实现了 __iter__() 方法的对象，即意味着其实可迭代 的。 含有 next() 的对象，就是迭代器，并且在这个方法中，在没有元素的时候要发起 StopIteration() 异常。 如果对以上类的调用换一种方式：

if __name__ == "__main__":
    x = MyRange(7)
    print list(x)
    print "x.next()==>", x.next()

运行后会出现如下结果： 

$ python 21401.py
[0, 1, 2, 3, 4, 5, 6]
x.next()==>
Traceback (most recent call last):
    File "21401.py", line 26, in 
        print "x.next()==>", x.next()
    File "21401.py", line 21, in next
        raise StopIteration()
StopIteration

说明什么呢？ print list(x) 将对象返回值都装进了列表中并打印出来，这个正常运行了。此时指针已经移动到了 迭代对象的最后一个， next() 方法没有检测也不知道是不是要停止了，它还要继续下去，当继续下一个的时候，才发现没有元素了，于是返回了 StopIteration() 。 为什么要将用这种可迭代的对象呢？就像上面例子一样，列表不是挺好的吗？ 列表的确非常好，在很多时候效率很高，并且能够解决相当普遍的问题。但是，不要忘记一点，在某些时候，列表可能会给你带来灾难。因为在你使用列表的时候，需要将列表内容一次性都读入到内存中，这样就增加了内存的负担。如果列表太大太大，就有内存溢出的危险了。这时候需要的是迭代对象。比如斐波那契数列

#!/usr/bin/env Python
# coding=utf-8
"""
compute Fibonacci by iterator
"""

__metaclass__ = type
class Fibs:
    def __init__(self, max):
        self.max = max
        self.a = 0
        self.b = 1
    def __iter__(self):
        return self
    def next(self):
        fib = self.a
        if fib > self.max:
            raise StopIteration
        self.a, self.b = self.b, self.a + self.b
        return fib
if __name__ == "__main__":
    fibs = Fibs(5)
    print list(fibs)

运行结果是：

$ python 21402.py
[0, 1, 1, 2, 3, 5]

如果说，要在斐波那契数列中找出大于 1000 的最小的数，能不能在上述代码基础上改造得出呢？

关于列表和迭代器之间的区别，还有两个非常典型的内建函数： range() 和 xrange() ，研究一下这两个的差异，会有所收获的。

range(...)

    range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers
>>> dir(range)
['__call__', '__class__', '__cmp__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

从 range() 的帮助文档和方法中可以看出，它的结果是一个列表。但是，如果用 help(xrange) 查看：

class xrange(object)
| xrange(stop) -> xrange object
| xrange(start, stop[, step]) -> xrange object
|
| Like range(), but instead of returning a list, returns an object that
| generates the numbers in the range on demand. For looping, this is
| slightly faster than range() and more memory efficient.

xrange() 返回的是对象，并且进一步告诉我们，类似 range() ，但不是列表。在循环的时候，它跟 range() 相比“slightly faster than range() and more memory efficient”，稍快并更高的内存效率（就是省内存呀）。查看它的方法：

>>> dir(xrange)
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__getitem__', '__hash__', '__init__', '__iter__', '__len__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

看到令人兴奋的 __iter__ 了吗？说明它是可迭代的，它返回的是一个可迭代的对象。 也就是说，通过 range() 得到的列表，会一次性被读入内存，而 xrange() 返回的对象，则是需要一个数值才从返回一个数值。比如这样一个应用：

>>> a = ["name", "age"]
>>> b = ["qiwsir", 40]
>>> zip(a,b)
[('name', 'qiwsir'), ('age', 40)]

如果两个列表的个数不一样，就会以短的为准了，比如：

>>> zip(range(4), xrange(100000000))
[(0, 0), (1, 1), (2, 2), (3, 3)]

第一个 range(4) 产生的列表被读入内存；第二个是不是也太长了？但是不用担心，它根本不会产生那么长的列表，因为只需要前 4 个数值，它就提供前四个数值。如果你要修改为 range(100000000) ，就要花费时间了，可以尝试一下哦。

迭代器的确有迷人之处，但是它也不是万能之物。比如迭代器不能回退，只能如过河的卒子，不断向前。另外，迭代器也不适合在多线程环境中对可变集合使用

结束语

实习渠道哪家强，中国北京找优加！
只要实习相关，找我们，给你一套适合你的解决方案，从简历制作、面试题库、行业资源、模拟面试到大厂资源。