Python迭代与生成器

迭代

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

可迭代对象iterable 

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

2.语法

-- 创建：

class 可迭代对象名称:

  def __iter__(self):

      return 迭代器

-- 使用：

for 变量名 in 可迭代对象:

　　语句

3.原理：

迭代器 = 可迭代对象.__iter__()

while True:

    try:

        print(迭代器.__next__())

    except StopIteration:

         break

list01 = [43,4,54,5,566,7,7]
# for itme in list01:
#   print(itme)

#对象具有__iter__()方法

# for原理:
# 1. 获取迭代器对象
iterator = list01.__iter__()
# 2. 循环获取下一个元素
while True:
  try:
    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 SkillIterator:
  """
    迭代器
  """

  def __init__(self, target):
    self.target = target
    self.index = 0

  def __next__(self):
    # 需求:将SkillManager中__list_skill的元素返回
    # 创建一个下标索引index,与列表的长度比较，要求下表索引不能超过列表的长度
    if self.index > len(self.target) - 1:
      raise StopIteration()
    # 下标每次+1，并将每次下标元素返回去
    result = self.target[self.index]
    self.index += 1
    return result


class Skill:
  pass

class SkillManager:
  def __init__(self):
    self.__list_skill = []

  def add_skill(self, skill):
    self.__list_skill.append(skill)

  def __iter__(self):
    return SkillIterator(self.__list_skill)


manager = SkillManager()
manager.add_skill(Skill())
manager.add_skill(Skill())
manager.add_skill(Skill())


iterator = manager.__iter__()
while True:
  try:
    item = iterator.__next__()
    print(item)
  except StopIteration:
    break

class Skill:
  pass


class SkillManager:
  """
    可迭代对象
  """

  def __init__(self):
    self.__list_skill = []

  def add_skill(self, skill):
    self.__list_skill.append(skill)

  def __iter__(self):
    # return SkillIterator(self.__list_skill)

    for item in self.__list_skill:
      yield item

    """
      执行过程:
         1. 调用__iter__()方法程序不执行.
         2. 调用__next__()方法开始执行.
         3. 执行到yield语句暂时离开方法.
         4. 再次调用__next__()方法继续执行
         .....
      原理:如果方法体中包含yield语句,则自动生成迭代器代码.
      生成迭代器代码的大致规则:
        1.将yield关键字以前的代码,放到__next__()方法中.
        2.将yield关键字以后的数据,作为__next__()方法返回值.
    """

    # print("准备第一个元素:")
    # yield self.__list_skill[0]
    #
    # print("准备第二个元素:")
    # yield self.__list_skill[1]
    #
    # print("准备第三个元素:")
    # yield self.__list_skill[2]


manager = SkillManager()
manager.add_skill(Skill())
manager.add_skill(Skill())
manager.add_skill(Skill())


iterator = manager.__iter__()
while True:
  try:
    item = iterator.__next__()
    print(item)
  except StopIteration:
    break

tuple01 = (4, 4, 5, 565, 6, 7)
iterator = tuple01.__iter__()
while True:
  try:
    item = iterator.__next__()
    print(item)
  except:
    break

dict01 = {"张无忌":3,"赵敏":2}
iterator = dict01.__iter__()
while True:
  try:
    key = iterator.__next__()
    value = dict01[key]
    print(key,value)
  except:
    break

生成器generator

1.定义：能够动态(循环一次计算一次返回一次)提供数据的可迭代对象。

2.作用：在循环过程中，按照某种算法推算数据，不必创建容器存储完整的结果，从而节省内存空间。数据量越大，优势越明显。

3.以上作用也称之为延迟操作或惰性操作，通俗的讲就是在需要的时候才计算结果，而不是一次构建出所有结果。

生成器函数

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

2.语法

-- 创建：

def 函数名():

…

yield 数据

…

-- 调用：

 for 变量名 in 函数名():

  语句

class MyGenerator:
  """
    备注:本类是生成器的"源码",只需要看,不需要写.
    生成器:可迭代对象 + 迭代器对象
  """

  def __init__(self, stop_value):
    self.__stop_value = stop_value
    self.__start_value = 0

  def __iter__(self):
    return self

  def __next__(self):
    if self.__start_value >= self.__stop_value:
      raise StopIteration()
    result = self.__start_value
    self.__start_value += 1
    return result


