Python学习笔记 - 流程控制

前言

程序设计中的流程控制语句有三种：即顺序、分支和循环语句。Python 程序通过控制语句来管理程序流，完成一定的任务。程序流是由若干个语句组成的，语句既可以是一条单一的语句，也可以是复合语句。Python 中的控制语句有以下几类：

• 顺序语句：从上往下一行行地执行的语句
• 分支语句：if
• 循环语句：while 和 for-in
• 跳转语句：break、continue 和 return

一、顺序结构

在任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下一行行地执行，中间没有任何判断和跳转。

如果 Python 程序的多行代码之间没有任何流程控制语句，则程序总是从上往下依次执行，排在前面的语句先执行，排在后面的语句后执行。这意味着如果没有流程控制，Python 程序的语句是一个顺序执行流，从上向下依次执行每条语句。

二、分支结构 — if 语句

分支语句提供了一种控制机制，使得程序具有了 “判断能力”，能够像人类的大脑一样分析问题。分支语句又称为条件语句，条件语句使部分程序根据某些表达式的值被有选择地执行。

Python 中的分支语句只有 if 语句。if 语句有 if 结构、if-else 结构 和 if-elif-else 结构三种。

2.1 if 结构

if 语句的语法结构如下：

if 条件表达式:
    语句块

如果条件表达式的计算结果为 True，就执行语句块，否则就执行 if 结构后面的语句。

if 结构示例代码如下：if_test.py

# coding=utf-8
# 代码文件: 控制语句/if_test.py

import sys                # 导入sys模块

score = int(sys.argv[1])  # 获得命令行参数的参数 --1

if score >= 85:
    print("score:%d 您真优秀！" %score)

if (score >= 60) and (score < 85):
    print("score:%d 您的成绩还可以，仍需继续努力！" %score)

if score < 60:
    print("score:%d 您需要加倍努力！" %score)

运行结果：

F:\python_work\Python基础\控制语句>python if_test.py 95
score:95 您真优秀！

F:\python_work\Python基础\控制语句>python if_test.py 75
score:75 您的成绩还可以，仍需继续努力！

F:\python_work\Python基础\控制语句>python if_test.py 56
score:56 您需要加倍努力！

        为了灵活输入分数（score）本例中使用了 sys.argv，sys.argv 能够返回命令行参数列表，见代码第1处。sys.argv[1] 返回参数列表的第二个元素，因为第一个元素 sys.argv[0] 是执行的 Python 文件名 if_test.py。由于参数列表中的元素为字符串，所以还需要使用 int() 函数将字符串转换为 int 类型。另外，为了使用 sys.argv 命令行参数列表，还需要在文件开始通过 import sys 语句导入 sys 模块。

如果程序需要获取 sys.argv[0] 元素，返回值为 if_test.py。

《注意》使用 sys.argv 获取命令行参数列表的程序代码，不能在 Python Shell 环境下运行获得参数列表。

2.2  if-else 结构

几乎所有的编程语言都支持这个结构，而且结构的格式基本相同。语句格式如下：

if 条件表达式 :
    语句块1
else:
    语句块2

        当程序执行到 if 语句时，先判断条件表达式，如果值为True，则执行语句块1，然后跳过 else 语句及其语句块2，继续执行后面的语句。如果条件表达式为 False，则忽略语句块1而直接执行语句块2，然后继续执行后面的语句。

if-else 结构示例代码如下：if_else.py

# coding=utf-8
# 代码文件: 控制语句/if_else.py
# if-else结构

import sys                # 导入sys模块

score = int(sys.argv[1])  # 获得命令行参数的参数 --1

if score >= 60:
    print("及格")
    if score >= 90:
        print("优秀")
else:
    print("不及格")

运行结果：

F:\python_work\Python基础\控制语句>python if_else.py 96
及格
优秀

F:\python_work\Python基础\控制语句>python if_else.py 56
不及格

F:\python_work\Python基础\控制语句>python if_else.py 85
及格

2.3  if-elif 结构

elif 结构如下：

if 条件1:
    语句块1
elif 条件2:
    语句块2
elif 条件3:
    语句块3
......
elif 条件n:
    语句块n
[else:
    语句块n+1]

