CH06_流程控制

本章目标

  • 掌握if选择结构的运用
  • 掌握assert断言
  • 掌握while循环结构的运用
  • 掌握for循环结构的运用
  • 掌握循环中break和continue的运用

if选择结构

概述

在 Python 中，可以使用 if else 语句对条件进行判断，然后根据不同的结果执行不同的代码，这称为选择结构或者分支结构。

Python 中的 if else 语句可以细分为三种形式，分别是 if 语句、if else 语句和 if elif else 语句，它们的语法和执行流程如表1所示。

​ 以上三种形式中，第二种和第三种形式是相通的，如果第三种形式中的 elif 块不出现，就变成了第二种形式。另外，elif 和 else 都不能单独使用，必须和 if 一起出现，并且要正确配对。

对语法格式的说明：

“表达式”可以是一个单一的值或者变量，也可以是由运算符组成的复杂语句，形式不限，只要它能得到一个值就行。不管“表达式”的结果是什么类型，if else 都能判断它是否成立（真或者假）。
• “代码块”由具由相同缩进量的若干条语句组成。
• if、elif、else 语句的最后都有冒号:，不要忘记。

一旦某个表达式成立，Python 就会执行它后面对应的代码块；如果所有表达式都不成立，那就执行 else 后面的代码块；如果没有 else 部分，那就什么也不执行。

执行过程最简单的就是第一种形式——只有一个 if 部分。如果表达式成立（真），就执行后面的代码块；如果表达式不成立（假），就什么也不执行。

对于第二种形式，如果表达式成立，就执行 if 后面紧跟的代码块1；如果表达式不成立，就执行 else 后面紧跟的代码块2。

对于第三种形式，Python 会从上到下逐个判断表达式是否成立，一旦遇到某个成立的表达式，就执行后面紧跟的语句块；此时，剩下的代码就不再执行了，不管后面的表达式是否成立。如果所有的表达式都不成立，就执行 else 后面的代码块。

总起来说，不管有多少个分支，都只能执行一个分支，或者一个也不执行，不能同时执行多个分支。

案例

【实例1】使用第一种选择结构判断用户是否符合条件： 

1
2
3
4
5
6
7
8
9
age = int( input("请输入你的年龄：") )

if age < 18 :
    print("你还未成年，建议在家人陪同下使用该软件！")
    print("如果你已经得到了家长的同意，请忽略以上提示。")

#该语句不属于if的代码块
print("软件正在使用中...")

运行结果1：

1
2
3
4
请输入你的年龄：16↙
你还未成年，建议在家人陪同下使用该软件！
如果你已经得到了家长的同意，请忽略以上提示。
软件正在使用中...

运行结果2：

1
2
请输入你的年龄：24↙
软件正在使用中...

从运行结果可以看出，如果输入的年龄小于 18，就执行 if 后面的语句块；如果输入的年龄大于等于 18，就不执行 if 后面的语句块。这里的语句块就是缩进四个空格的两个 print() 语句。

【实例2】改进上面的代码，年龄不符合时退出程序： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import sys

age = int( input("请输入你的年龄：") )

if age < 18 :
    print("警告：你还未成年，不能使用该软件！")
    print("未成年人应该好好学习，读个好大学，报效祖国。")
    sys.exit()
else:
    print("你已经成年，可以使用该软件。")
    print("时间宝贵，请不要在该软件上浪费太多时间。")

print("软件正在使用中...")

运行结果1：

1
2
3
请输入你的年龄：16↙
警告：你还未成年，不能使用该软件！
未成年人应该好好学习，读个好大学，报效祖国。

运行结果2：

1
2
3
4
请输入你的年龄：20↙
你已经成年，可以使用该软件。
时间宝贵，请不要在该软件上浪费太多时间。
软件正在使用中...

sys 模块的 exit() 函数用于退出程序。

【实例3】判断一个人的身材是否合理： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
height = float(input("输入身高（米）："))
weight = float(input("输入体重（千克）："))
bmi = weight / (height * height)  #计算BMI指数

if bmi<18.5:
    print("BMI指数为："+str(bmi))
    print("体重过轻")
elif bmi>=18.5 and bmi<24.9:
    print("BMI指数为："+str(bmi))
    print("正常范围，注意保持")
