Python3之迭代器，生成器

一、可迭代对象和迭代器

1.迭代的概念

上一次输出的结果为下一次输入的初始值，重复的过程称为迭代,每次重复即一次迭代，并且每次迭代的结果是下一次迭代的初始值
注：循环不是迭代

1. 迭代器：可以被next()函数调用并不断返回下一个值的对象称为迭代器
2. 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
3. 迭代器有两个基本的方法：iter() 和 next()。
4. 可使用isinstance()判断一个对象是否是迭代器对象（Iterator）
5. Python3中range(n)生成的是迭代器对象； python2中xrange(n)生成的才是迭代器对象
6. 原生函数iter(instance) 可以判断某个对象是否可迭代，它的工作流程大概分为以下3个步骤：
   检查对象instance是否实现了__iter__方法，并调用它获取返回的迭代器(iterator)。
   如果对象没有实现__iter__方法，但是实现了__getitem__方法，Python会生成一个迭代器。
   如果上述都失败，则编译器则抛出TypeError错误，‘xxx’ Object is not iterable。

while True: #只满足重复，因而不是迭代
     print('====>')

2.可迭代的对象

内置__iter__方法的，都是可迭代的对象。
迭代是Python最强大的功能之一，是访问集合元素的一种方式。。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 生成迭代器和 next()遍历迭代器元素。

dil = iter(range(10))  #使用iter方法创建一个迭代器
print(type(dil))    #类型为迭代器
	<class 'range_iterator'>
print(dil)
	<range_iterator object at 0x7fb9bf466ed0>
l1 = [1,2,3,4,5]
it = iter(l1)    #将列表转换为迭代器
print(type(it))
	<class 'list_iterator'>
 print(it)
	<list_iterator object at 0x7fb9bf42e9e8>

print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(next(it))
print(next(it))   #如果迭代器元素到最后没有了就会报错
Traceback (most recent call last):
	  File "<stdin>", line 1, in <module>
StopIteration

for i in it:    #此处因为迭代元素已经到了最后，所以没有元素输出
	    print(i,end=" ")
print(next(dil))   #使用next输出迭代器的下一个元素
print(next(dil))
print(next(dil))
print(next(dil))
for i in dil:    #而输出dil迭代器的元素会接着输出迭代器的元素，知道最后一个。
 	 print(i,end=" ")

list = [1,2,3,4,5,6,7,8]
inter1 = list.__iter__()   #遵循迭代器协议，生成可以迭代的对象
print(inter1.__next__())
print(inter1.__next__())

集合中使用迭代器

 s1 = {'python','java','net','php'}
iter2 = s1.__iter__()
print(iter2)
	#<set_iterator object at 0x7fb9bf450ea0>
print(iter2.__next__())  # java
print(iter2.__next__()) # php
print(iter2.__next__()) # net
print(iter2.__next__() )  # python

字典中使用迭代器

 dict1 = {'k1':'v1','k2':'v2'}
iter3 = dict1.__iter__()
print(iter3.__next__())   #字典默认迭代的是key值  #k1
print(iter3.__next__())     #k2

文件中使用迭代器

with open('test','r') as f1:
	iter5 = f1.__iter__()
 	print(iter5.__next__(),end = ' ')
	print(iter5.__next__(),end = ' ')
	print(iter5.__next__(),end = ' ')
 # 2222
  #4444
 # 6666

import sys         # 引入 sys 模块
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
while True:
   try:
       print (next(it))
   except StopIteration:
       sys.exit()

class IterText:
  def __init__(self, text):
      self.text = text

  def __iter__(self):
      return IteratorText(self.text)


class IteratorText:
  def __init__(self, text):
      self.text = text
      self.index = 0

  def __iter__(self):
      return self

  def __next__(self):
      try:
          letter = self.text[self.index]
      except IndexError:
          raise StopIteration
      self.index += 1
      return letter

text = IterText("hey")
for l in text:
  print(l)

class Iter1:
  def __init__(self, text):
      self.text = text

  def __iter__(self):
      return iter(self.text)

iter1 = Iter1("hello")
for s in iter1:
  print(s)

那么如何判断一个对象是否是可迭代呢？使用collections模块的Iterable类型判断

from collections import Iterable
print(isinstance('abc', Iterable)) # str是否可迭代
#True
print(isinstance([1,2,3], Iterable)) # list是否可迭代
#True
print(isinstance(123, Iterable)) # 整数是否可迭代
#False　

2、生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
1.生成器函数：常规函数定义，但是，使用yield语句而不是return语句返回结果。yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次重它离开的地方继续执行
2.生成器表达式：类似于列表推导，但是，生成器返回按需产生结果的一个对象，而不是一次构建一个结果列表
为何使用生成器之生成器的优点
Python使用生成器对延迟操作提供了支持。所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果。这也是生成器的主要好处。
生成器小结：
1.是可迭代对象
2.实现了延迟计算,省内存啊
3.生成器本质和其他的数据类型一样，都是实现了迭代器协议，只不过生成器附加了一个延迟计算省内存的好处

def ite():
 print('hello')
 yield 'test1'
 print('world')
 yield 'test2'
 yield 'test3'
 yield 'test4'

gen = ite()   #生成了一个生成器
print(type(gen))
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())
print(gen.__next__())

<class 'generator'>
hello
test1
world
test2
test3
test4

生成器方法：

close()：手动关闭生成器，后面的调用会直接返回Stoplteration异常。
def gen():
 	yield 'hello'
 	yield 'python'
 
st = gen()
print(st.__next__())
hello
st.close()   #关闭生成器后再显示元素就抛出异常
print(st.__next__())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
StopIteration

send()：生成器函数最大的特点是可以接受外部传入的一个变量，并根据变量内容计算结果后返回。

def consumer(name):
    print('begin..')
    while True:
        baozi = yield name  #第一次执行时返回name的值，然后将send的值赋值给yield
        print('is you %s' %baozi)  #所以此时baozi的值为1

d = consumer('zhang')
print(d.__next__())
print(d.send(1))
print(d.send(2))
print(d.send(3))
print(d.send(5))

begin..
zhang
is you 1
zhang
is you 2
zhang
is you 3
zhang
is you 5
zhang

import sys
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

python 语言特性

1 生成器表达式

g = (x ** 2 for x in range(10))
print(next(g))
print(next(g))
print(sum(x ** 3 for x in range(10)))  # 2025
print(sum(x ** 3 for x in range(10) if x % 3 == 1))  # 408

2 迭代字典

print({x: x ** 2 for x in range(5)})
#{ 0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
print({x: 'A'+ str(x) for x in range(5)})
#{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4'}

3、通过迭代字典反转字典

m = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5 }
print(m)
print({v : k for k, v in m.items()})
#{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}