2022年 11月 4日

python迭代器详解

一、什么是迭代器
迭代是python中访问集合元素的一种非常强大的一种方式。迭代器是一个可以记住遍历位置的对象，因此不会像列表那样一次性全部生成，而是可以等到用的时候才生成，因此节省了大量的内存资源。迭代器对象从集合中的第一个元素开始访问，直到所有的元素被访问完。迭代器有两个方法：iter（）和next（）方法。

二、可迭代的对象
类似于list、tuple、str 等类型的数据可以使用for …… in…… 的循环遍历语法从其中依次拿到数据并进行使用，我们把这个过程称为遍历，也称迭代。python中可迭代的对象有list（列表）、tuple（元组）、dirt（字典）、str（字符串）set等。

  1. mylist = [1,2,3,4,5]
  2. mydirt = {
  3.     "name":"张三",
  4.     "sex":"男",
  5.     "age":18
  6.     }
  7.     
  8. mytuple = (1,2,3,4,5)
  9. myset = {1,2,3,3,4}
  10.  
  11. for i in mylist:
  12.     print(i)
  13.  
  14. for i in mytuple:
  15.     print(i)
  16.  
  17. for i in myset:
  18.     print(i)
  19.  
  20. for i,j in mydirt.items():
  21.     print("%s:%s" % (i,j))

 
 
除此之外，也可以创建一个可迭代的对象：只要此对象含有__iter__方法，那么它就是一个可迭代的对象，如下面的例子：其中定义了一个__iter__方法，我们通过isinstance（）函数以及Iterable来判断由Classmate类创建的class1对象是否是可迭代的对象：若class1是一个Iterable（可迭代对象）则结果返回为True；否则，结果为False。

  1. from collections import Iterable
  2.  
  3.  
  4. class Classmate(object):
  5.     """定义一个同学类"""
  6.  
  7.     def __init__(self):
  8.         self.name = list()
  9.         self.name_num = 0
  10.  
  11.     def add(self,name):
  12.         self.name.append(name)
  13.     
  14.     def __iter__(self):
  15.         pass
  16.  
  17.     
  18. class1 =  Classmate()
  19. class1.add("张三")
  20. class1.add("李四")
  21. class1.add("王五")
  22.  
  23. print("判断是否是可迭代的对象：", isinstance(class1,Iterable))

运行结果如下：

三、创建一个迭代器
1.一个类（对象）只要含有“__iter__”、”__next__”两个方法，就将其称为迭代器。__iter__方法返回一个特殊的迭代器对象，而这个迭代器对象自动实现了_next__方法，并返回一个值，最后通过抛出异常StopIteration来结束迭代。我们来给上一个例子增加__next__方法：

  1. from collections import Iterable
  2. from collections import Iterator
  3.  
  4.  
  5. class Classmate(object):
  6.     """定义一个同学类"""
  7.  
  8.     def __init__(self):
  9.         self.name = list()
  10.         self.name_num = 0
  11.  
  12.     def add(self,name):
  13.         self.name.append(name)
  14.     
  15.     def __iter__(self):
  16.         pass
  17.  
  18.     def __next__(self):
  19.        pass
  20.  
  21.  
  22. class1 =  Classmate()
  23. class1.add("张三")
  24. class1.add("李四")
  25. class1.add("王五")
  26.  
  27. print("判断是否是可迭代的对象：", isinstance(class1,Iterable))
  28.  
  29. print("判断是否是迭代器：", isinstance(class1,Iterator))

还是通过isinstance（）函数来判断，如果class1是一个迭代器（Iterator），则结果返回True；否则返回False。运行结果如下：