elif bmi>=24.9 and bmi<29.9:
    print("BMI指数为："+str(bmi))
    print("体重过重")
else:
    print("BMI指数为："+str(bmi))
    print("肥胖")

运行结果：

1
2
3
4
输入身高（米）：1.7↙
输入体重（千克）：70↙
BMI指数为：24.221453287197235
正常范围，注意保持

【实例】判断是否为酒后驾车

如果规定，车辆驾驶员的血液酒精含量小于 20mg/100ml 不构成酒驾；酒精含量大于或等于 20mg/100ml 为酒驾；酒精含量大于或等于 80mg/100ml 为醉驾。先编写 Python 程序判断是否为酒后驾车。

1
2
3
4
5
6
7
8
9
proof = int(input("输入驾驶员每 100ml 血液酒精的含量："))
if proof < 20:
    print("驾驶员不构成酒驾")
else:
    if proof < 80:
        print("驾驶员已构成酒驾")
    else:
        print("驾驶员已构成醉驾")

运行结果：

1
2
输入驾驶员每 100ml 血液酒精的含量：10
驾驶员不构成酒驾

如何判断表达式是否成立

上面说过，if 和 elif 后面的“表达式”的形式是很自由的，只要表达式有一个结果，不管这个结果是什么类型，Python 都能判断它是“真”还是“假”。

布尔类型（bool）只有两个值，分别是 True 和 False，Python 会把 True 当做“真”，把 False 当做“假”。

对于数字，Python 会把 0 和 0.0 当做“假”，把其它值当做“真”。

对于其它类型，当对象为空或者为 None 时，Python 会把它们当做“假”，其它情况当做真。比如，下面的表达式都是不成立的： 

1
2
3
4
5
""  #空字符串
[ ]  #空列表
( )  #空元组
{ }  #空字典
None  #空值

【实例】if elif 判断各种类型的表达式： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
b = False
if b:
    print('b是True')
else:
    print('b是False')

n = 0
if n:
    print('n不是零值')
else:
    print('n是零值')

s = ""
if s:
    print('s不是空字符串')
else:
    print('s是空字符串')

l = []
if l:
    print('l不是空列表')
else:
    print('l是空列表')

d = {}
if d:
    print('d不是空字典')
else:
    print('d是空字典')

def func():
    print("函数被调用")

if func():
    print('func()返回值不是空')
else:
    print('func()返回值为空')

运行结果：

1
2
3
4
5
6
7
b是False
n是零值
s是空字符串
l是空列表
d是空字典
函数被调用
func()返回值为空

说明：对于没有 return 语句的函数，返回值为空，也即 None。

pass语句及其作用

在实际开发中，有时候我们会先搭建起程序的整体逻辑结构，但是暂时不去实现某些细节，而是在这些地方加一些注释，方面以后再添加代码，请看下面的例子： 

1
2
3
4
5
6
7
8
9
10
11
12
13
age = int( input("请输入你的年龄：") )

if age < 12 :
    print("婴幼儿")
elif age >= 12 and age < 18:
    print("青少年")
elif age >= 18 and age < 30:
    print("成年人")
elif age >= 30 and age < 50:
    #TODO: 成年人
else:
    print("老年人")

当年龄大于等于 30 并且小于 50 时，我们没有使用 print() 语句，而是使用了一个注释，希望以后再处理成年人的情况。当 Python 执行到该 elif 分支时，会跳过注释，什么都不执行。

但是 Python 提供了一种更加专业的做法，就是空语句 pass。pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做。

就像上面的情况，有时候程序需要占一个位置，或者放一条语句，但又不希望这条语句做任何事情，此时就可以通过 pass 语句来实现。使用 pass 语句比使用注释更加优雅。

使用 pass 语句更改上面的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
age = int( input("请输入你的年龄：") )

if age < 12 :
    print("婴幼儿")
elif age >= 12 and age < 18:
    print("青少年")
elif age >= 18 and age < 30:
    print("成年人")
elif age >= 30 and age < 50:
    pass
else:
    print("老年人")

运行结果：

1
请输入你的年龄：40↙

代码缩进

缩进多少合适

Python 要求代码块必须缩进，但是却没有要求缩进量，你可以缩进 n 个空格，也可以缩进 n 个 Tab 键的位置。

