p3

Author: qiwsir

214.md

@@ -6,34 +6,80 @@
 
 迭代，对于读者已经不陌生了，曾有专门一节来讲述，如果印象不深，请复习[《迭代》](./128.md)。
 
-正如读者已知，对序列（列表、元组）、字典和文件都可以用`iter()`方法生成迭代对象，然后用`next()`方法访问。当然，这种访问不是自动的，如果用for循环，就可以自动完成上述访问了。
+    >>> hasattr(list, '__iter__')
+    True
 
-如果用`dir(list)`,`dir(tuple)`,`dir(file)`,`dir(dict)`来查看不同类型对象的属性，会发现它们都有一个名为`__iter__`的东西。这个应该引起读者的关注，因为它和迭代器（iterator）、内置的函数iter()在名字上是一样的，除了前后的双下划线。望文生义，我们也能猜出它肯定是跟迭代有关的东西。当然，这种猜测也不是没有根据的，其重要根据就是英文单词，如果它们之间没有一点关系，肯定不会将命名搞得一样。
+不仅仅是列表，文件、字典都有一个名为`__iter__`的方法，这说明它们都是可迭代的。
 
-猜对了。`__iter__`就是对象的一个特殊方法，它是迭代规则(iterator potocol)的基础。或者说，对象如果没有它，就不能返回迭代器，就没有`next()`方法，就不能迭代。
+`__iter__()`是对象的一个特殊方法，它是迭代规则(iterator potocol)的基础，有了它，说明对象是可迭代的。
 
->提醒注意，如果读者用的是python3.x，迭代器对象实现的是`__next__()`方法，不是`next()`。并且，在python3.x中有一个内建函数next()，可以实现`next(it)`，访问迭代器，这相当于于python2.x中的`it.next()`（it是迭代对象）。
+跟迭代有关的一个内建函数`iter()`，它的文档中这样描述：
 
-那些类型是list、tuple、file、dict对象有`__iter__()`方法，标着他们能够迭代。这些类型都是python中固有的，我们能不能自己写一个对象，让它能够迭代呢？
+    >>> help(iter)
+    Help on built-in function iter in module __builtin__:
 
-当然呢！要不然python怎么强悍呢。
+    iter(...)
+        iter(collection) -> 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.
+
+这个函数前文介绍过，它返回一个迭代器对象。比如：
+
+    >>> lst = [1, 2, 3, 4]
+    >>> iter_lst = iter(lst)
+    >>> iter_lst
+    <listiterator object at 0x02BE8D50>        #Python 3返回结果：<list_iterator object at 0x00000000034CD6D8>
+    
+从返回结果中可以看出，`iter_lst`引用的是迭代器对象。那么，`iter_lst`和`lst`有区别吗？
+
+    >>> hasattr(lst, "__iter__")
+    True
+    >>> hasattr(iter_lst, "__iter__")
+    True
+
+它们都有`__iter__`，这是相同点，说明它们都是可迭代的。
+
+但是：
+
+Python 2：
+
+    >>> hasattr(lst, "next")
+    False
+    >>> hasattr(iter_lst, "next")
+    True
+
+Python 3：
+
+    >>> hasattr(lst, "__next__")
+    False
+    >>> hasattr(iter_lst, "__next__")
+    True
+
+这就是两者的区别。我们像`iter_lst`所引用的对象那样，具有`next()`（Python 2）或者`__next__()`（Python 3）方法的对象，称之为迭代器对象。显见，迭代器对象必然是可迭代的，反之则不然。
+    
+Python 3中迭代器对象实现的是`__next__()`方法，不是`next()`。并且，在Python 3中有一个内建函数`next()`，可以实现`next(it)`访问迭代器，这相当于于Python 2中的`it.next()`（it是迭代对象）。
+
+为了体现Python强悍，自己写一个迭代器对象。
 
     #!/usr/bin/env python
     # coding=utf-8
 
     """
     the interator as range()
     """
-    class MyRange(object):
+    class MyRange(object):    #Python 3: class MyRange:
         def __init__(self, n):
