迭代器

迭代器 (iterator) 是一个可以记住遍历的位置的对象。迭代是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
使用 dir()函数可以看出 下列的列表中包含 iter,即为迭代器：

  1. nums = [1,2,3] 
  2. print(dir(nums))
  5. """ 
  6. ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', 
  7. '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', 
  8. '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', 
  9. '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', 
  10. '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', 
  11. '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', 
  12. '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 
  13. 'pop', 'remove', 'reverse', 'sort'] 
  14. """

迭代器有两个基本的方法：

  • iter()
  • next()

字符串，列表或元组对象都可用于创建迭代器：

  1. list=[1,2,3,4]
  2. it1 = iter(list)    # 创建迭代器对象
  3. print (next(it1))   # 输出迭代器的下一个元素
  4. print (next(it1))
  5. """ 
  6. 1
  7. 2
  8. """
  9. #----------------------------------
  10. dict={"name":"一缕清风","age":22}
  11. it2 = iter(dict)   
  12. print (it2)
  13. print (next(it2))
  14. print (next(it2))
  15. # print (next(it2)) # StopIteration
  16. try:
  17.   print(next(it2))
  18. except StopIteration:
  19.   pass
  21. """ 
  22. <dict_keyiterator object at 0x7fe409aeb0e8>
  23. name
  24. age
  25. """
  26. #----------------------------------
  27. it3 = iter((1,2,3))    
  28. print (next(it3))
  29. print (next(it3))
  31. """ 
  32. 1
  33. 2
  34. """
  35. #----------------------------------
  36. it4 = iter("abcdefg")    
  37. print (next(it4))
  38. print (next(it4))
  39. """
  40. a
  41. b
  42. """
  43. #----------------------------------

迭代器对象可以使用常规for语句进行遍历：

  1. #!/usr/bin/python3
  3. list=[1,2,3,4]
  4. it = iter(list)    # 创建迭代器对象
  5. for x in it:
  6.     # print (x, end=" ")
  7.     print (x)
  9. for x in ["a","b","c","d"]:
  10.     # print (x, end=" ")
  11.     print (x)
  13. # for x in (10,20):
  14. # for x in tuple([]):
  15. for x in tuple([10,20]):
  16.     # print (x, end=" ")
  17.     print (x)
  19. for x in {"name":"一缕清风","age":22}:
  20.     # print (x, end=" ")
  21.     print (x)
  23. """ 
  24. 1
  25. 2
  26. 3
  27. 4
  28. a
  29. b
  30. c
  31. d
  32. 10
  33. 20
  34. name
  35. age
  36. """

也可以使用 next() 函数：

  1. #!/usr/bin/python3
  3. import sys         # 引入 sys 模块
  5. list=[1,2,3,4]
  6. it = iter(list)    # 创建迭代器对象
  8. while True:
  9.     try:
  10.         print (next(it))
  11.     except StopIteration:
  12.         # sys.exit()
  13.         break
  16. """ 
  17. 1
  18. 2
  19. 3
  20. 4 
  21. """

创建一个迭代器

把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。
如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 init(), 它会在对象初始化的时候执行。
更多内容查阅：Python3 面向对象

  • iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
  • next() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递减 1：

  1. class MyNumbers:
  2.   def __init__(self):
  3.     self.a = 1
  5.   def __iter__(self):
  6.     return self
  8.   def __next__(self):
  9.     x = self.a
  10.     self.a -= 1
  11.     return x
  13. myclass = MyNumbers()
  14. myiter = iter(myclass)
  16. print(next(myiter))
  17. print(next(myiter))
  18. print(next(myiter))
  19. print(next(myiter))
  20. print(next(myiter))
  22. """ 
  23. 1
  24. 0
  25. -1
  26. -2
  27. -3 
  28. """

StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。
在 20 次迭代后停止执行：

  1. class MyRanges:
  2.   def __init__(self, start = 0, end = 0,step = 1):
  3.     self.start = start
  4.     self.end = end
  5.     self.step = step
  6.     self.value = start
  7.     self.increase =  end > start
  8.     # self.increase = True if end > start else False #判断是否递增
  10.   def __iter__(self):
  11.     return self
  13.   def __next__(self):
  14.     if self.increase:
  15.       if self.value <= self.end:
  16.         x = self.value
  17.         self.value += self.step
  18.         return x
  19.       else:
  20.         raise StopIteration
  21.     else:
  22.       if self.value >= self.end:
  23.         x = self.value
  24.         self.value -= self.step
  25.         return x
  26.       else:
  27.         raise StopIteration
  29. #--------------------------------------------------------
  30. myiter = iter(MyRanges(0,-10,2))
  31. while True:
  32.   try:
  33.     print(next(myiter))
  34.   except StopIteration:
  35.     break
  36. """ 
  37. 0
  38. -2
  39. -4
  40. -6
  41. -8
  42. -10
  43. """
  44. #--------------------------------------------------------
  45. myiter2 = iter(MyRanges(2,10,2))
  46. for x in myiter2:
  47.   print(x)
  48. """ 
  49. 2
  50. 4
  51. 6
  52. 8
  53. 10
  54. """

生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
以下实例使用 yield 实现斐波那契数列：

  1. #!/usr/bin/python3
  3. import sys
  5. def fibonacci(n): # 生成器函数 - 斐波那契
  6.     a, b, counter = 0, 1, 0
  7.     while True:
  8.         if (counter > n): return "退出"
  9.         yield a
  10.         a, b = b, a + b
  11.         counter += 1
  14. f = fibonacci(12)  # f 是一个迭代器，由生成器返回生成
  15. while True:
  16.   try:
  17.     print (next(f), end=" ")
  18.   # except Exception as unusual:
  19.   except StopIteration as unusual:
  20.     # sys.exit()
  21.     print(unusual.value)
  22.     break
  24. """ 
  25. 0 1 1 2 3 5 8 13 21 34 55 89 144 退出
  26. """