可以看出，elif 结构实际上是 if-else 结构的多层嵌套，它明显的特点就是在多个分支中只执行一个语句块，而其他分支都不执行，所以这种结构可以用于有多种判断结果的分支中。其中，else 分支是可以省略的，Python并不要求 if-elif 结构后面必须要有 else 分支。

elif 结构示例代码如下：if_elif_else.py

# coding=utf-8
# 代码文件: 控制语句/if_elif_else.py
# if-elif-else结构

import sys                # 导入sys模块

score = int(sys.argv[1])  # 获得命令行参数的参数 --1

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
    grade = 'F'

print("Grade = " + grade)  # +为字符串连接符

运行结果：

F:\python_work\Python基础\控制语句>python if_elif_else.py 98
Grade = A

F:\python_work\Python基础\控制语句>python if_elif_else.py 86
Grade = B

F:\python_work\Python基础\控制语句>python if_elif_else.py 76
Grade = C

F:\python_work\Python基础\控制语句>python if_elif_else.py 64
Grade = D

F:\python_work\Python基础\控制语句>python if_elif_else.py 54
Grade = F

2.4  三目运算符替代品 —— if-else 条件表达式

Python编程语言没有类似 C/C++、Java 语言的三目运算符。为提供类似的功能，Python提供了条件表达式，条件表达式语法如下：

表达式1 if 条件 else 表达式2

其中，当条件计算为 True 时，返回表达式1，否则返回表达式2。

【补充】三目运算符

三目运算符的语法形式：条件 ? 表达式1 : 表达式2

当条件为真时，返回表达式1，否则返回表达式2。

使用条件表达式来实现三目运算符功能的示例代码如下：ternary_operator.py

# coding=utf-8
# 代码文件: 控制语句/ternary_operator.py
# 三目运算符替代品——条件表达式: 表达式1 if 条件 else 表达式2 <==> 条件 ? 表达式1 : 表达式2

import sys                # 导入sys模块

score = int(sys.argv[1])  # 获得命令行参数的参数 --1

result = "及格" if score >= 60 else "不及格"
print(result)

运行结果：

F:\python_work\Python基础\控制语句>python ternary_operator.py 98
及格

F:\python_work\Python基础\控制语句>python ternary_operator.py 56
不及格

从示例可见，条件表达式事实上就是 if-else 结构，而普通的 if-else 结构不是表达式，不会有返回值，而条件表达式不但进行条件判断，而且还会有返回值。

2.5  pass 语句

很多编程语言都提供了 “空语句” 支持，Python也不例外，Python 的 pass 语句就是空语句。

有时候程序需要占一个位置、放一条语句，但又不希望这条语句做任何事情，此时就可通过 pass 语句来实现。通过使用 pass 语句，可以让程序更完整。

如下程序示范了 pass 作为空语句的用法。

程序清单：pass_test.py

# coding=utf-8
# 代码文件: 控制语句/pass_test.py
# pass 语句的用法

s = input("请输入一个整数: ")
s = int(s)
if s > 5:
    print("大于5")
elif s < 5:
    # 空语句，相当于占位符
    pass
else:
    print("等于5")

运行结果：

F:\python_work\Python基础\控制语句>python pass_test.py
请输入一个整数: 3

F:\python_work\Python基础\控制语句>python pass_test.py
请输入一个整数: 12
大于5

F:\python_work\Python基础\控制语句>python pass_test.py
请输入一个整数: 5
等于5

从运行结果可以看出，对于 s 小于 5 的情形，程序暂时不想处理（或不知道如何处理），此时程序就需要空语句来先占一个位置，那么就可使用 pass 语句了。

三、断言语句(assert)

断言语句和 if 分支有点类似，它用于对一个 bool 表达式进行断言，如果该 bool 表达式为 True，则该程序可以继续往下执行；否则程序会引发 AssertionError 错误，并终止程序的运行。

assert 语句的语法格式如下：

assert(条件表达式)

例如如下程序。

程序清单：assert_test.py

# coding=utf-8
# 代码文件: 控制语句/assert_test.py
# assert断言语句的用法

s_age = input("请输入您的年龄: ")
age = int(s_age)
assert 20 <= age <= 80             # --1
print("您输入的年龄在20~80之间")

上面程序第1处的代码断言 age 必须位于 20 到 80 之间。运行上面的程序，如果输入的 age 处于执行范围之内，则可看到如下运行结果：