-            self.i = 0
+            self.i = 1
             self.n = n
 
         def __iter__(self):
             return self
 
-        def next(self):
-            if self.i < self.n:
+        def next(self):        #Python 3: def __next__(self):
+            if self.i <= self.n:
                 i = self.i
                 self.i += 1
                 return i
@@ -42,65 +88,71 @@
 
     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
+        print [i for i in x]        #Python 3中使用print()函数，下同，从略
 
 将代码保存，并运行，结果是：
 
-    $ python 21401.py 
-    x.next()==> 0
-    x.next()==> 1
-    ------for loop--------
-    2
-    3
-    4
-    5
-    6
+    [1, 2, 3, 4, 5, 6, 7]
 
-以上代码的含义，是自己仿写了拥有`range()`的对象，这个对象是可迭代的。分析如下：
+以上代码的含义，是自己仿写了类似`range()`的类，但是跟`range()`又有所不同，除了结果不同之外，还有：
 
-类MyRange的初始化方法`__init__()`就不用赘述了，因为前面已经非常详细分析了这个方法，如果复习，请阅读[《类(2)》](./207md)相关内容。
+- 类`MyRange`的初始化方法`__init__()`就不用赘述了，因为前面已经非常详细分析了这个方法，如果复习，请阅读[《类(2)》](./207md)相关内容。
 
-`__iter__()`是类中的核心，它返回了迭代器本身。一个实现了`__iter__()`方法的对象，即意味着其实可迭代的。
+- `__iter__()`是类中的核心，它返回了迭代器本身。一个实现了`__iter__()`方法的对象，即意味着它是可迭代的。
 
-含有`next()`的对象，就是迭代器，并且在这个方法中，在没有元素的时候要发起`StopIteration()`异常。
+- 实现`next()`或者`__next__()`方法，从而使得这个对象是迭代器对象，并且方法中判断，在不满足条件的时候要发起`StopIteration()`异常。
 
-如果对以上类的调用换一种方式：
+再来看`range()`（以下仅仅限于Python 2）：
 
-    if __name__ == "__main__":
-        x = MyRange(7)
-        print list(x)
-        print "x.next()==>", x.next()
+    >>> a = range(7)
+    >>> hasattr(a, "__iter__")
+    True
+    >>> hasattr(a, "next") 
+    False
+    >>> print a
+    [0, 1, 2, 3, 4, 5, 6]
 
-运行后会出现如下结果：
+所以我写的类和`range()`还是有很大区别的。
+
+为了能深入理解迭代器的工作过程，我们这样来操作：
+
+    if __name__ == "__main__":
+        x = MyRange(3)
+        print "self.n=",x.n,";","self.i=",x.i    #Python 3中使用print()函数，下同，从略
+        x.next()
+        print "self.n=",x.n,";","self.i=",x.i
+        x.next()
+        print "self.n=",x.n,";","self.i=",x.i
+        x.next()
+        print "self.n=",x.n,";","self.i=",x.i
+        x.next()
+        print "self.n=",x.n,";","self.i=",x.i
+
+运行结果如下：
+
+    self.n= 3 ; self.i= 1
+    self.n= 3 ; self.i= 2
+    self.n= 3 ; self.i= 3
+    self.n= 3 ; self.i= 4
 
-    $ python 21401.py 
-    [0, 1, 2, 3, 4, 5, 6]
-    x.next()==>
     Traceback (most recent call last):
-      File "21401.py", line 26, in <module>
-        print "x.next()==>", x.next()
-      File "21401.py", line 21, in next
+      File "F:\MyGitHub\StarterLearningPython\2code\21401.py", line 32, in <module>
+        x.next()
+      File "F:\MyGitHub\StarterLearningPython\2code\21401.py", line 21, in next
         raise StopIteration()
     StopIteration
 