def my_range(stop_value):
  start_value = 0
  while start_value < stop_value:
    yield start_value
    start_value += 1


# 0 1 2 3 4
result = my_range(5)
# 生成器对象.__iter__() 返回的结果就是生成器对象
# 140573829693376
print(id(result.__iter__()))
# 140573829693376
print(id(result))

# 函数体包含yield语句,返回值类型是生成器.
print(type(result))
#<class 'generator'>
for item in result:
  print(item)

3.说明：

-- 调用生成器函数将返回一个生成器对象，不执行函数体。

--  yield翻译为”产生”或”生成” 

4.执行过程：

(1) 调用生成器函数会自动创建迭代器对象。

(2) 调用迭代器对象的__next__()方法时才执行生成器函数。

(3) 每次执行到yield语句时返回数据，暂时离开。

(4) 待下次调用__next__()方法时继续从离开处继续执行。

5.原理：生成迭代器对象的大致规则如下

-- 将yield关键字以前的代码放在next方法中。

-- 将yield关键字后面的数据作为next方法的返回值。

def get_even(list_target):
  for item in list_target:
    if item % 2 == 0:
      # return item  返回一个数据,退出方法.
      yield item  # 返回多个数据,暂时离开方法


list01 = [34, 4, 54, 5, 7, 8]
result = get_even(list01)
# print(result)
# 没有事先存储所有偶数,
# 而是循环一次  计算一次  返回一次
for item in result:
  print(item)

内置生成器

枚举函数enumerate

1.语法：

for 变量 in enumerate(可迭代对象):

     语句

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

    语句

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

def my_enumerate(list_target):
  for i in range(len(list_target)):
    yield (i, list_target[i])

for item in my_enumerate([3,34,4,5,6]):
  print(item)

for index,item in enumerate([3,34,4,5,6]):
  print(index,item)

zip

1.语法：

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

     语句

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

def my_zip(list01,list02):
  for i in range(len(list01)):
    yield (list01[i] ,list02[i])

for item in my_zip([2,4,45],[5,6,8]):
  print(item)
#(2, 5)
#(4, 6)
#(45, 8)
list01 = ["张无忌","赵敏","周芷若"]
list02 = [101,102]
for item in zip(list01,list02,list02):
  print(item)
#('张无忌', 101, 101)
#('赵敏', 102, 102)

生成器表达式

1.定义：用推导式形式创建生成器对象。

2.语法：变量 = ( 表达式 for 变量 in 可迭代对象 [if 真值表达式] )

list01  = [4,4,5,56,6,78]
# 立即执行,将所有结果存入内存
result01 = [item for item in list01 if item >5]
for item in result01:
  print(item)
# 56 6 78
result02 = (item for item in list01 if item >5)
# 延迟执行,循环一次 计算一次  返回一个(覆盖了上一个)
for item in result02:
  print(item)
#56 6 78

总结：

(1)迭代器,生成器是什么?

1.迭代器是一个更加抽象的概念,任何对象,如果他的类有next方法和iter方法返回自身.对于string,list,dict,tuple等这类容器对象,使用for循环遍历是很方便的.在后台for语句对容器对象调用了iter()函数,iter()是python的内置函数.iter()会返回一个定义了next()方法的迭代器对象,他在容器中逐个访问容器内元素,next()也是python的内置函数在没有后续元素时,next()会排除一个Stoplterration的异常.

2.生成器是创建迭代器的简单而强大的工具,只是在返回数据的时候需要使用yield语句.每次next()被调用时,生成器就会返回他脱离的位置(它记忆语句最后一次执行的位置和所有的数据值)

(2)他们的区别?

生成器一次只返回一个值,降低内存消耗,而迭代器一次返回所有值.

生成器能做到迭代器能做的所有事,而且因为自动创建了 __ iter __ ()和next()方法,生成器显得特别简洁,而且生成器也是高效的,使用生成器表达式取代列表解析可以同时节省内存,除了创建和保持程序状态的自动生成,当生成器终结时,也会自动抛出Stoplterration的异常