F:\python_work\Python基础\控制语句>python assert_test.py
请输入您的年龄: 32
您输入的年龄在20~80之间

如果输入的 age 不处于 20 到 80 之间，将可以看到如下运行结果：

F:\python_work\Python基础\控制语句>python assert_test.py
请输入您的年龄: 18
Traceback (most recent call last):
  File "F:\python_work\Python基础\控制语句\assert_test.py", line 7, in 
    assert 20 <= age <= 80
AssertionError

从上面的运行结果可以看出，断言也可以对逻辑表达式进行判断，因此实际上断言也相当于一种特殊的分支结构。

assert 断言的执行逻辑是：

if 条件为 False:
    程序引发 AssertionError 错误

四、循环结构

循环结构能够使程序代码重复执行。Python 支持 while 和 for 两种循环构造类型。

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体。当反复执行这个循环体时，需要在合适的时候把循环条件改为假，从而结束循环；否则循环将一直执行下去，形成死循环。循环语句可能包含如下4个部分：

• 初始化语句（init_statements）：一条或多条语句，用于完成一些初始化工作。初始化语句在循环开始之前执行。
• 循环条件（test_expression）：这是一个布尔表达式，这个表达式能决定是否执行循环体。
• 循环体（body_statements）：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行。
• 迭代语句（iteration_statements）：这个部分在一次执行循环体结束后，对循环条件求值之前执行，通常用于控制循环条件中的变量，使得循环在合适的时候结束。

上面4个部分只是一般分类，并不是每个循环中都非常清晰地分出这4个部分。

4.1  while 循环

while 循环是一种先对循环条件进行判断的循环结构。其语法格式如下：

[初始化语句]
while <循环条件>:
    <循环体>
    [迭代语句]
[else:
    语句块]

• while 循环在每次执行循环体之前，都要先对 test_expression 循环条件求值，如果循环条件为 True，则运行循环体部分。从上面的语法格式来看，迭代语句 iteration_statements 总是位于循环体的最后，因此只有当循环体能成功执行完成时，while 循环才会执行迭代语句 iteration_statements。从这个意义上看，while 循环也可被当成分支语句使用 — 如果 test_expression 循环条件一开始就为 False，则循环体部分将永远不会获得执行的机会。
• while 循环可以带有 else 语句，else 语句将在下文详细介绍。

下面看一个简单的 while 循环示例，代码如下：while_test.py

# coding=utf-8
# 代码文件: 控制语句/while_test.py
# while循环语句

i = 0

while (i * i) < 100_000:  # 找到平方数小于100_000的最大整数
    i += 1

i -= 1
print("i = {0}".format(i))
print("i * i = {0}".format(i * i))

运行结果：

F:\python_work\Python基础\控制语句>python while_test.py
i = 316
i * i = 99856

上述程序代码的目的是找到平方数小于 100_000（即十万）的最大整数。使用 while 循环需要注意，while 循环条件部分只能写一个表达式，而且是一个布尔型表达式。本例中，先给循环变量 i 初始化赋值为 0，然后必须在循环体内部通过语句更改循环变量 i 的值，否则将会发生死循环。

【提示】为了阅读方便，整数和浮点数均可添加多个0 或 下划线以提高可读性，如 000.01563 和 _360_000，两种格式均不会影响实际值。一般是每三位加一个下划线。

4.2  for 循环

for 循环是应用最广泛、功能最强的一种循环语句。Python 语言中没有 C/C++ 风格的 for 语句，它的 for 语句相等于 Java 中的增强 for 循环语句，只用于序列，序列包括范围、字符串、列表、元组和字典等可迭代对象包含的元素。Python 使用的 for 循环结构是 for-in 结构，其语法格式如下：

for <迭代变量> in 序列:
    语句块
[else:
    语句块]

对上面的 for-in 语法格式的几点说明：

• for-in 循环中的迭代变量的值受 for-in 循环控制，该变量将会在每次循环开始时自动被赋值，因此程序不应该在循环中对该变量赋值。
• for-in 循环可用于遍历任何可迭代对象。所谓可迭代对象，就是指该对象中包含一个 __iter__() 方法，且该方法的返回值对象具有 next() 方法。
• for-in 循环中也可以带有 else 语句，else 语句将在下文详细介绍。

例1、for-in 循环示例代码如下：for_test.py

