10.1、Python3 条件控制

Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。

10.1.1、if 语句

Python 中 if 语句的一般形式如下所示：

if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3

• 如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
• 如果 "condition_1" 为False，将判断 "condition_2"
• 如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
• 如果 "condition_2" 为False，将执行"statement_block_3"块语句

Python 中用 elif 代替了 else if，所以if语句的关键字为：if – elif – else。
注意：
if elif else 结构是一种“互斥”条件检查，满足第一个条件后，不再检查其后的条件。
if if if 结构是一种“非互斥”条件检查，所有条件都会被独立检查，可能会执行多个条件块。

注意：

1. 每个条件后面要使用冒号 :，表示接下来是满足条件后要执行的语句块。
2. 使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3. 在Python中没有switch – case语句。

Gif 演示：

10.1.2、实例

以下是一个简单的 if 实例：

#!/usr/bin/python3

var1 = 100
if var1:
    print ("1 - if 表达式条件为 true")
    print (var1)

var2 = 0
if var2:
    print ("2 - if 表达式条件为 true")
    print (var2)
print ("Good bye!")

执行以上代码，输出结果为：

1 - if 表达式条件为 true
100
Good bye!

从结果可以看到由于变量 var2 为 0，所以对应的 if 内的语句没有执行。

以下实例演示了狗的年龄计算判断：

#!/usr/bin/python3

age = int(input("请输入你家狗狗的年龄: "))
print("")
if age < 0:
    print("你是在逗我吧!")
elif age == 1:
    print("相当于 14 岁的人。")
elif age == 2:
    print("相当于 22 岁的人。")
elif age > 2:
    human = 22 + (age -2)*5
    print("对应人类年龄: ", human)

### 退出提示
input("点击 enter 键退出")

将以上脚本保存在dog.py文件中，并执行该脚本：

$ python3 dog.py
请输入你家狗狗的年龄: 1

相当于 14 岁的人。
点击 enter 键退出

以下为if中常用的操作运算符:

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于
==	等于，比较两个值是否相等
!=	不等于

#!/usr/bin/python3

# 程序演示了 == 操作符
# 使用数字
print(5 == 6)
# 使用变量
x = 5
y = 8
print(x == y)

以上实例输出结果：

False
False

high_low.py文件演示了数字的比较运算：

#!/usr/bin/python3

# 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:
    guess = int(input("请输入你猜的数字："))

    if guess == number:
        print("恭喜，你猜对了！")
    elif guess < number:
        print("猜的数字小了...")
    elif guess > number:
        print("猜的数字大了...")

执行以上脚本，实例输出结果如下：

$ python3 high_low.py
数字猜谜游戏!
请输入你猜的数字：1
猜的数字小了...
请输入你猜的数字：9
猜的数字大了...
请输入你猜的数字：7
恭喜，你猜对了！

10.1.3、if 嵌套

在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。

if 表达式1:
    语句
    if 表达式2:
        语句
    elif 表达式3:
        语句
    else:
        语句
elif 表达式4:
    语句
else:
    语句

# !/usr/bin/python3

num=int(input("输入一个数字："))
if num%2==0:
    if num%3==0:
        print ("你输入的数字可以整除 2 和 3")
    else:
        print ("你输入的数字可以整除 2，但不能整除 3")
else:
    if num%3==0:
        print ("你输入的数字可以整除 3，但不能整除 2")
    else:
        print  ("你输入的数字不能整除 2 和 3")

将以上程序保存到 test_if.py 文件中，执行后输出结果为：

$ python3 test.py
输入一个数字：6
你输入的数字可以整除 2 和 3

10.2、Python3 循环语句

本章节将为大家介绍 Python 循环语句的使用。Python 中的循环语句有 for 和 while。Python 循环语句的控制结构图如下所示：

10.2.1、while 循环

Python 中 while 语句的一般形式：

while 判断条件：
    语句

执行 Gif 演示：

同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。

以下实例使用了 while 来计算 1 到 100 的总和：

#!/usr/bin/env python3

n = 100

sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1

print("1 到 %d 之和为: %d" % (n,sum))

执行结果如下：

1 到 100 之和为: 5050

10.2.1.1、无限循环

我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下：

#!/usr/bin/python3