2.只是名义上的 可迭代对象/迭代器 还不够，具有相应的功能才算是完整。首先，对于__iter__方法，它需要具有一个可以返回一个迭代器对象的功能（这个对象可以是自己(前提是本身就是一个迭代器），也可以是其它迭代器）；对于__next__方法，它需要标记并返回下一个迭代器对象。代码如下（为防止迭代速度过快，我们添加sleep来控制速度）：

  1. from collections import Iterable
  2. from collections import Iterator
  3. import time
  4.  
  5.  
  6. class Classmate(object):
  7.     """定义一个同学类"""
  8.  
  9.     def __init__(self):
  10.         self.name = list()
  11.         self.name_num = 0
  12.  
  13.     def add(self,name):
  14.         self.name.append(name)
  15.     
  16.     def __iter__(self):
  17.         return self   # 返回本身
  18.  
  19.     def __next__(self):
  20.        
  21.        # 记忆性返回数据
  22.        if self.name_num < len(self.name):
  23.            ret = self.name[self.name_num]
  24.            self.name_num += 1
  25.            return ret
  26.  
  27.  
  28.  
  29. class1 =  Classmate()
  30. class1.add("张三")
  31. class1.add("李四")
  32. class1.add("王五")
  33.  
  34. print("判断是否是可迭代的对象：", isinstance(class1,Iterable))
  35.  
  36. print("判断是否是迭代器：", isinstance(class1,Iterator))
  37.  
  38. for name in class1:
  39.     print(name)
  40.     time.sleep(1)

运行结果如下:

 

可以发现，当需要读取的内容读取完之后不会停止，而是无限循环的继续返回空值。因此我们可以为其添加抛出异常（StopIteration，python中用于标标识迭代完成，防止出现无限循环的情况）的程序，当需要的数据读取完成时就抛出异常，从而结束：

  1. from collections import Iterable
  2. from collections import Iterator
  3. import time
  4.  
  5.  
  6. class Classmate(object):
  7.     """定义一个同学类"""
  8.  
  9.     def __init__(self):
  10.         self.name = list()
  11.         self.name_num = 0
  12.  
  13.     def add(self,name):
  14.         self.name.append(name)
  15.     
  16.     def __iter__(self):
  17.         return self   # 返回本身
  18.  
  19.     def __next__(self):
  20.        if self.name_num < len(self.name):
  21.            ret = self.name[self.name_num]
  22.            self.name_num += 1
  23.            return ret
  24.  
  25.         # 抛出异常，当循环后自动结束
  26.        else:
  27.            raise StopIteration
  28.  
  29.  
  30. class1 =  Classmate()
  31. class1.add("张三")
  32. class1.add("李四")
  33. class1.add("王五")
  34.  
  35. print("判断是否是可迭代的对象：", isinstance(class1,Iterable))
  36.  
  37. print("判断是否是迭代器：", isinstance(class1,Iterator))
  38.  
  39. for name in class1:
  40.     print(name)
  41.     time.sleep(1)

运行结果如下：

 

四、迭代器的应用
迭代器最核心的功能就是可以通过__next__方法的调用来返回下一个值。而这个值不是从已有的数据中读取的，而是通过程序按照一定的规则生成的。这也就意味着我们可以不再依赖一个现存的数据集合来存放数据，而是边用边生成，这样的好处就是可以节省大量的内存空间。我们通过对比以下问题的两个解决方法，来进一的理解其应用优势：

问题：试编写一个程序实现斐波那契数列（0,1,1,2,3,5,8,13,21……后一项总是等于前两项的和）：

方法一：

  1. a = 0
  2. b = 1
  3. myFibonacci = list()
  4.  
  5. nums = int(input("请输入需要生成Fibonacci数列项的个数："))
  6.  
  7. i = 0
  8. while i < nums:
  9.     myFabonacci.append(a)
  10.     a,b = b,a+b
  11.     i += 1
  12.  
  13. for num in myFibonacci:
  14.     print(num)

方法二：

  1. class Fibonacci(object):
  2.     """斐波那契数列得迭代器"""
  3.     def __init__(self,nums):
  4.         self.nums = nums   # 传入参数，生成斐波那契数列的个数
  5.         self.a = 0   
  6.         self.b = 1
  7.         self.i =0    # 用于记忆生成的个数
  8.     def __iter__(self):
  9.         return self
  10.  
  11.     def __next__(self):
  12.            
  13.        ret = self.a   # 记忆第一个数
  14.  
  15.        if self.i < self.nums:
  16.             self.a, self.b = self.b,self.a +self.b
  17.             self.i += 1
  18.             return ret
  19.        else:
  20.            raise StopIteration   # 停止迭代
  21.  
  22. nums = int(input("请输入需要生成Fibonacci数列项的个数："))
  23. fobo = Fibonacci(nums)
  24.  
  25. for num in fobo:
  26.     print(num)

假如我们需要生成10个Fibonacci数列的项，两者的运行结果相同，如下：

虽然结果相同，但实际效果却相差巨大。来看一下方法一，他是通过while循环立即生成一个列表用来存放数据，接着再从已有的数据中读取所需数据，而这需要占用一定的内存空间；再来看一下方法二，它并没有用到列表，而是返回一个迭代器，在需要的时候生成相关数据。纵观以上两种方法，在生成个数较小时，两者相差不大，但当生成个数是10万，100万，1000万呢？前者需要消耗大量的内存资源，而后者仅需占用一点内存即可。这也是python2中range（）函数和python3中range（）函数的不同点，python3的range（）函数采用了迭代器的方式，不再依赖于现有的数据集合，也就相当于python2中的xrange()函数。

五、小结：
1.可迭代对象不一定是迭代器。

2.迭代器一定是可迭代对象。

3.容器类型（list tuple dict str set ）是可迭代对象但不是迭代器。

 
————————————————
版权声明：本文为CSDN博主「xcy.小相」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45807032/article/details/105219674