# coding=utf-8
# 代码文件: 控制语句/for_test.py
# for循环语句

print("------ 范围 ------")
for num in range(1, 10):    # 使用范围 --1
    print("{0} * {0} = {1}".format(num, num * num))

print("------ 字符串 ------")
# for 语句
for item in "Hello":        # 使用字符串 --2
    print(item)

# 声明整数列表
numbers = [43, 32, 53, 54, 75, 7 ,10] # --3
print("------ 整数列表 ------")
# for 语句
for item in numbers:        # 使用列表 --4
    print("Count is: {0}".format(item))

运行结果：

------ 范围 ------
1 * 1 = 1
2 * 2 = 4
3 * 3 = 9
4 * 4 = 16
5 * 5 = 25
6 * 6 = 36
7 * 7 = 49
8 * 8 = 64
9 * 9 = 81
------ 字符串 ------
H
e
l
l
o
------ 整数列表 ------
Count is: 43
Count is: 32
Count is: 53
Count is: 54
Count is: 75
Count is: 7
Count is: 10

上述代码第1处 range(1, 10) 函数是创建范围（range）对象，它的取值是 1 ≤ range(1, 10) < 10，步长为1，总共 9 个整数。范围也是一种整数序列，关于范围也将会在下文中详细介绍。代码第2处是循环遍历字符串 "Hello"，字符串也是一个序列，所以可以用 for 循环变量。代码第3处是定义整数列表。代码第4处是遍历列表 numbers。

例2、使用 for-in 循环来计算指定整数的阶乘。

程序清单：for_factorial.py

# coding=utf-8
# 代码文件: 控制语句/for_factorial.py
# 使用for循环来计算指定整数的阶乘

s_number = input("请输入您想计算的阶乘整数值: ")
number = int(s_number)

result = 1
# 使用 for-in 循环遍历范围
for num in range(1, number + 1):
    result *= num;
print("{0}! = {1}".format(number, result))

运行结果：

F:\python_work\Python基础\控制语句>python for_factorial.py
请输入您想计算的阶乘整数值: 7
7! = 5040

上述程序将会根据用户输入的整数值进行循环。用户输入整数7，此时程序将会构建一个 range(1, 8) 对象（不包含8），因此 for-in 循环将会自动循环7次，在每次循环开始时，迭代变量 num 都会被依次自动赋值为 range 所包含的每个元素。

for-in 循环中的迭代变量完全接受 for-in 循环控制，因此该迭代变量 num 也被称为循环计数器。

需要说明的是，程序对 for-in 循环的循环计数器 num 赋值在语法上是允许的，但没有什么意义，而且非常容易导致错误。

例如，如下程序：

for i in range(1, 5):
    i = 20
    print("i: ", i)

上面程序中的 i = 20 语句对循环计数器 i 赋值，这样导致程序每次循环时都要先对变量 i 赋值，当程序刚进入循环体时，i 就被重新赋值为 20，因此在循环体中看到的 i 永远都是 20。运行上面程序，将看到如下输出结果：

i: 20
i: 20
i: 20
i: 20

4.3  嵌套循环

如果把一个循环放在另一个循环体内，那么就可以形成嵌套循环。

嵌套循环既可以是 for-in 循环嵌套 while 或 for-in 循环，也可以是 while 循环嵌套 for-in 或 while 循环。即各种类型的循环都可以作为外层循环，各种类型的循环也都可以作为内层循环。

嵌套循环的执行流程图如下图 4-1 所示：

图4-1  嵌套循环的执行流程图

从图 4-1 来看，嵌套循环就是把内层循环当成外层循环的循环体。只有内层循环的循环条件为假时，才会完全跳出内层循环，才可以结束外层循环的当次循环，开始下一次外层循环。

示例、嵌套循环的示例代码如下：nested_loop.py

# coding=utf-8
# 代码文件: 控制语句/nested_loop.py
# 嵌套循环的使用

# 外层循环
for i in range(1, 4):
    j = 0
    # 内层循环
    while j < 3:
        print("i = {0}, j = {1}".format(i, j))
        j += 1

运行结果：

F:\python_work\Python基础\控制语句>python nested_loop.py
i = 1, j = 0
i = 1, j = 1
i = 1, j = 2
i = 2, j = 0
i = 2, j = 1
i = 2, j = 2
i = 3, j = 0
i = 3, j = 1
i = 3, j = 2

