Python之路(第十篇)迭代器协议、for循环机制、三元运算、列表解析式、生成器

一、迭代器协议

a迭代的含义

  迭代器即迭代的工具，那什么是迭代呢？
  #迭代是一个重复的过程，每次重复即一次迭代，并且每次迭代的结果都是下一次迭代的初始值

b为何要有迭代器？

对于序列类型：字符串、列表、元组，我们可以使用索引的方式迭代取出其包含的元素。但对于字典、集合、文件等类型是没有索引的，若还想取出其内部包含的元素，则必须找出一种不依赖于索引的迭代方式，这就是迭代器

c可迭代对象

可迭代对象指的是内置有iter方法的对象,即字符串、元组、列表、集合、字典、文件，

  
  'hello'.__iter__
  (1,2,3).__iter__
  [1,2,3].__iter__
  {'a':1}.__iter__
  {'a','b'}.__iter__
  open('a.txt').__iter__

d迭代器对象

  
  可迭代对象执行obj.__iter__()得到的结果就是迭代器对象
  而迭代器对象指的是即内置有__iter__又内置有__next__方法的对象

可迭代对象（字符串、元组、列表、集合、字典、文件）通过调用

  
  __iter__()

方法，这里是遵循迭代器协议，将可迭代对象转为一个迭代器，这时既可以调用

  
  __iter__()方法又内置有__next__()方法

即为迭代器对象。迭代器对象是一个内存地址。

迭代器对象本身也可以使用__iter__()方法

迭代器对象再次使用__iter__()方法生成的还是迭代器对象。

例子

  dic = {"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}
  iter_dic = dic.__iter__()
  print(iter_dic)
  v =iter_dic.__iter__()
  print(v)

　　

输出结果

  <dict_keyiterator object at 0x02191600>
  <dict_keyiterator object at 0x02191600>

　　

分析：这里可以看到，对字典dic调用了__iter__()方法，使其变成迭代器对象，再次对这个迭代器对象使用__iter__()方法还是其本身。

e迭代器协议

1.迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么就引起一个StopIteration异常，以终止迭代 （只能往后走不能往前退）

2.可迭代对象：实现了迭代器协议的对象（如何实现：对象内部定义一个iter()方法）

3.协议是一种约定，可迭代对象实现了迭代器协议，python的内部工具（如for循环，sum，min，max函数等)使用迭代器协议访问对象。

f注意：

迭代器对象一定是可迭代对象，而可迭代对象不一定是迭代器对象。

例子

  s  = "hello"
  iter_s = s.__iter__() #将字符串用__iter__()方法转换为迭代器对象
  print(iter_s.__next__())  #调用__next__()方法依次按照顺序打印每个字符
  print(iter_s.__next__())
  print(iter_s.__next__())
  print(iter_s.__next__())
  print(iter_s.__next__())
  print(iter_s.__next__()) #抛出异常StopIteration，或者说结束标志

　　

  ​

输出结果

  h
  e
  l
  l
  o
  #抛出异常StopIteration，或者说结束标志，StopIteration

　　

这里等同于用for循环打印

  
  s  = "hello"
  for i in s:  #for i in s.__iter__()
      print(i)  #print(iter_s.__next__())直到出现StopIteration，然后结束循环

　　

分析：这里的for 循环里的for i in s，s调用了__iter__()方法，将s变为一个迭代器对象，同时对这个迭代器对象使用

__next__()方法打印出来，循环访问，并处理了最后的StopIteration，结束了循环。

小知识

next()方法是调用python解释器的，等同于某个可迭代对象下的__next__()方法

即

  #print（next（iter_s））等同于print(iter_s.__next__())

　　

