• 内容：提供一个方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示

    • 实现方法：iter、next ```python class LinkList: “””链表 头结点保存链表的长度””” class Node:

      1.   def __init__(self, item=None):
      2.       self.item = item
      3.       self.next = None

      class LinkListIterator:

      1.   def __init__(self, node):
      2.       self.node = node
      3.   def __next__(self):
      4.       if self.node:
      5.           cur_node = self.node
      6.           self.node = cur_node.next
      7.           return cur_node.item
      8.       else:
      9.           raise StopIteration
      10.   def __iter__(self):
      11.       return self

      def init(self, iterable=None):

      1.   self.head = LinkList.Node(0)
      2.   self.tail = self.head
      3.   self.extend(iterable)

      def append(self, obj):

      1.   s = LinkList.Node(obj)
      2.   self.tail.next = s
      3.   self.tail = s

      def extend(self, iterable):

      1.   for obj in iterable:
      2.       self.append(obj)
      3.   self.head.item += len(iterable)

      def iter(self):

      1.   return self.LinkListIterator(self.head.next)

      def len(self):

      1.   return self.head.item

      def str(self):

      1.   return "<<" + ", ".join(map(str,self)) + ">>"

    li = [i for i in range(100)] lk = LinkList(li)

    print(lk) ```