从上面的运行结果可知，当进入到嵌套循环时，循环变量 i 开始为0，这时即进入了外层 for 循环。当进入外层循环体后，外层循环把 i 当成一个普通变量，其值为0。在外层循环的当次循环中，内层循环就是一个普通循环。

实际上，嵌套循环不仅可以是两层嵌套，还可以是三层循环、四层循环 ...... 不论循环如何嵌套，都可以把内层循环当成外层循环的循环体来对待，区别只是这个循环体中包含了需要反复执行的代码。

4.4  for 表达式

for 表达式用于利用其它区间、元组、列表等可迭代对象创建新的列表。for 表达式的语法格式如下：

[表达式 for 循环计数器 in 可迭代对象]

从上面的语法格式可以看出，for 表达式与普通的 for 循环的区别有两点。

• 在 for 关键字之前定义一个表达式，该表达式通常会包含循环计数器。
• for 表达式没有循环体，因此不需要冒号。

for 表达式当然也是有循环的，它同样会对可迭代对象进行循环——可迭代对象包含几个对象，该循环就对 for 之前的 “表达式” 执行几次（相当于 for 之前的表达式就是循环体），并将每次执行的值收集起来作为新的列表元素。

（1）for 表达式最终返回的是列表，因此 for 表达式也被称为列表推导式。

例如如下代码：for_expr.py

# coding=utf-8
# 代码文件: 控制语句/for_expr.py
# for表达式的使用

a_range = range(10)
# 对 a_range执行for表达式
a_list = [x * x for x in a_range]  # --1
# a_list 包含10个元素
print(a_list)

运行结果：

F:\python_work\Python基础\控制语句>python for_expr.py
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

        上面第1处的代码对 a_range 执行迭代，由于 a_range 相当于包含10个元素（0~9），因此程序生成的 a_list 同样包含了10个元素，每个元素都是 a_range 中每个元素的平方（由表达式 x * x 控制）。

（2）还可以在 for 表达式后面添加 if 条件，这样 for 表达式将只迭代那些符合条件的元素。例如如下代码：

# for表达式后面添加if语句
b_list = [x * x for x in a_range if x % 2 == 0]  # --2
# b_list 列表包含5个元素
print(b_list)

上面第2处的代码前面第1处的代码大致相同，只是为 for 表达式增加了 if 条件，这样程序只处理 range 区间的偶数，因此程序生成的 b_list 只包含了 5 个元素。

运行结果如下：

[0, 4, 16, 36, 64]

（3）如果将 for 表达式的方括号改为圆括号，for 表达式将不再生成类别，而是生成一个生成器（generator），该生成器同样可使用 for 循环迭代。

对于使用圆括号的 for 表达式，它最终返回的是生成器，因此这种 for 表达式也称为生成器推导式。示例代码如下：

# 使用for表达式创建生成器
c_generator = (x * x for x in a_range if x % 2 == 0) # --3
# 使用for循环迭代生成器
for i in c_generator:
	print(i, end='\t')
print()

上面第3处的代码只是将 for 表达式的方括号改为圆括号，因此这行代码语句将会创建一个 generator 生成器对象，接下来程序使用 for 循环遍历了该 generator 对象。

运行结果：

0       4       16      36      64

（4）在前面看到的 for 表达式都是一个循环，实际上 for 表达式可使用多个循环，就像嵌套循环一样。例如如下代码：

# for表达式可使用多个循环
d_list = [(x, y) for x in range(5) for y in range(4)] # --4
# d_list 列表包含20个元素
print(d_list)

上面代码第4处中的 x 是遍历 range(5) 的循环计数器，因此该 x 可迭代5次；y 是遍历 range(4) 的循环计数器，因此该 y 可迭代4次。因此，该 (x, y) 表达式一共会迭代 5 × 4 = 20 次。

运行结果：

[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)]

上面的 for 表达式相当于如下的嵌套 for 循环。

dd_list = []
for x in range(5):
    for y in range(4):
        dd_list.append((x, y))

（5）for 表达式还支持类似于三层嵌套的多个循环的 for 表达式形式，例如如下代码：

# 包含多个循环的for表达式
e_list = [[x, y, z] for x in range(5) for y in range(4) for z in range(6)] # --5
# e_list 列表包含120个元素
print(e_list)