例子2

  dic = {"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}
  iter_dic = dic.__iter__()
  print(iter_dic.__next__())
  print(iter_dic.__next__())
  print(iter_dic.__next__())
  print(iter_dic.__next__())
  # print(iter_dic.__next__())  产生StopIteration停止标志

　　

输出结果

  k1
  k2
  k3
  k4

　　

改成for循环

  dic = {"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}
  for i in dic:  #dic调用了__iter__方法，将其改成迭代器对象
      print(i)   #使用__next__()方法挨个去打印，直到出现StopIteration结束

　　

用while循环实现

  dic = {"k1":"v1","k2":"v2","k3":"v3","k4":"v4"}
  iter_dic = dic.__iter__()
  while True:
      try:
          print(iter_dic.__next__())
      except StopIteration:
          print("迭代结束了，循环终止")
          break
          

　　

输出结果

  k1
  k2
  k3
  k4
  #迭代结束了，循环终止

　　

g迭代器的优缺点

优点：

• 提供一种统一的、不依赖于索引的迭代方式

• 惰性计算，节省内存

缺点：

• 无法获取长度（只有在next完毕才知道到底有几个值）

• 一次性的，只能往后走，不能往前退

二、三元运算

三元表达式的格式

  
  为真时的结果 if 判定条件 else 为假时的结果

如果条件成立，返回if前面的结果，否则else 返回else后的结果

例子

  a = 2
  b = 3
  s  = a if a < b else b   #这里的if语句后不加冒号
  print(s)

　　

输出结果

  2

　　

例子2

  name = input('姓名>>: ')
  res = 'SB' if name == 'ken' else 'NB'
  print(name,res)
 

　　

三、列表解析式

列表解析是Python迭代机制的一种应用，它常用于实现创建新的列表，返回的是一个列表，因此用在[]中。

例子

生成1-100以内的偶数

普通使用for循环的方式

  li  = []
  for i in range(1,101):
      if i % 2 == 0:
          li.append(i)
      else:
          pass
  print(li)

　　

使用列表解析式

  li  = []
  res = [i for i in range(1,101)if i % 2 == 0 ]
  print(res)
 

　　

例子2

将字符串变大写组成列表

普通方式

  s  = "nicholas"
  li = []
  for i in s :
      res = i.upper()
      li.append(res)
  print(li)

　　

列表解析式

  s  = "nicholas"
  li = [i.upper() for i in s ]
  print(li)

　　

四、生成器

如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。

第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator，即生成器表达式：

生成器表达式能做的事情列表解析基本都能处理，只不过在需要处理的序列比较大时，列表解析比较费内存。

例子

  li = [i*i for i in range(10) ]
  print(li)

　　

输出结果

  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

　　

分析：这里是生成了一个0到9的平方的列表。

这里要改成生成器只要把列表生成式的[]改成()

  li = [i*i for i in range(10) ]
  g = (i*i for i in range(10) )
  print(li)
  print(g)

　　

输出结果

  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  <generator object <genexpr> at 0x02221600>

　　

分析：这里的<generator object <genexpr> at 0x02221600>就是一个生成器。这是生成器的第一种形式。

生成器是包含有__iter__()和__next__()方法的，所以可以直接使用for来迭代

在这里调用__next__()方法或者用next()直接打印

  li = [i*i for i in range(5) ]
  g = (i*i for i in range(5) )
  print(li)
  print(g)
  print(g.__next__())
  print(g.__next__())
  print(g.__next__())
  print(next(g))
  print(next(g))
  #print(next(g))    #执行到此处就会产生一个StopIteration错误，类似可迭代对象调用__next__()一样

　　

输出结果

  [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  <generator object <genexpr> at 0x02211600>
  0
  1
  4
  9
  16

　　

这里的g生成器就是一个迭代器。

这里也可以用for循环直接打印

li = [i*i for i in range(5) ]
g = (i*i for i in range(5) )
print(li)
for i in g:
    print(i)

　　

输出结果

[0, 1, 4, 9, 16]
0
1
4
9
16

　

分析：同样的这里的对生成器g的for循环自动处理了StopIteration错误，结束了for循环。与处理可迭代对象的方式类似。

第二种是生成器函数：

在函数中如果出现了yield关键字，那么该函数就不再是普通函数，而是生成器函数。生成器函数可以生产一个无线的序列，这样列表根本没有办法进行处理。

yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator。函数名+括号就变成了生成器。

例子

下面为一个可以生产奇数的生成器函数。

def num():
    n=1
    while True:
        print("函数内的第一处",n)
        yield n
        print("函数内奇数", n)
        n+=2
        print("函数内的第二处", n)
new_num = num()
print(new_num)
next(new_num)
print("函数外面的",next(new_num))

　　

输出结果

<generator object num at 0x02421660>
函数内的第一处 1
函数内奇数 1
函数内的第二处 3
函数内的第一处 3
函数外面的 3

　　

分析：执行print(new_num)语句可以看到，这里的自定义函数是一个生成器，通过next()方法调用执行函数内部语句，这里的yield相当于return的功能，每次next()返回一个迭代值，下次next（）继续执行循环，于是函数继续执行，直到再次遇到 yield，再次返回。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。而不是在while True语句下一次性执行完语句。

yield 与 return

return 是返回并中止函数

yield 是返回数据，并冻结当前的执行过程

next唤醒冻结的函数执行过程，继续执行，直到遇到下一个yield

例子

def g():
   yield 1
   yield 2
   yield 3
new_g = g()
print(next(new_g)) 
#第一次调用next(new_g)时，会在执行完yield语句后挂起，所以此时程序并没有执行结束，函数返回数据1，并冻结当前执行过程，等待下一个next()唤醒执行过程
print(next(new_g))
#通过next()唤醒执行过程，yield返回数据2，冻结执行过程，等待下一个next()
print(next(new_g))
# print(next(new_g))  
#这里如果运行上面这条语句，程序试图从yield语句的下一条语句开始执行，发现已经到了结尾，所以抛出StopIteration异常。

　　

输出结果

1
2
3

　　

分析：在一个生成器中，如果没有return，则默认执行到函数完毕时返回StopIteration；

如果遇到return,如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。

例子

def g():
   yield 1
   yield 2
   return "a"
   yield 3
new_g = g()
print(next(new_g))#通过next()执行函数，得到返回数据1，冻结当前过程，等待下一个next()唤醒
print(next(new_g))#通过next()执行函数，得到返回数据1，冻结当前过程，等待下一个next()唤醒
print(next(new_g))#通过next()执行函数，遇到return语句，直接抛出StopIteration 终止迭代，这样yield '3'语句永远也不会执行。
print(next(new_g))

　　

输出结果

1
Traceback (most recent call last):
2
 File "D:/exercise/test1.py", line 11, in <module>
    print(next(new_g))
StopIteration: a  #如果在return后返回一个值，那么这个值为StopIteration异常的说明，不是程序的返回值。

　　

如果在return后返回一个值，那么这个值为StopIteration异常的说明，不是程序的返回值。

生成器没有办法使用return来返回值。

例子

与上面的例子基本相同，只是修改了return的返回值

def g():
   yield 1
   yield 2
   return "some"
   yield 3
new_g = g()
print(next(new_g))
print(next(new_g))
print(next(new_g))
print(next(new_g))

输出结果

1
Traceback (most recent call last):
2
 File "D:/exercise/test1.py", line 11, in <module>
    print(next(new_g))
StopIteration: some    #生成器return返回的值是为StopIteration异常的说明，不是程序的返回值。

　　

生成器支持的方法

close()

手动关闭生成器函数，后面的调用会直接返回StopIteration异常。

例子

def g():
   yield 1
   yield 2
   yield 3

new_g = g()
print(next(new_g))
print(next(new_g))
new_g.close()   #这里通过cloes()方法直接关闭了生成器，后续通过next()也无法唤醒生成器继续执行返回数据，也就是说无法返回数据3，在这里直接抛出StopIteration异常
print(next(new_g))
print(next(new_g))

　

输出结果

1
Traceback (most recent call last):
2
  File "D:/exercise/test1.py", line 11, in <module>
    print(next(new_g))
StopIteration

　　

send()方法

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

例子

def gen():
      value = 0
      while True:
          receive = yield value
          if receive == "stop":
              break
          value = 'got: %s' % receive
  ​
  g=gen()
  print(g.send(None))
  print(g.send('aaa'))
  print(g.send(3))
  print(g.send('stop'))

　　

输出结果

  Traceback (most recent call last):
    File "D:/exercise/test6.py", line 18, in <module>
      print(g.send('stop'))
  StopIteration
  0
  got: aaa
  got: 3

　　

分析：

执行过程：

1、首先g.send(None)或者g.next()唤醒生成器，并执行到receive = yield value语句，冻结执行过程，等下一个next()、g.send()、g.close(),此时，执行完了yield语句，但是没有给receive赋值。

注意：在启动生成器函数时只能send(None)或者next(g),如果试图输入其它的值都会得到错误提示信息。

2、通过g.send('aaa')，会传入aaa，并赋值给receive，然后计算出value的值，并回到while头部，执行yield value语句有停止。

此时yield value会输出"got: aaa"，然后冻结执行状态。

3、通过g.send(3)，会重复第2步，最后输出结果为"got: 3"

4、通过g.send('stop')，传入生成器函数，赋值给receive,执行if receive == "stop":break 退出循环，整个函数执行完毕，最后出现StopIteration异常

throw()

throw()用来向生成器函数送入一个异常，可以结束系统定义的异常，或者自定义的异常。throw()后直接抛出异常并结束程序，或者消耗掉一个yield，或者在没有下一个yield的时候直接进行到程序的结尾。

例子

def gen():
      while True:
          try:
              yield 'normal value'
              yield 'normal value 2'
              print('here')
          except ValueError:
              print('we got ValueError here')
          except TypeError:
              break
  g=gen()
  print(next(g))
  print(g.throw(ValueError))
  print(next(g))
  print(next(g))
  print(next(g))
  print(g.throw(TypeError))

　　

输出结果

  normal value
  we got ValueError here
  normal value    
  normal value 2
  here
  normal value
  normal value 2
  Traceback (most recent call last):
   File "D:/exercise/test6.py", line 22, in <module>
   print(g.throw(TypeError))
  StopIteration

　　

分析：

执行过程

1、通过print(next(g))唤醒生成器，执行到yield 'normal value'，返回"normal value"被输出，冻结生成器函数执行过程

2、执行print(g.throw(ValueError))语句，出现了ValueError，这里直接执行了except ValueError下的内容，循环继续，返回try语句，执行了yield 'normal value'，这里又输出了一个“normal value”，之后冻结执行过程

3、执行了print(next(g))，函数里执行yield 'normal value 2'语句，输出“normal value 2”，冻结执行过程，

4、执行了print(next(g))，函数里开始继续执行，输出“here”,之后调到开始执行yield 'normal value'，输出“normal value”，冻结执行过程

5、执行了print(next(g))，函数里执行yield 'normal value 2'，输出“normal value 2”，冻结执行过程

6、通过print(g.throw(TypeError))，跳出try语句，出现TypeError，直接执行except TypeError:

跳出while循环，到达生成器函数结尾，所以抛出StopIteration异常。