但是从编程习惯的角度看，我建议缩进 1 个 Tab 键的位置，或者缩进 4 个空格；它们两者其实是等价的，很多编辑器都可以将 Tab 键设置为 4 个空格，比如，IDLE 中默认 Tab 键就是 4 个空格。

同一代码块缩进量要相同

Python 虽然不限制代码块的缩进量，你可以随意缩进 n 个空格，但是，同一个代码块内的所有语句都必须拥有相同的缩进量，不能一会缩进 2 个空格，一会缩进 4 个空格。下面的代码是一个反面教材： 

1
2
3
4
5
6
age = int( input("请输入你的年龄：") )

if age < 18 :
    print("你还未成年，建议在家人陪同下使用该软件！")
      print("未成年人如果得到了家长的同意，请忽略以上提示。")  #缩进量不对

运行这段代码，Python 解释器会报出语法错误： 

1
SyntaxError: unexpected indent

这段代码中，第一个 print() 语句缩进了 4 个空格，第二个 print() 语句缩进了 6 个空格，缩进量不同导致它们不是同一个代码块。Python 会认为第一个 print() 语句是 if 的执行体，而第二个 print() 是一个意外的存在，不知道该把它当做谁的代码块，所以解析失败，报错。

不要随便缩进

另外需要注意的是，不需要使用代码块的地方千万不要缩进，一旦缩进就会产生一个代码块。下面的代码是一个反面教材： 

1
2
info = "Python教程的网址是：http://c.biancheng.net/python/"
    print(info)

这两条简单的语句没有包含分支、循环、函数、类等结构，不应该使用缩进。

assert断言

概述

Python assert 语句，又称断言语句，可以看做是功能缩小版的 if 语句，它用于判断某个表达式的值，如果值为真，则程序可以继续往下执行；反之，Python 解释器会报 AssertionError 错误。

assert 语句的语法结构为： 

1
assert 表达式

assert 语句的执行流程可以用 if 判断语句表示，如下所示

1
2
3
4
if 表达式==True:
     程序继续执行
else:
     程序报 AssertionError 错误

有读者可能会问，明明 assert 会令程序崩溃，为什么还要使用它呢？这是因为，与其让程序在晚些时候崩溃，不如在错误条件出现时，就直接让程序崩溃，这有利于我们对程序排错，提高程序的健壮性。

因此，assert 语句通常用于检查用户的输入是否符合规定，还经常用作程序初期测试和调试过程中的辅助工具。

下面的程序演示了 assert 语句的用法：

1
2
3
4
5
mathmark = int(input())
#断言数学考试分数是否位于正常范围内
assert 0 <= mathmark <= 100
#只有当 mathmark 位于 [0,100]范围内，程序才会继续执行
print("数学考试分数为：",mathmark)

运行该程序，测试数据如下： 

1
2
90
数学考试分数为： 90

再次执行该程序，测试数据为：

1
2
3
4
5
159
 Traceback (most recent call last):
   File "C:\Users\mengma\Desktop\file.py", line 3, in <module>
     assert 0 <= mathmark <= 100
 AssertionError

可以看到，当 assert 语句后的表达式值为真时，程序继续执行；反之，程序停止执行，并报 AssertionError 错误。

while循环

概述

Python 中，while 循环和 if 条件分支语句类似，即在条件（表达式）为真的情况下，会执行相应的代码块。不同之处在于，只要条件为真，while 就会一直重复执行那段代码块。

while 语句的语法格式如下：

1
2
while 条件表达式：
    代码块

这里的代码块，指的是缩进格式相同的多行代码，不过在循环结构中，它又称为循环体。

while 语句执行的具体流程为：首先判断条件表达式的值，其值为真（True）时，则执行代码块中的语句，当执行完毕后，再回过头来重新判断条件表达式的值是否为真，若仍为真，则继续重新执行代码块…如此循环，直到条件表达式的值为假（False），才终止循环。

while 循环结构的执行流程如图 1 所示。

案例

1
2
3
4
5
6
7
8
9
# 循环的初始化条件
num = 1
# 当 num 小于100时，会一直执行循环体
while num < 100 :
    print("num=", num)
    # 迭代语句
    num += 1
print("循环结束!")

运行程序会发现，程序只输出了 1~99，却没有输出 100。这是因为，当循环至 num 的值为 100 时，此时条件表达式为假（100<100），当然就不会再去执行代码块中的语句，因此不会输出 100。