var = 1
while var == 1 :  # 表达式永远为 true
   num = int(input("输入一个数字  :"))
   print ("你输入的数字是: ", num)

print ("Good bye!")

执行以上脚本，输出结果如下：

输入一个数字  :5
你输入的数字是:  5
输入一个数字  :

你可以使用 CTRL+C 来退出当前的无限循环。

无限循环在服务器上客户端的实时请求非常有用。

10.2.1.2、while ... else 语句

while … else 在条件语句为 false 时执行 else 的语句块：

#!/usr/bin/python3

count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

执行以上脚本，输出结果如下：

0  小于 5
1  小于 5
2  小于 5
3  小于 5
4  小于 5
5  大于或等于 5

10.2.1.3、简单语句组

类似 if 语句的语法，如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中，如下所示：

#!/usr/bin/python

flag = 1

while (flag): print ('欢迎访问菜鸟教程!')

print ("Good bye!")

注意：以上的无限循环你可以使用 CTRL+C 来中断循环。

执行以上脚本，输出结果如下：

欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
欢迎访问菜鸟教程!
……

10.2.2、for 语句

Python for 循环可以遍历任何序列的项目，如一个列表或者一个字符串。

for 循环的一般格式如下：

for <variable> in <sequence>:
    <statements>
else:
    <statements>

Python loop 循环实例：

>>>languages = ["C", "C++", "Perl", "Python"]
>>> for x in languages:
...     print (x)
...
C
C++
Perl
Python
>>>

以下 for 实例中使用了 break 语句，break 语句用于跳出当前循环体：

#!/usr/bin/python3

sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
    if site == "Runoob":
        print("菜鸟教程!")
        break
    print("循环数据 " + site)
else:
    print("没有循环数据!")
print("完成循环!")

执行脚本后，在循环到 "Runoob"时会跳出循环体：

循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!

10.2.2.1、range()函数

如果你需要遍历数字序列，可以使用内置range()函数。它会生成数列，例如:

>>>for i in range(5):
...     print(i)
...
0
1
2
3
4

你也可以使用range指定区间的值：

>>>for i in range(5,9) :
    print(i)

5
6
7
8
>>>

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'):

>>>for i in range(0, 10, 3) :
    print(i)

0
3
6
9
>>>

负数：

>>>for i in range(-10, -100, -30) :
    print(i)

-10
-40
-70
>>>

您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>

还可以使用range()函数来创建一个列表：

>>>list(range(5))
[0, 1, 2, 3, 4]
>>>

10.2.2.2、break、continue 和 else

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。 实例如下：

#!/usr/bin/python3

for letter in 'Runoob':     # 第一个实例
   if letter == 'b':
      break
   print ('当前字母为 :', letter)

var = 10                    # 第二个实例
while var > 0:
   print ('当期变量值为 :', var)
   var = var -1
   if var == 5:
      break

print ("Good bye!")

执行以上脚本输出结果为：

当前字母为 : R
当前字母为 : u
当前字母为 : n
当前字母为 : o
当前字母为 : o
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
Good bye!

continue语句被用来告诉Python跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

#!/usr/bin/python3

for letter in 'Runoob':     # 第一个实例
   if letter == 'o':        # 字母为 o 时跳过输出
      continue
   print ('当前字母 :', letter)

var = 10                    # 第二个实例
while var > 0:
   var = var -1
   if var == 5:             # 变量为 5 时跳过输出
      continue
   print ('当前变量值 :', var)
print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
当前字母 : b
当前变量值 : 9
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。

如下实例用于查询质数的循环例子:

#!/usr/bin/python3

