迭代器 (iterator)

迭代：每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。
例如：循环获取容器中的元素。

可迭代对象 (iterable)

1. 定义：具有__iter__函数的对象，返回迭代器对象。
2. 语法

• 创建：

  class 可迭代对象名称:
  
  	def __iter__(self):
  		return 迭代器
  

• 使用：

  for 变量名 in 可迭代对象:
  	语句
  

3. 原理：迭代器 = 可迭代对象.iter()

   while True:
   	try: 
   		print(迭代器.__next__())
   	except StopIteration:
   		break
   

4. for循环原理
   可以被for的条件：对象具有__iter__()方法

   list01 = [1, 2, 3, 4, 5]
   # 迭代
   for item in list01:
   	print(item)
   # 1. 获取迭代器
   iterator = list01.__iter__()
   while True:
       try:
   		# 2. 获取下一个元素
           item = iterator.__next__()
           print(item)
   	# 3. 如果没有元素则结束循环
       except StopIteration:
           break
   

迭代器对象 (iterator)

1. 定义：可以被next()函数调用并返回下一个值的对象。
2. 语法

   class 迭代器类名:
   
       def __init__(self, 聚合对象):
           self.聚合对象= 聚合对象 
   
       def __next__(self): 
   		if 没有元素:
   			raise StopIteration
   		return 聚合对象元素
   

3. 说明：聚合对象通常是容器对象。
4. 作用：
   使用者只需通过一种方式，便可简洁明了的获取聚合对象中各个元素，而又无需了解其内部结构。
   无论存储数据的具体容器是什么，可以以一种方式获取每个数据。

   # 迭代器
   class Iterator:
   
       def __init__(self, data):
           self. __data = data
           self.__index = 0
   
       def __next__(self):
       	try:
       		item = self.__data[self.__index]
       		self.__index += 1
       		return item
       	except:
       		raise StopIteration()
   
   # 可迭代对象
   class StudentManager:
   
       def __init__(self):
           self.__list_stus = ['吕布', '赵云', '典韦']
   
       def add_stu(self, name):
           self.__list_stus.append(name)
   
       def __iter__(self):
           return Iterator(self.__list_stus)
   
   
   manager = StudentManager()
   
   for item in manager:
       print(item)
   

生成器 (generator)

1. 定义：能够动态(循环一次 计算一次 返回一次)提供数据的可迭代对象。
2. 作用：
   在循环过程中，按照某种算法(+=1)推算数据，不必创建容器存储完整的结果，从而节省内存空间。
   数据量越大，优势越明显。
3. 以上作用也称之为延迟操作或惰性操作，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果。
4. 优点：节省内存。
5. 缺点：不能灵活访问数据(索引,切片)。

生成器函数

1. 定义：含有yield语句的函数，返回值为生成器对象。
2. 语法

• 创建：

  def 函数名():
  	语句
  	yield 数据
  

• 调用：

  for 变量名 in 函数名():
  	语句
  

• 伪代码：生成器 --> 迭代器 + 可迭代对象

  class Generator: 
      
      def __iter__(self):
          return self
      
      def __next__(self):
          ... 
  

3. 说明：
   调用生成器函数将返回一个生成器对象，不执行函数体。
   yield翻译为”产生”或”生成”。
4. 执行过程：
   (1) 调用生成器函数会自动创建迭代器对象。
   (2) 调用迭代器对象的__next__()方法时才执行生成器函数。
   (3) 每次执行到yield语句时返回数据，暂时离开。
   (4) 待下次调用__next__()方法时继续从离开处继续执行。
5. 原理：生成迭代器对象的大致规则如下
   将yield关键字以前的代码放在next方法中。
   将yield关键字后面的数据作为next方法的返回值。

   def my_range(end):
       begin = 0
       while begin < end:
           yield begin  # 暂时离开，再次调用继续执行
           begin += 1
   
   for item in my_range(100):
       print(item)  # 0 1 2 3 4
   

内置生成器

枚举函数 (enumerate)

1. 语法：

   for 变量 in enumerate(可迭代对象):
   	语句
   for 索引, 元素in enumerate(可迭代对象):
   	语句
   

2. 作用：遍历可迭代对象时，可以将索引与元素组合为一个元组。
3. 原理：

   def my_enumerate(iterable):
       index = 0
       for item in iterable:
           yield (index, item)
           index += 1
   
   list01 = [1, 2, 3, 4, 5]
   for index, item in my_enumerate(list01):
       print(index, item)
   # 等价于
   for index, item in enumerate(list01):
       print(index, item)
   

zip

1. 语法：

for item in zip(可迭代对象1, 可迭代对象2….):
	语句

2. 作用：将多个可迭代对象中对应的元素组合成一个个元组，生成的元组个数由最小的可迭代对象决定。
3. 原理：

   def my_zip(iterable01, iterable02):
       for i in range(len(iterable01)):
           yield (iterable01[i], iterable02[i])
   
   list01 = ["悟空", "八戒", "沙僧"]
   for item in my_zip(list02, list01):
       print(item)
   # 等价于
   for item in zip(list02, list01):
       print(item)
   
   

生成器表达式

1. 定义：用推导式形式创建生成器对象
2. 语法：变量 = ( 表达式 for 变量 in 可迭代对象 if 真值表达式)

   list01 = [1, 2, 3, 4, 5]
   for item in (item + 10 for item in list01 if item % 2):
       print(item)
   

最后

以上就是有魅力盼望为你收集整理的迭代器和生成器迭代器 (iterator)生成器 (generator)的全部内容，希望文章能够帮你解决迭代器和生成器迭代器 (iterator)生成器 (generator)所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。