注意，在使用 while 循环时，一定要保证循环条件有变成假的时候，否则这个循环将成为一个死循环。所谓死循环，指的是无法结束循环的循环结构，例如将上面 while 循环中的num += 1代码注释掉，再运行程序你会发现，Python 解释器一直在输出”num= 1”，永远不会结束（因为 num<100 一直为 True），除非我们强制关闭解释器。

再次强调，只要位于 while 循环体中的代码，其必须使用相同的缩进格式（通常缩进 4 个空格），否则 Python 解释器会报 SyntaxError 错误（语法错误）。例如，将上面程序中num+=1语句前移一个空格，再次执行该程序，此时 Python 解释器就会报 SyntaxError 错误。

除此之外，while 循环还常用来遍历列表、元组和字符串，因为它们都支持通过下标索引获取指定位置的元素。例如，下面程序演示了如何使用 while 循环遍历一个字符串变量： 

1
2
3
4
5
my_char="https://os-guangchuang.gitee.io/note/"
i = 0;
while i<len(my_char):
    print(my_char[i],end="")
    i = i + 1

程序执行结果为： 

1
https://os-guangchuang.gitee.io/note/

for循环

概述

Python 中的循环语句有 2 种，分别是 while 循环和 for 循环，前面章节已经对 while 做了详细的讲解，本节给大家介绍 for 循环，它常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素。

for 循环的语法格式如下：

1
2
for 迭代变量 in 字符串|列表|元组|字典|集合：
    代码块

格式中，迭代变量用于存放从序列类型变量中读取出来的元素，所以一般不会在循环中对迭代变量手动赋值；代码块指的是具有相同缩进格式的多行代码（和 while 一样），由于和循环结构联用，因此代码块又称为循环体。

for 循环语句的执行流程如图 1 所示。

下面的程序演示了 for 循环的具体用法： 

1
2
3
4
5
add = "https://os-guangchuang.gitee.io/note/"
#for循环，遍历 add 字符串
for ch in add:
    print(ch,end="")

运行结果：

1
https://os-guangchuang.gitee.io/note/

可以看到，使用 for 循环遍历  add 字符串的过程中，迭代变量 ch 会先后被赋值为 add 字符串中的每个字符，并代入循环体中使用。只不过例子中的循环体比较简单，只有一行输出语句。

案例

案例1：进行数值循环

​ 在使用 for 循环时，最基本的应用就是进行数值循环。比如说，想要实现从 1 到 100 的累加，可以执行如下代码： 

1
2
3
4
5
6
7
print("计算 1+2+...+100 的结果为：")
#保存累加结果的变量
result = 0
#逐个获取从 1 到 100 这些值，并做累加操作
for i in range(101):
    result += i
print(result)

运行结果：

1
2
计算 1+2+...+100 的结果为：
5050

上面代码中，使用了 range() 函数，此函数是 Python 内置函数，用于生成一系列连续整数，多用于 for 循环中。

案例2：遍历列表和元组

​ 当用 for 循环遍历 list 列表或者 tuple 元组时，其迭代变量会先后被赋值为列表或元组中的每个元素并执行一次循环体。

1
2
3
4
my_list = [1,2,3,4,5]
for ele in my_list:
    print('ele =', ele)

运行结果：

1
2
3
4
5
ele = 1
ele = 2
ele = 3
ele = 4
ele = 5

案例3：遍历字典

​ 在使用 for 循环遍历字典时，经常会用到和字典相关的 3 个方法，即 items()、keys() 以及 values()，它们各自的用法已经在前面章节中讲过，这里不再赘述。当然，如果使用 for 循环直接遍历字典，则迭代变量会被先后赋值为每个键值对中的键。

1
2
3
4
5
6
my_dic = {'百度':"http://www.baidu.com",\
          '淘宝':"http://www.taobao.com",\
          '京东':"http://www.jd.com"}
for ele in my_dic:
    print('ele =', ele)

运行结果：

1
2
3
ele = 百度
ele = 淘宝
ele = 京东

因此，直接遍历字典，和遍历字典 keys() 方法的返回值是相同的。

除此之外，我们还可以遍历字典 values()、items() 方法的返回值。例如： 