运行结果：

[[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 0, 3], [0, 0, 4], [0, 0, 5], [0, 1, 0], [0, 1, 1], [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5], [0, 2, 0], [0, 2, 1], [0, 2, 2], [0, 2, 3], [0, 2, 4], [0, 2, 5], [0, 3, 0], [0, 3, 1], [0, 3, 2], [0, 3, 3], [0, 3, 4], [0, 3, 5], [1, 0, 0], [1, 0, 1], [1, 0, 2], [1, 0, 3], [1, 0, 4], [1, 0, 5], [1, 1, 0], [1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 1, 4], [1, 1, 5], [1, 2, 0], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 0], [1, 3, 1], [1, 3, 2], [1, 3, 3], [1, 3, 4], [1, 3, 5], [2, 0, 0], [2, 0, 1], [2, 0, 2], [2, 0, 3], [2, 0, 4], [2, 0, 5], [2, 1, 0], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 1, 4], [2, 1, 5], [2, 2, 0], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 2, 4], [2, 2, 5], [2, 3, 0], [2, 3, 1], [2, 3, 2], [2, 3, 3], [2, 3, 4], [2, 3, 5], [3, 0, 0], [3, 0, 1], [3, 0, 2], [3, 0, 3], [3, 0, 4], [3, 0, 5], [3, 1, 0], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 1, 4], [3, 1, 5], [3, 2, 0], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 2, 4], [3, 2, 5], [3, 3, 0], [3, 3, 1], [3, 3, 2], [3, 3, 3], [3, 3, 4], [3, 3, 5], [4, 0, 0], [4, 0, 1], [4, 0, 2], [4, 0, 3], [4, 0, 4], [4, 0, 5], [4, 1, 0], [4, 1, 1], [4, 1, 2], [4, 1, 3], [4, 1, 4], [4, 1, 5], [4, 2, 0], [4, 2, 1], [4, 2, 2], [4, 2, 3], [4, 2, 4], [4, 2, 5], [4, 3, 0], [4, 3, 1], [4, 3, 2], [4, 3, 3], [4, 3, 4], [4, 3, 5]]

（6）对于包含多个循环的 for 表达式，同样可指定 if 条件。假如我们有一个需求：程序要将两个列表中的数值按 “能否整除” 的关系配对在一起。比如，src_a 列表中包含元素 30，src_b 列表中包含元素 5，其中 30 可以整除 5，那么就将 30 和 5 配对在一起。对于上面的需求使用 for 表达式来实现非常简单，例如如下代码：

src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121]
src_b = [3, 5, 7, 11]
# 只要a能整除b，就将它们配对在一起
result = [(a, b) for a in src_a for b in src_b if a % b == 0] # --7
print(result)

运行结果：

[(30, 3), (30, 5), (12, 3), (66, 3), (66, 11), (39, 3), (78, 3), (36, 3), (57, 3), (121, 11)]

五、控制循环结构 — 跳转语句

        跳转语句能够改变程序的执行顺序，可以实现程序的跳转。Python 提供了 3 种跳转语句：break、continue 和 return。需要了解的是，Python 语言并没有提供 goto 语句来控制程序的跳转。

5.1  break 语句

        break 语句可用于前面介绍的 while 和 for 循环结构，它的作用是强行退出循环体，不再执行循环体中剩余的语句。不管是哪种循环，一旦在循环体中遇到 break，系统就将完全结束该循环，开始执行循环之后的代码。

示例：使用 break 语句结束 for 循环。代码如下：for_break.py

# coding=utf-8
# 代码文件: 控制语句/for_break.py
# for循环中的break语句

for item in range(10):
    if item == 3:
        # 跳出for循环
        break
    print("Count is: {0}".format(item))

运行结果：

F:\python_work\Python基础\控制语句>python for_break.py
Count is: 0
Count is: 1
Count is: 2

在上述代码中，当迭代变量 item 等于 3 的时候，if 条件表达式为 True，程序就会执行 break 语句，而 break 语句终止 for 循环。range(10) 范围函数省略了开始参数，默认是从 0 开始的。

5.2  continue 语句

continue 语句用来结束本次循环，跳过循环体中尚未执行的语句，接着进行终止条件的判断，以决定是否继续循环。

示例：continue语句使用。代码清单：for_continue.py