for n in range(2, 10):
    for x in range(2, n):
        if n % x == 0:
            print(n, '等于', x, '*', n//x)
            break
    else:
        # 循环中没有找到元素
        print(n, ' 是质数')

执行以上脚本输出结果为：

2  是质数
3  是质数
4 等于 2 * 2
5  是质数
6 等于 2 * 3
7  是质数
8 等于 2 * 4
9 等于 3 * 3

10.2.2.3、pass 语句

Python pass是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句，如下实例

>>>while True:
...     pass  # 等待键盘中断 (Ctrl+C)

最小的类:

>>>class MyEmptyClass:
...     pass

以下实例在字母为 o 时 执行 pass 语句块:

#!/usr/bin/python3

for letter in 'Runoob':
   if letter == 'o':
      pass
      print ('执行 pass 块')
   print ('当前字母 :', letter)

print ("Good bye!")

执行以上脚本输出结果为：

当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!

10.2.3、举例

10.2.3.1、求偶数

打印 10 以内的偶数？

for i in range(10):
    if i & 1:        # 与运算是最快的，0与1得0，1与1得1，二进制只有0和1
        continue
    print(i)

10.2.3.2、求整除

计算 1000 以内的被 7 整除的前 20 个数(for 循环)？

count = 0
for i in range(0,1000,7):       # 思路有很多，步长为7最简单高效
    print(i)
    count += 1
    if count == 20:
        break

10.2.3.3、迭代求值

输入一个整数，用整数处理的方式从高位到低位截取出来？

# 迭代思想
num = int(input('please input a number: '))
digits = len(str(num))                      # 先算位数
times = digits - 1                          # 循环次数
while times >=0:
    output = num //(10**times)              # 截取高位
    print(output)
    num = num - output*(10**times)          # 算出剩余数用于迭代
    times -=1

10.2.3.4、拼形状

打印一个边长为 n 的正方形？

方法1：制作前两行用作模板，后面复制
n = int(input('please input rhomboid side: '))
for i in range(n-1):
    Topside = "*\t"*(n-1)+"*"       # 制作第一行模板
    Midside = "*"+"\t"*(n-1)+"*"    # 制作第二行模板
    if i == 0:
        print(Topside)
        print("\n")
    else:
        print(Midside)
        print("\n")
else:
    print(Topside)

方法2：利用对称的思想
# 边长为3，则-1 0 1 => range(-1,2)
# 边长为4，则-2 -1 0 1 => range(-2,2)
# 边长为5，则-2 -1 0 1 2 => range(-2,3)
n = int(input('please input rhomboid side: '))
e = -n//2
for i in range(e,n+e):          # 此处只用作循环次数，真正的意义是用于算法当中进行对称处理
    if i == e or i == n+e-1:
        print("*"*n)
    else:
        print("*"+" "*(n-2)+"*")

10.2.3.5、求阶乘

求 1 到 5 阶乘之和？

方法一：累乘累加
# 更高效
a = 1
sum = 0
for i in range(1,6):
    a = i * a           # 累积乘上去就是每一个数的阶乘
    sum = sum + a       # 累加上去就是阶乘之和
print(sum)

方法二：单独阶乘累加
# 嵌套循环效率低
sum = 0
factorial = 1
for i in range(1,6):
    for j in range(1,i+1):
        factorial *= j      # 两层循环为了将每个数进行阶乘运算，思路清淅，但是效率很低
    sum += factorial
    factorial = 1
print(sum)

10.2.3.6、素数判断

给一个数，判断是否是素数？

# 给定一个数n,若要两个数相乘等于n，那必然一个数大于等于根号n，另一个数小于等于根号n
n = int(input('please input one number: '))
for i in range(2,int(n**0.5)+1):
    if n % i == 0:
        print(n,'不是素数')
        break
else:
    print(n,"是素数")

10.2.3.7、99 乘法口诀

打印 99 乘法口诀表？

for i in range(1,10):
    for j in range(1,i+1):
        print('{} * {} = {:2d}'.format(j,i,i*j),end="   ")  # 直接从左向右打印
    print()

s = ""
for i in range(1,10):
    for j in range(i,10):
        s += '{} * {} = {:<{}}'.format(i, j, j*i, 2 if j<4 else 3) # 拼接成字符串，为的是右对齐
    print('{:>117}'.format(s))
    s = ""

10.2.3.8、打印菱形

# 打印菱形
import sys
line = int(input("please input rhomboid lines: "))
if line < 3 or line % 2 == 0:
    print("your input number is not proper to construct rhomboid, now exited!")
    print("please input odd number larger than 2")
    sys.exit(7)
symmetry_left = -(line//2)
symmetry_right = line + symmetry_left
for i in range(symmetry_left,symmetry_right):   # 这里的对称思想用得就巧妙，将对称数用在算法中进行对称处理
    if i < 0:
        print(" "*(-i)+"*"*(line+2*i))  # 打印菱形重点就在于找出每一行空格和 * 个数的规律
    else:
        print(" "*i+"*"*(line-2*i))

# 打印闪电
import sys
line = int(input("please input flash lines: "))
if line < 3 or line % 2 == 0:
    print("your input number is not proper to construct flash, now exited!")
    print("please input odd integer larger than 2")
    sys.exit(7)
symmetry_left = -(line//2)
symmetry_right = line + symmetry_left
for i in range(symmetry_left,symmetry_right): # 依然利用对称的巧秒思想
    if i < 0:
        print(" "*(-i)+"*"*(symmetry_right+i)) # 不管打印什么，重点依然是找出每一行空格和 * 个数的规律
    elif i == 0:
        print("*"*line)
    else:
        print(" "*abs(symmetry_left)+"*"*(symmetry_right-i))

10.2.3.9、求斐波那契

求 fib 数列 101 项？

a = 0
b = 1
for i in range(100):
    a, b = b, a+b       # python 特有的方式，封装与解构
else:
    print(b)

10.2.3.10、求素数

求 10 万内的所有素数？

方法1：
import datetime
start = datetime.datetime.now()
count = 1
for i in range(3,100000,2):
    for j in range(2,int(i**0.5)+1):    # 若要两个数相乘等于n，那必然一个数大于等于根号n，另一个数小于等于根号n
        if i % j == 0:
            break
    else:
        count += 1
print(count)
delta = (datetime.datetime.now()-start).total_seconds()
print(delta)

对上面的代码进行优化：
import datetime
start = datetime.datetime.now()
count = 1
for i in range(3,100000,2):         # 大于2的偶数都能被2整除，排除掉
    if i > 10 and i % 10 == 5:      # 大于10的个位数为5都可以被5整除，排除掉
        continue
    for j in range(3,int(i**0.5)+1,2):  # 奇数都不能被2整除，所以从3开始，步长为2是因为奇数不能被偶数整除
        if i % j == 0:
            break
    else:
        count += 1
print(count)
delta = (datetime.datetime.now()-start).total_seconds()
print(delta)

10.3、Python3 迭代器与生成器

10.3.1、迭代器

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

字符串，列表或元组对象都可用于创建迭代器：

>>> list=[1,2,3,4]
>>> it = iter(list)    # 创建迭代器对象
>>> print (next(it))   # 输出迭代器的下一个元素
1
>>> print (next(it))
2
>>>

迭代器对象可以使用常规 for 语句进行遍历：

#!/usr/bin/python3

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
for x in it:
    print (x, end=" ")

执行以上程序，输出结果如下：

1 2 3 4

也可以使用 next() 函数：

#!/usr/bin/python3

import sys         # 引入 sys 模块

list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象

while True:
    try:
        print (next(it))
    except StopIteration:
        sys.exit()

执行以上程序，输出结果如下：

1
2
3
4

10.3.1.1、创建迭代器

• 把一个类作为一个迭代器使用需要在类中实现两个方法 iter() 与 next() 。
• 如果你已经了解的面向对象编程，就知道类都有一个构造函数，Python 的构造函数为 init(), 它会在对象初始化的时候执行。
• iter() 方法返回一个特殊的迭代器对象， 这个迭代器对象实现了 next() 方法并通过 StopIteration 异常标识迭代的完成。
• next() 方法（Python 2 里是 next()）会返回下一个迭代器对象。

创建一个返回数字的迭代器，初始值为 1，逐步递增 1：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

执行输出结果为：

1
2
3
4
5

10.3.1.2、StopIteration

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 next() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 20 次迭代后停止执行：

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)

执行输出结果为：

1
2
...
19
20

10.3.2、生成器

10.3.2.1、生成器表达式语法

• (返回值 for 元素 in 可迭代对象 if 条件)
• 列表解析式的中括号换成小括号就行了
• 返回一个生成器

10.3.2.2、同列表解析式的区别

• 生成器表达式是按需计算( 或称惰性求值、延迟计算 )，需要的时候才计算值
• 列表解析式是立即返回值

10.3.2.3、生成器

• 可迭代对象
• 迭代器

g = ("{:04}".format(i) for i in range(1,11))
next(g)

for x in g:
    print(x)
print("----------------------")

for x in g:
    print(x)
===============================================
0002
0003
0004
0005
0006
0007
0008
0009
0010
----------------------

• 延迟计算
• 返回迭代器，可以迭代
• 从前到后走完一遍后，不能回头

g = ["{:04}".format(i) for i in range(1,11)]
for x in g:
    print(x)
print("-----------------------")

for x in g:
    print(x)
================================================
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
-----------------------
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010

• 立即计算
• 返回的不是迭代器，返回可迭代对象列表
• 从头到尾走完一遍后，可以再回头迭代

yield 函数

• 在 Python 中，使用了 yield 的函数被称为生成器（generator）。
• 跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
• 在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
• 调用一个生成器函数，返回的是一个迭代器对象。

以下实例使用 yield 实现斐波那契数列：

#!/usr/bin/python3

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()

执行以上程序，输出结果如下：

0 1 1 2 3 5 8 13 21 34 55

10.3.3、生成器和列表解析式的对比

计算方式

• 生成器表达式延迟计算，列表解析式立即计算

内存占用

• 单从返回值本身来说，生成器表达式省内存，列表解析式返回新的列表
• 生成器没有数据，内存占用极少，但是使用的时候，虽然一个个返回数据，但是合起来占用的内存也差不多
• 列表解析式构造新的列表需要占用内存

计算速度

• 单看计算时间看，生成器表达式耗时非常短，列表解析式耗时长
• 但是生成器本身并没有返回任何值，只返回了一个生成器对象
• 列表解析式构造并返回了一个新的列表

10.3.4、习题分析

it = (print("{}".format(i+1)) for i in range(2))
first = next(it)
second = next(it)
val = first + second

• val的值是什么？
  • print() 函数的返回值是 None，所以 first 和 second 都是 None，val 抛出异常
• val = first + second 语句之后能否再次 next(it)？
  • 生成器已经迭代完了，所以 next(it) 会抛出 StopIteration 异常

it = (x for x in range(10) if x % 2)
first = next(it)
second = next(it)
val = first + second

• val 的值是什么？

  • val 的值是 1 + 3 = 4

• val = first + second 语句之后能否再次 next(it)？

  • 当然可以，因为这个生成器跟上面那个不同，first 和 second 没用 print() 函数，所以有返回值

def inc():
    for i in range(5):
        yield i
print(1,"-->",type(inc))
print(2,"-->",type(inc()))
x = inc()
print(3,"-->",type(x))
print(4,"-->",next(x))
for m in x:
    print(5,"-->",m,"*")
for m in x:
    print(6,"-->",m,"**")
------------------------------
1 --> <class 'function'>
2 --> <class 'generator'>
3 --> <class 'generator'>
4 --> 0
5 --> 1 *
5 --> 2 *
5 --> 3 *
5 --> 4 *

===============================

y = (i for i in range(5))
print(type(y))
print(next(y))
print(next(y))
-------------------------------
<class 'generator'>
0
1

• 普通函数调用后立即执行完毕，但是生成器函数可以使用 next 函数多次执行
• 生成器函数等价于生成器表达式，只不过生成器函数可以更加复杂

def gen():
    print("line 1")
    yield 1
    print("line 2")
    yield 2
    print("line 3")
    return 3
print(1,"-->",next(gen()))
print(2,"-->",next(gen()))
print(3,"-->",next(gen()))
print()
g = gen()
print(4,"-->",next(g))
print(5,"-->",next(g))
print(6,"-->",next(g))
print(7,"-->",next(g,"End"))
-----------------------------------------
line 1
1 --> 1
line 1
2 --> 1
line 1
3 --> 1

line 1
4 --> 1
line 2
5 --> 2
line 3
---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-5-7a4c4921825b> in <module>
     13 print(4,"-->",next(g))
     14 print(5,"-->",next(g))
---> 15 print(6,"-->",next(g))
     16 print(7,"-->",next(g,"End"))

StopIteration: 3

• 其中 1-3 都是使用 next(gen())，实际上 3 次调用函数生成了 3 个生成器，而并不是 3 次拨动同一个生成器
• 其中 4-7 是 g=gen() 后，g 就是一个生成器，多次 next(g) 实际上是拨动同一个生成器，直到耗尽
• 6 抛出异常，是因为被 return 语句打断，无法继续获取下一个值，抛出 StopIteration 异常
• 如果注释 6 让 7 执行，则 7 不会抛出异常，因为 7 的 next 有默认值 "End"，生成器耗尽后就会输出默认值
• 在生成器函数中，使用多个 yield 语句，执行一次后会暂停执行，把 yield 表达式的值返回
• 再次执行会执行到下一个 yield 语句
• return 语句依然可以终止函数运行，但 return 语句的返回值不能被获取到
• return 会导致无法继续获取下一个值，抛出 StopIteration 异常
• 如果函数没有显示的 return 语句，如果生成器函数执行到结尾，一样会抛出 StopIteration 异常

生成器函数应用也是极为广泛

• 包含 yield 语句的生成器函数生成生成器对象的时候，生成器函数的函数体不会立即执行
• next(generator) 会从函数的当前位置向后执行到之后碰到的第一个 yield 语句，会弹出值，并暂停函数执行
• 再次调用 next 函数，和上一条一样的处理过程
• 没有多余的 yield 语句能被执行，继续调用 next 函数，会抛出 StopIteration 异常

生成器的一些简单应用

下面实现一个计数器

def counter():
    i = 0
    while True:
        i += 1
        yield i
def inc(c):
    return next(c)

c = counter()

print(inc(c),end=" ")
print(inc(c),end=" ")
print(inc(c),end=" ")
print(inc(c),end=" ")
--------------------------------
1 2 3 4

================================
def counter():
    i = 0
    while True:
        i += 1
        yield i
def inc():
    c = counter()
    return next(c)
print(inc(),end=" ")
print(inc(),end=" ")
print(inc(),end=" ")
print(inc(),end=" ")
--------------------------------
1 1 1 1

• 两个例子对比，前一个例子相当于多次拨动同一个生成器，后一个例子相当于每一次都是重新生成一个生成器

def inc():
    def couter():
        i = 0
        while True:
            i += 1
            yield i
    c = couter()
    return lambda:next(c)
foo = inc()
print(foo(),end=" ")
print(foo(),end=" ")
print(foo(),end=" ")
print(foo(),end=" ")
--------------------------------
1 2 3 4

================================
def inc():
    def counter():
        i = 0
        while True:
            i += 1
            yield i
    c = counter()

    def _inc():
        return next(c)
    return _inc
foo = inc()
print(foo(),end=" ")
print(foo(),end=" ")
print(foo(),end=" ")
print(foo(),end=" ")
--------------------------------
1 2 3 4

• 两个例子是等效的，借用 lambda 表达式更高级

下面实现处理递归问题

def fib():
    x = 0
    y = 1
    while True:
        yield y
        x,y=y,x+y
foo = fib()
for _ in range(5):
    print(next(foo),end=" ")
---------------------------------
1 1 2 3 5

=================================
pre = 0
cur = 1
print(pre,cur,end=" ")
def fib(n,pre=0,cur=1):
    pre,cur = cur,pre+cur
    print(cur,end=" ")
    if n == 2:
        return
    fib(n-1,pre,cur)
fib(5)
----------------------------------
0 1 1 2 3 5

• 两个例子等价

生成器与协程 coroutine

• 生成器的高级用法
• 比进程、线程轻量级
• 是在用户空间调度函数的一种实现
• Python3 asyncio 就是协程实现，已经加入到标准库
• Python3.5 使用 async、await 关键字直接原生支持协程
• 协程调度器实现思路
  • 有 2 个生成器 A、B
  • next(A) 后，A 执行到 yield 语句暂停，然后去执行 next(B)，B执行到 yield 语句也暂停，然后再次调用 next(A)，再调用 next(B)，周而复始，就实现了调度的效果
  • 可以引入调度的策略来实现切换的方式
• 协程是一种非抢占式调度

yield from 可以简化代码

def inc():
    for x in range(1000):
        yield x
foo = inc()
print(next(foo))
print(next(foo))
===============================
def inc():
    yield from range(1000)
foo = inc()
print(next(foo))
print(next(foo))

• 上面表达方式等效
• yield from 是 Python3.3 出现的新的语法
• yield from iterable 是 for item in iterable：yield item 形式的语法糖