1
2
3
4
5
my_dic = {'百度':"http://www.baidu.com",\
          '淘宝':"http://www.taobao.com",\
          '京东':"http://www.jd.com"}
for ele in my_dic.items():
    print('ele =', ele)

运行结果：

1
2
3
ele = ('百度', 'http://www.baidu.com')
ele = ('淘宝', 'http://www.taobao.com')
ele = ('京东', 'http://www.jd.com')

循环嵌套

概述

Python 不仅支持 if 语句相互嵌套，while 和 for 循环结构也支持嵌套。所谓嵌套（Nest），就是一条语句里面还有另一条语句，例如 for 里面还有 for，while 里面还有 while，甚至 while 中有 for 或者 for 中有 while 也都是允许的。

当 2 个（甚至多个）循环结构相互嵌套时，位于外层的循环结构常简称为外层循环或外循环，位于内层的循环结构常简称为内层循环或内循环。

循环嵌套结构的代码，Python 解释器执行的流程为：

  1. 当外层循环条件为 True 时，则执行外层循环结构中的循环体；
  2. 外层循环体中包含了普通程序和内循环，当内层循环的循环条件为 True 时会执行此循环中的循环体，直到内层循环条件为 False，跳出内循环；
  3. 如果此时外层循环的条件仍为 True，则返回第 2 步，继续执行外层循环体，直到外层循环的循环条件为 False；
  4. 当内层循环的循环条件为 False，且外层循环的循环条件也为 False，则整个嵌套循环才算执行完毕。

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

案例

案例1：

1
2
3
4
5
6
i = 0
while i<10:
    for j in range(10):
        print("i=",i," j=",j)       
    i=i+1

可以看到，此程序中运用了嵌套循环结构，其中外循环使用的是 while 语句，而内循环使用的是 for 语句。程序执行的流程是：

  • 一开始 i=0，循环条件 i<10 成立，进入 while 外循环执行其外层循环体；
  • 从 j=0 开始，由于 j <10 成立，因此进入 for 内循环执行内层循环体，直到 j=10 不满足循环条件，跳出 for 循环体，继续执行 while 外循环的循环体；
  • 执行 i=i+1 语句，如果 i<10 依旧成立，则从第 2 步继续执行。直到 i<10 不成立，则此循环嵌套结构才执行完毕。

根据上面的分析，此程序中外层循环将循环 10 次（从 i=0 到 i=9），而每次执行外层循环时，内层循环都从 j=0 循环执行到 j=9。因此，该嵌套循环结构将执行 10*10 = 100 次。

嵌套循环执行的总次数 = 外循环执行次数 * 内循环执行次数

事实上，if 语句和循环（while、for）结构之间，也可以相互嵌套，举个例子： 

1
2
3
4
5
i = 0
if i<10:
    for j in range(5):
        print("i=",i," j=",j)

运行结果：

1
2
3
4
5
i= 0  j= 0
i= 0  j= 1
i= 0  j= 2
i= 0  j= 3
i= 0  j= 4

需要指明的是，上面程序演示的仅是 2 层嵌套结构，其实 if、while、for 之间完全支持多层（ ≥3 ）嵌套。例如：

1
2
3
4
5
if ...:
     while ...:
         for ...:
             if ...:
                 ...

也就是说，只要场景需要，判断结构和循环结构之间完全可以相互嵌套，甚至可以多层嵌套。

break和continue

break

我们知道，在执行 while 循环或者 for 循环时，只要循环条件满足，程序将会一直执行循环体，不停地转圈。但在某些场景，我们可能希望在循环结束前就强制结束循环，Python 提供了 2 种强制离开当前循环体的办法：

  1. 使用 continue 语句，可以跳过执行本次循环体中剩余的代码，转而执行下一次的循环。
  2. 只用 break 语句，可以完全终止当前循环。

本节先讲解 break 的用法，continue 语句放到下节做详细介绍。

break 语句可以立即终止当前循环的执行，跳出当前所在的循环结构。无论是 while 循环还是 for 循环，只要执行 break 语句，就会直接结束当前正在执行的循环体。

这就好比在操场上跑步，原计划跑 10 圈，可是当跑到第 2 圈的时候，突然想起有急事要办，于是果断停止跑步并离开操场，这就相当于使用了 break 语句提前终止了循环。