-说明什么呢？`print list(x)`将对象返回值都装进了列表中并打印出来，这个正常运行了。此时指针已经移动到了迭代对象的最后一个，正如在[《迭代》](./128.md)中描述的那样，`next()`方法没有检测也不知道是不是要停止了，它还要继续下去，当继续下一个的时候，才发现没有元素了，于是返回了`StopIteration()`。
-
-为什么要将用这种可迭代的对象呢？就像上面例子一样，列表不是挺好的吗？
-
-列表的确非常好，在很多时候效率很高，并且能够解决相当普遍的问题。但是，不要忘记一点，在某些时候，列表可能会给你带来灾难。因为在你使用列表的时候，需要将列表内容一次性都读入到内存中，这样就增加了内存的负担。如果列表太大太大，就有内存溢出的危险了。这时候需要的是迭代对象。比如斐波那契数列（在本教程多处已经提到这个著名的数列：[《练习》的练习4](./129.md)，[《函数(4)》中递归举例](./204.md)）:
+当`next()`或者`__next__()`中的`self.i <= self.n`为假，就`raise StopIteration()`，结束迭代过程。   
+ 
+还记得斐波那契数列吗？前文已经多次用到，这里我们再次使用它，不过是要用它来做一个迭代器对象。
 
     #!/usr/bin/env python
     # coding=utf-8
     """
     compute Fibonacci by iterator
     """
-    __metaclass__ = type
 
-    class Fibs:
+    class Fibs(object):        #Python 3: class Fibs:
         def __init__(self, max):
             self.max = max
             self.a = 0
@@ -109,7 +161,7 @@
         def __iter__(self):
             return self
 
-        def next(self):
+        def next(self):        #Python 3: def __next__(self):
             fib = self.a
             if fib > self.max:
                 raise StopIteration
@@ -118,7 +170,7 @@
 
     if __name__ == "__main__":
         fibs = Fibs(5)
-        print list(fibs)
+        print list(fibs)        #Python 3: print(list(fibs))
 
 运行结果是：
 
@@ -127,16 +179,61 @@
 
 >给读者一个思考问题：要在斐波那契数列中找出大于1000的最小的数，能不能在上述代码基础上改造得出呢？
 
-关于列表和迭代器之间的区别，还有两个非常典型的内建函数：`range()`和`xrange()`，研究一下这两个的差异，会有所收获的。
+以上演示了迭代器的一个具体应用。综合本节上面的内容和前文对迭代的讲述，对迭代器做一个概括：
+
+1. 在 Python 中，迭代器是遵循迭代协议的对象。
+2. 可以使用`iter()` 以从任何序列得到迭代器（如 list, tuple, dictionary, set 等）。
+3. 编写类，实现`__iter__()`方法，以及 `next()`（Python 2）或`__next__()`（Python 3） 。当没有元素时，则引发 `StopIteration`异常。
+4. 如果有很多值，列表就会占用太多的内存，而迭代器则占用更少内存。
+5. 迭代器从第一个元素开始访问，直到所有的元素被访问完结束，只能往前不会后退。
+
+迭代器不仅实用，也很有趣。看下面的操作：
 
-    range(...)
-        range(stop) -> list of integers
-        range(start, stop[, step]) -> list of integers
+    >>> my_lst = [x**x for x in range(4)]
+    >>> my_lst
+    [1, 1, 4, 27]
+    >>> for i in my_lst: print i    #Python 3: print(i)
 
-    >>> 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__']
+    1
+    1
+    4
+    27
+    >>> for i in my_lst: print i
+    
+    1
+    1
+    4
+    27
+
+我连续两次调用列表`my_lst`进行循环，都能正常进行。这个列表相当于一个耐用品，可以反复使用。
 