# coding=utf-8
# 代码文件: 控制语句/for_continue.py
# for循环中的continue语句

for item in range(10):
    if item == 3:
        # 跳出本次for循环
        continue
    print("Count is: {0}".format(item))

运行结果：

F:\python_work\Python基础\控制语句>python for_continue.py
Count is: 0
Count is: 1
Count is: 2
Count is: 4
Count is: 5
Count is: 6
Count is: 7
Count is: 8
Count is: 9

在上述代码中，当条件 item == 3 条件成立的时候执行 continue 语句，continue 语句会终止本次循环，循环体中 continue 之后的语句将不再执行，所以输出结果中没有打印 Count is: 3 这条输出语句。

5.3  break 语句

        return 语句用于从包围它的最直接方法、函数或匿名函数返回。当函数或方法执行到一条 return 语句时（在 return 关键字后还可以跟变量、常量和表达式），这个函数或方法将被结束执行。

        Python 程序中的大部分循环都被放在函数或方法中执行，一旦在循环体内执行到一条 return 语句时，return 语句就会结束该函数或方法，循环自然也随之结束。

示例：return 语句在 for 循环体中的使用。程序清单：for_return.py

# coding=utf-8
# 代码文件: 控制语句/for_return.py
# return 语句在 for 循环体中的使用

def test():
    # 外层循环
    for i in range(5):
        for j in range(5):
            print("value_i:%d, value_j:%d" %(i, j))
            if j == 2:
                return
            print("return 后的输出语句")

test()

运行结果：

F:\python_work\Python基础\控制语句>python for_return.py
value_i:0, value_j:0
return 后的输出语句
value_i:0, value_j:1
return 后的输出语句
value_i:0, value_j:2

        从运行结果中可以看出，循环执行到 i 等于 0，j 等于 2 时，会执行到 return 语句，这时程序就会完全结束（当 test() 函数结束时，也就是Python 程序结束时）。从这个运行结果来看，虽然 return 语句并不是专门用来控制循环结构的关键字，但通过 return 语句确实可以结束一个循环。与 break 和  continue 不同的是，return 直接结束整个函数或方法，而不管 return 处于多少层循环之内。

5.4  while 和 for 中的 else 语句

在前面上文介绍 while 和 for 循环时，提到过它们都可以跟 else 语句，它与 if 语句中的 else 不同。这里的 else 是在循环体正常结束时才会运行的代码，当循环被中断时不执行，break、return 和 异常抛出都会中断循环。循环中的 else 语句流程图如下图 5-2 所示。

图5-2  循环中的else语句

示例：循环中的 else 语句的使用。代码清单：while_for_else.py

# coding=utf-8
# 代码文件: 控制语句/while_for_else.py
# while 和 for 循环中的 else 语句

i = 1

while (i * i) < 10:
    # if i == 3:
    #   break
    print("{0} * {0} = {1}".format(i, i * i))
    i += 1
else:
    print("While Over!")  # while循环结束时会执行该语句

print("-------------")

for item in range(10):
    if item == 3:
        break
    print("Count is: {0}".format(item))
else:
    print("For Over!")     # for循环被break中断执行，不会执行该语句

运行结果：

1 * 1 = 1
2 * 2 = 4
3 * 3 = 9
While Over!
-------------
Count is: 0
Count is: 1
Count is: 2

        上述代码中，while 循环体中的 break 语句被注释掉了，因此当循环结束时会执行 else 语句，所以最后输出了 "While Over!"。而在 for 循环中当条件满足时，会执行 break 语句，循环结束时则不会执行 else 语句，所以最后没有输出 "For Over!"。

        循环中的 else 代码块是 Python 语句中的一个很特殊的语法（其他编程语言通常并不支持），else 代码块的主要作用是便于生成更优雅的 Python 代码。

5.5  使用范围 — range()函数

在前面的代码中，多次使用了范围，范围在 Python 中类型是 range，表示一个整数序列，创建范围对象需要使用 range() 函数，range() 函数语法格式如下：

range([start,] stop[, step])

其中的三个参数都是整数类型，start 是开始值，可以省略，表示从 0 开始；stop 是结束值；step 是步长，步长可以是负数，即创建递减序列。

注意：整数序列的取值范围是 [start, stop)，即半闭半开的区间，一般而言，(stop - start) 就是序列的长度。

