python 迭代器 一个奇怪的解决方法

　　一般我们在类里面写迭代器都是如下写法：

　　

 class IterableSomthing:
     def __iter__(self):
         return self

     def __next__(self):
         return 1

　　但是，《流畅的python》给出了不同的见解。该书指出，在数据结构内实现迭代器是个很蠢的想法，因为需要引入游标指针记录位置的缘故，这么实现迭代器会造成数据结构空间性能下降，同时，因为游标指针的独立性使得改数据结构无法并发遍历，所以又造成了时间性能的下降。代码如下

 class Node:
     def __init__(self, item):
         self.item = item
         self.pre = None
         self.next = None

 class Deque:
     def __init__(self):
         """创建一个空的双端队列"""
         self.head = None
         self.tail = None
         self.point = self.head  #游标指针

     def add_front(self, item):
         """从队头加入一个item元素"""
         n0 = Node(item)
         if self.head:
             n0.next = self.head
             self.head.pre = n0
             self.head = n0
         else:
             self.head = n0
             self.tail = n0
         self.zero()

     def add_rear(self, item):
         """从队尾加入一个item元素"""
         n0 = Node(item)
         if self.tail:
             n0.pre = self.tail
             self.tail.next = n0
             self.tail = n0
         else:
             self.head = n0
             self.tail = n0
         self.zero()

     def remove_front(self):
         """从队头删除一个item元素"""
         if self.head:
             if self.head == self.tail:
                 self.head = None
                 self.tail = None
             else:
                 self.head.next.pre = None
                 self.head = self.head.next
         self.zero()

     def remove_rear(self):
         """从队尾删除一个item元素"""
         if self.tail:
             if self.head == self.tail:
                 self.head = None
                 self.tail = None
             else:
                 self.tail.pre.next = None
                 self.tail = self.tail.pre
         self.zero()

     def is_empty(self):
         """判断双端队列是否为空"""
         return self.head is None

     def size(self):
         """返回队列的大小"""
         i = 0
         n0 = self.head
         while n0:
             i += 1
             n0 = n0.next
         return i

     def tolist(self):
         li = []
         n0 = self.head
         while n0:
             li.append(n0.item)
             n0 = n0.next
         return li

     def gen(self):
         n0 = self.head
         while n0:
             # print(id(self))
             yield n0.item
             n0 = n0.next
         raise StopIteration

     def __iter__(self):
         # n0 = self.head
         # while n0:
         #     # print(id(self))
         #     yield n0.item
         #     n0 = n0.next
         # raise StopIteration
         return self

     def __next__(self):
         if self.point:
             n0 = self.point
             self.point = self.point.next
             return n0.item
         else:
             self.zero()
             raise StopIteration

     def zero(self):  #游标指针归零函数
         self.point = self.head

这是个双端队列的python实现，如果实现了迭代器，就必须实现游标指针类属性，游标指针归零类方法，着实降低了开发效率

有没有别的解决方法呢？

有

只要改一处：

     def __iter__(self):
         __index_temp = self.__head
         while __index_temp:
             n0 = __index_temp
             __index_temp = __index_temp.next
             yield n0
         else:
             raise StopIteration

对你没看错，没有__next__函数！没有游标指针！没有归零函数！

这个__iter__函数需要返回一个迭代器，我们就给他一个，因为生成器也是迭代器！

此时，这个双端队列的python实现就不是一个迭代器了，而是一个可迭代对象，就可以用for循环迭代了

def test2():
    s1 = DoubleLinkList()
    for i in range(1000):
        s1.append(i)
    for ii in s1:
        print(ii.item)
        if ii.item == 500:
            print('------------------------------------------------------------------------------')
            break
    for ii in s1:
        print(ii.item)

而且每一个for循环都是独立的，因为每个for循环块获得的对象都是一个独立的生成器，相互之间不会干扰，虽然看起来都是调用同一个对象，但实际上完全不是这么一回事，这就和list的实现是一样一样的，这样的话做并发循环就容易多了。

思考：python里的魔术方法都很有用，但是我们是要为了实现某个功能专门实现对应的魔术方法呢，还是直接实现对应的功能函数呢？

　　    魔术方法是为了其他方法服务的基本方法，还是锦上添花的增补手段呢？