-从`range()`的帮助文档和方法中可以看出，它的结果是一个列表。但是，如果用`help(xrange)`查看：
+在Python中，除了列表解析式，还可以做元组解析式，方法非常简单：
+
+    >>> my_tup = (x**x for x in range(4))
+    >>> my_tup
+    <generator object <genexpr> at 0x02B7C2B0>
+    >>> for i in my_tup: print i
+
+    1
+    1
+    4
+    27
+    >>> for i in my_tup: print i
+
+对于`my_tup`，我们已经看到，它是generator对象，关于这个名称先不管它，后面会讲解。当把它用到循环中，它明显是一次性用品，只能使用一次，再次使用，就什么也不显示了。
+
+    >>> type(my_lst)
+    <type 'list'>
+    >>> type(my_tup)
+    <type 'generator'>
+
+`my_lst`和`my_tup`是两种不同的对象，并且`my_tup`也不是元组，它是一个generator。其它先不管，请读者在你的Python交互模式中输入`dir(my_tup)`，如果是Python 2，请查找是否有`__iter__`和`next`；如果是Python 3则查看是否有`__iter__`和`__next__`。答案是肯定的。这也是`my_lst`和`my_tup`所引用对象的区别。
+
+因此，`my_tup`引用的是一个迭代器对象。它的`next()`或者`__next__()`方法，使得它只能向前。
+
+关于列表和迭代器之间的区别，还有两个非常典型的内建函数：`range()`和`xrange()`，研究一下这两个的差异，会有所收获的。
+
+`range()`的结果是一个列表。但是，如果用`help(xrange)`查看（仅限于Python 2）：
 
     class xrange(object)
      |  xrange(stop) -> xrange object
@@ -146,14 +243,16 @@
      |  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”，稍快并更高的内存效率（就是省内存呀）。查看它的方法：
+`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()`返回的对象，则是需要一个数值才从返回一个数值。比如这样一个应用：
+也就是说，通过`range()`得到的列表，会一次性被读入内存，而`xrange()`返回的对象，则是需要一个数值才从返回一个数值。
+
+上述论述仅适用于Python 2，因为在Python 3里面，将`range()`优化了，相当于Python 2里面`xrange()`，所以，在Python 3中就不再有`xrange()`。
 
 还记得`zip()`吗？
 
@@ -164,7 +263,7 @@
 
 如果两个列表的个数不一样，就会以短的为准了，比如：
 
-    >>> zip(range(4), xrange(100000000))
+    >>> zip(range(4), xrange(100000000))    #适用于Python 2
     [(0, 0), (1, 1), (2, 2), (3, 3)]
 
 第一个`range(4)`产生的列表被读入内存；第二个是不是也太长了？但是不用担心，它根本不会产生那么长的列表，因为只需要前4个数值，它就提供前四个数值。如果你要修改为`range(100000000)`，就要花费时间了，可以尝试一下哦。
@@ -173,6 +272,6 @@
 
 ------
 
-[总目录](./index.md)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[上节：特殊方法(2)](./213.md)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[下节：生成器](./215.md)
+[总目录](./index.md)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[上节：黑魔法](./240.md)&nbsp;&nbsp;&nbsp;|&nbsp;&nbsp;&nbsp;[下节：生成器](./215.md)
 
 如果你认为有必要打赏我，请通过支付宝：**[email protected]**,不胜感激。

2code/21401.py

@@ -6,25 +6,36 @@
 """
 class MyRange(object):
     def __init__(self, n):
-        self.i = 0
+        self.i = 1
         self.n = n
 
     def __iter__(self):
         return self
 
     def next(self):
-        if self.i < self.n:
+        if self.i <= self.n:
             i = self.i
             self.i += 1
             return i
         else:
             raise StopIteration()
 
 if __name__ == "__main__":
-    x = MyRange(7)
-    print list(x)
-    print "x.next()==>", x.next()
-    print "x.next()==>", x.next()
-    print "------for loop--------"
-    for i in x:
-        print i
+    x = MyRange(3)
+    print "self.n=",x.n,";","self.i=",x.i
+    x.next()
+    print "self.n=",x.n,";","self.i=",x.i
+    x.next()
+    print "self.n=",x.n,";","self.i=",x.i
+    x.next()
+    print "self.n=",x.n,";","self.i=",x.i
+    x.next()
+    print "self.n=",x.n,";","self.i=",x.i
+    
+    #print [i for i in x]
+    #print list(x)
+    #print "x.next()==>", x.next()
+    #print "x.next()==>", x.next()
+    #print "------for loop--------"
+    #for i in x:
+    #    print i