range() 函数一般用于 for 循环中。

示例：range() 函数的使用。代码清单：for_range.py

# coding=utf-8
# 代码文件: 控制语句/for_range.py
# 在for循环中使用范围函数range()

for item in range(1, 10, 2):   # 整数序列取值从1开始，步长为2，取值范围要小于10 --1
    print("Count is: {0}".format(item))

print("----------------")

for item in range(0, -10, -3): # 整数序列取值从0开始，步长为-3，取值范围要大于-10 --2
    print("Count is: {0}".format(item))

运行结果：

F:\python_work\Python基础\控制语句>python for_range.py
Count is: 1
Count is: 3
Count is: 5
Count is: 7
Count is: 9
----------------
Count is: 0
Count is: -3
Count is: -6
Count is: -9

        上述代码第1处是创建一个范围，步长为 2，有 5 个元素，包含的元素见输出结果。代码第2处是创建一个递减范围，步长为 -3，有 4 个元素，包含的元素见输出结果。

六、编程练习

6.1  使用循环输出九九乘法表。

# coding=utf-8
# 代码文件: 编程练习/haskell.py
# 使用循环输出九九乘法表

for i in range(1, 10):
    for j in range(1, i+1):
        print("%d * %d = %2d" %(j, i, i * j), end = " ")
    print()

6.2  用户输入自己的成绩，程序会自动判断该成绩的类型：成绩 90分用 A 表示；80~89分用 B 表示；70~79分用 C 表示；其他的用 D 表示。

# coding=utf-8
# 代码文件: 编程练习/score_level.py
# 用户输入自己的成绩，程序会自动判断该成绩的类型：成绩 \geqslant 90分用 A 表示；80~89分用 B 表示；
# 70~79分用 C 表示；其他的用 D 表示。

import sys

while(True):
    s = input("请输入成绩: ")
    if s == 'exit':
        print('exit succ')
        sys.exit()
    score = float(s)
    if score >= 90:
        print('A')
    elif 90 > score >= 80:
        print('B')
    elif 80 > score >= 70:
        print('C')
    else:
        print('D')

6.3  判断 101~200 之间有多少个素数，并输出所有的素数。

# coding=utf-8
# 代码文件: 编程练习/prime_number.py
# 判断 101~200 之间有多少个素数，并输出所有的素数。

import math

start = 101
end = 200
for i in range(start, end+1):
    is_prime = True
    for j in range(2, int(math.sqrt(i)) + 1):
        if i % j == 0:
            is_prime = False
            break
    if is_prime:
        print(i, end = " ")
print()

6.4  打印出所有的 “水仙花数”。所谓“水仙花数”，是指一个三位数，其各位数字的立方和等于该数本身。例如，153 是一个水仙花数，因为 。

# coding=utf-8
# 代码文件: 编程练习/shuixianhua_number.py
# 打印出所有的 “水仙花数”。所谓“水仙花数”，是指一个三位数，其各位数字的立方和等于该数本身。
# 例如，153 是一个水仙花数，因为 153 = 1^{3} + 5^{3} + 3^{3}。

for i in range(100, 1000):
    hundred_digit = i // 100
    ten_digit = (i - hundred_digit * 100) // 10
    singel_digit = i % 10
    if i == (hundred_digit ** 3) + (ten_digit ** 3) + (singel_digit ** 3):
        print(i, end = " ")
print()

6.5  输入一行字符，分别统计出其中英文字母、空格、数字和其他字符的个数。

# coding=utf-8
# 代码文件: 编程练习/char_count.py
# 输入一行字符，分别统计出其中英文字母、空格、数字和其他字符的个数。

string = input("请输入一行字符: ")
char_num, digit_num, blank_num, other_num = 0, 0, 0, 0
for c in string:
    if c.isalpha(): char_num += 1
    elif c == ' ': blank_num += 1
    elif c.isdigit(): digit_num += 1
    else: other_num += 1
print("字符串长度: ", len(string))
print("英文字母个数: ", char_num)
print("空格个数: ", blank_num)
print("数字个数: ", digit_num)
print("其他字符个数: ", other_num)

参考

《Python从小白到大牛(第1版-2018).pdf》第8章 - 控制语句

《疯狂Python讲义(2018.12).pdf》第4章 - 流程控制