break 语句的语法非常简单，只需要在相应 while 或 for 语句中直接加入即可。例如如下程序： 

1
2
3
4
5
6
7
8
9
add = "http://www.baidu.com,http://www.jd.com"
# 一个简单的for循环
for i in add:
    if i == ',' :
        #终止循环
        break
    print(i,end="")
print("\n执行循环体外的代码")

运行结果：

1
2
http://www.baidu.com
执行循环体外的代码

分析上面程序不难看出，当循环至 add 字符串中的逗号（ , ）时，程序执行 break 语句，其会直接终止当前的循环，跳出循环体。

break 语句一般会结合 if 语句进行搭配使用，表示在某种条件下跳出循环体。

注意，通过前面的学习我们知道，for 循环后也可以配备一个 else 语句。这种情况下，如果使用 break 语句跳出循环体，不会执行 else 中包含的代码。举个例子：

1
2
3
4
5
6
7
8
9
10
add = "http://www.baidu.com,http://www.jd.com"
# 一个简单的for循环
for i in add:
    if i == ',' :
        #终止循环
        break
    print(i,end="")
else:
    print("执行 else 语句中的代码")
print("\n执行循环体外的代码")

运行结果：

1
2
http://www.baidu.com
执行循环体外的代码

从输出结果可以看出，使用 break 跳出当前循环体之后，该循环后的 else 代码块也不会被执行。但是，如果将 else 代码块中的代码直接放在循环体的后面，则该部分代码将会被执行。

另外，对于嵌套的循环结构来说，break 语句只会终止所在循环体的执行，而不会作用于所有的循环体。举个例子： 

1
2
3
4
5
6
7
8
add = "http://www.baidu.com,http://www.jd.com"
for i in range(3):
    for j in add:
        if j == ',':
            break   
        print(j,end="")
    print("\n跳出内循环")

运行结果：

1
2
3
4
5
6
http://www.baidu.com
跳出内循环
http://www.baidu.com
跳出内循环
http://www.baidu.com
跳出内循环

分析上面程序，每当执行内层循环时，只要循环至 add 字符串中的逗号（ , ）就会执行 break 语句，它会立即停止执行当前所在的内存循环体，转而继续执行外层循环。

那么读者可能会问，在嵌套循环结构中，如何同时跳出内层循环和外层循环呢？最简单的方法就是借用一个 bool 类型的变量。

修改上面的程序： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
add = "http://www.baidu.com,http://www.jd.com"
#提前定义一个 bool 变量，并为其赋初值
flag = False
for i in range(3):
    for j in add:
        if j == ',':
            #在 break 前，修改 flag 的值
            flag = True
            break   
        print(j,end="")
    print("\n跳出内循环")
    #在外层循环体中再次使用 break
    if flag == True:
        print("跳出外层循环")
        break

可以看到，通过借助一个 bool 类型的变量 flag，在跳出内循环时更改 flag 的值，同时在外层循环体中，判断 flag 的值是否发生改动，如有改动，则再次执行 break 跳出外层循环；反之，则继续执行外层循环。

因此，上面程序的执行结果为： 

1
2
3
http://www.baidu.com
跳出内循环
跳出外层循环

continue

和 break 语句相比，continue 语句的作用则没有那么强大，它只会终止执行本次循环中剩下的代码，直接从下一次循环继续执行。

仍然以在操作跑步为例，原计划跑 10 圈，但当跑到 2 圈半的时候突然接到一个电话，此时停止了跑步，当挂断电话后，并没有继续跑剩下的半圈，而是直接从第 3 圈开始跑。

continue 语句的用法和 break 语句一样，只要 while 或 for 语句中的相应位置加入即可。例如： 

1
2
3
4
5
6
7
8
9
add = "http://www.baidu.com,http://www.jd.com"
# 一个简单的for循环
for i in add:
    if i == ',' :
        # 忽略本次循环的剩下语句
        print('\n')
        continue
    print(i,end="")

运行结果：

1
2
http://www.baidu.com
http://www.jd.com

可以看到，当遍历 add 字符串至逗号（ , ）时，会进入 if 判断语句执行 print() 语句和 continue 语句。其中，print() 语句起到换行的作用，而 continue 语句会使 Python 解释器忽略执行第 8 行代码，直接从下一次循环开始执行。

课后作业

1.略