【Python学习笔记系列】[万字长文] 一文带你彻底搞懂流程控制

最新推荐文章于 2024-07-25 22:24:14 发布

m0_70968573

最新推荐文章于 2024-07-25 22:24:14 发布

阅读量198

点赞数

文章标签：学习笔记 python

本文链接：https://blog.csdn.net/m0_70968573/article/details/131651602

版权

本文详细介绍了Python中的流程控制结构，包括顺序结构、选择结构（if,ifelse,ifelifelse）和循环结构（while,for）。重点讲解了ifelse表达式、if语句的嵌套、pass语句、assert断言以及循环中的break和continue语句的使用。此外，还提到了zip()函数和循环结构的嵌套应用。

摘要由CSDN通过智能技术生成

写在前面

最近这段时间比较充裕，想要系统学习一下python，这个系列算是对自己学习的一个记录吧。同时也想提供一个比较完整详细的python教程供有需要的小伙伴进行学习，大家一起共同进步！！！努力冲冲冲！！！

虽然我也不知道自己能够坚持多久，但我尽量坚持不断更哈哈哈。如果这篇文章对你有帮助的话，请多多点赞支持呀。你们的鼓励支持就是我坚持的最大动力【比心】。

如果需要查看往期文章的话，可以点击下面的文章链接，全部都已经汇总好了
【Python学习笔记系列】Python学习笔记系列文章汇总

前言

本文为python学习笔记系列文章。

本文主要介绍了python中的流程控制。

注：本文主要参考了C语言中文网中的python教程。

Python 程序可分为 3 大结构，即顺序结构、选择（分支）结构和循环结构：

Python 顺序结构就是让程序按照从头到尾的顺序依次执行每一条 Python 代码，不重复执行任何代码，也不跳过任何代码。
Python 选择结构也称分支结构，就是让程序“拐弯”，有选择性的执行代码；
Python 循环结构就是不断地重复执行同一段代码。

顺序结构

前面我们学习的代码都是顺序执行的，也就是先执行第1条语句，然后是第2条、第3条……一直到最后一条语句，这称为顺序结构。

顺序结构是最基础，最简单的结构。

由于前面已经学习过，这里不再赘述。

选择结构

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

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

表 1 if else 分支语句的三种形式
语法格式	执行流程
if 表达式：代码块
if 表达式：代码块 1 else：代码块 2
if 表达式 1：代码块 1 elif 表达式 2：代码块 2 elif 表达式 3：代码块 3 ...//其它elif语句 else：代码块 n

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

对语法格式的说明：

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

说明：

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

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

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

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

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

【实例1】

# 分支结构举例
age = int( input("请输入你的年龄：") )

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

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

运行结果1：

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

运行结果2：

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

【实例2】

# 分支结构举例
import sys
age = int( input("请输入你的年龄：") )

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

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

运行结果1：

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

运行结果2：

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

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

【实例3】

# 分支结构举例3
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.7↙
输入体重（千克）：70↙
BMI指数为：24.221453287197235
正常范围，注意保持

在其他语言中（如 C语言,C++等），选择结构还包括 switch 语句，也可以实现多重选择，但是在 Python 中没有 switch 语句，所以当要实现多重选择的功能时，只能使用 if else 分支语句。

if else 的表达式

if 和 elif 后面的“表达式”的形式是很自由的，只要表达式有一个结果，不管这个结果是什么类型，Python 都能判断它是“真”还是“假”。
布尔类型（bool）只有两个值，分别是 True 和 False，Python 会把 True 当做“真”，把 False 当做“假”。
对于数字，Python 会把 0 和 0.0 当做“假”，把其它值当做“真”。
对于其它类型，当对象为空或者为 None 时，Python 会把它们当做“假”，其它情况当做真。比如，下面的表达式都是不成立的：

"" #空字符串
[ ] #空列表
( ) #空元组
{ } #空字典
None #空值

【实例】

# 分支结构的表达式判断举例
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()返回值为空')

运行结果：

b是False
n是零值
s是空字符串
l是空列表
d是空字典
函数被调用
func()返回值为空

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

注意:

Python是以缩进来标记代码块的，代码块一定要有缩进，没有缩进的不是代码块。另外，同一个代码块的缩进量要相同，缩进量不同的不属于同一个代码块。

关于缩进：

由于Python是以缩进来标记代码块的，所以代码块一定要有缩进
if、elif 和 else 后面的代码块一定要缩进，而且缩进量要大于 if、elif 和 else 本身。
Python 要求代码块必须缩进，但是却没有要求缩进量，建议缩进 1 个 Tab 键的位置，或者缩进 4 个空格；
缩进的数量：一个代码块的所有语句都要缩进，而且缩进量必须相同。如果某个语句忘记缩进了，Python 解释器并不一定会报错，但是程序的运行逻辑往往会有问题。
同一代码块缩进量要相同：Python 不限制代码块的缩进量，可以随意缩进 n 个空格，但是，同一个代码块内的所有语句都必须拥有相同的缩进量
不要随便缩进：不需要使用代码块的地方千万不要缩进，一旦缩进就会产生一个代码块。

if语句嵌套

if、if else 和 if elif else三种条件语句，这三种条件语句之间可以相互嵌套。

例如，在最简单的 if 语句中嵌套 if else 语句，形式如下：

if 表达式 1：
    if 表示式 2：
        代码块 1
    else：
        代码块 2

再比如，在 if else 语句中嵌套 if else 语句，形式如下：

if 表示式 1：
    if 表达式 2：
        代码块 1
    else：
        代码块 2
else：
    if 表达式 3：
        代码块 3
    else：
        代码块 4

注意，在相互嵌套时，一定要严格遵守不同级别代码块的缩进规范。

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

可以使用两个 if else 语句嵌套来实现：

# if语句嵌套
proof = int(input("输入驾驶员每 100ml 血液酒精的含量："))

if proof < 20:
    print("驾驶员不构成酒驾")
else:
    if proof < 80:
        print("驾驶员已构成酒驾")   
    else:
        print("驾驶员已构成醉驾")

运行结果为：

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

除此之外，if分支结构中还可以嵌套循环结构，同样，循环结构中也可以嵌套分支结构。

pass语句

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

# pass语句举例--使用注释
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:
     print() # 成年人  
else:
    print("老年人")

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

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

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

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

# pass语句举例--使用pass
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("老年人")

运行结果：

请输入你的年龄：40

从运行结果可以看出，程序虽然执行到第 10 行代码，但是并没有进行什么操作。

assert语句

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

语法结构为：

assert 表达式

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

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

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

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

举例：

# assert语句举例
mathmark = int(input())

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

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

90
数学考试分数为： 90

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

120
Traceback (most recent call last):
File "D:\pythonLearning\basic\assert语句.py", line 5, in <module>
assert 0 <= mathmark <= 100
AssertionError

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

循环结构

while语句

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

语法格式如下：

while 条件表达式：
代码块

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

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

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

图 1 while 循环语句执行流程示意图

例如，打印 1~100 的所有数字，就可以使用 while 循环，实现代码如下：

# while循环举例
# 循环的初始化条件
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 循环遍历一个字符串变量：

# while循环举例
my_char="http://c.biancheng.net/python/"
i = 0;
while i<len(my_char):
    print(my_char[i],end="")
    i = i + 1

程序执行结果为：

http://c.biancheng.net/python/

for语句

for 循环，它常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素。

语法格式如下：

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

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

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

图 1 for 循环语句的执行流程图

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

# for循环语句举例
add = "http://c.biancheng.net/python/"

#for循环，遍历 add 字符串
for ch in add:
    print(ch,end="")

运行结果为：

http://c.biancheng.net/python/

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

for循环进行数值循环

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

# for循环语句举例--数值循环
print("计算 1+2+...+100 的结果为：")

#保存累加结果的变量
result = 0
#逐个获取从 1 到 100 这些值，并做累加操作
for i in range(101):
    result += i
print(result)

运行结果为：

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

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

for循环遍历列表和元组

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

下面程序使用 for 循环对列表进行了遍历：

# for循环语句举例--循环列表
my_list = [1,2,3,4,5]
for ele in my_list:
    print('ele =', ele)

程序执行结果为：

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

for循环遍历字典

使用 for 循环直接遍历字典，则迭代变量会被先后赋值为每个键值对中的键。

例如：

# for循环语句举例--循环字典
my_dic = {'python教程':"http://c.biancheng.net/python/",\
'shell教程':"http://c.biancheng.net/shell/",\
'java教程':"http://c.biancheng.net/java/"}
for ele in my_dic:
    print('ele =', ele)
print("======================")
for ele in my_dic.items():
    print('ele =', ele)

程序执行结果为：

ele = python教程
ele = shell教程
ele = java教程
======================
ele = ('python教程', 'http://c.biancheng.net/python/')
ele = ('shell教程', 'http://c.biancheng.net/shell/')
ele = ('java教程', 'http://c.biancheng.net/java/')

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

循环语句的else

Python中，无论是 while 循环还是 for 循环，其后都可以紧跟着一个 else 代码块，它的作用是当循环条件为 False 跳出循环时，程序会最先执行 else 代码块中的代码。

以 while 循环为例，下面程序演示了如何为 while 循环添加一个 else 代码块：

# while循环语句举例--else
add = "http://c.biancheng.net/python/"
i = 0
while i < len(add):
    print(add[i],end="")
    i = i + 1
else:
    print("\n执行 else 代码块")

程序执行结果为：

http://c.biancheng.net/python/
执行 else 代码块

上面程序中，当i==len(add)结束循环时（确切的说，是在结束循环之前），Python 解释器会执行 while 循环后的 else 代码块。

当然，我们也可以为 for 循环添加一个 else 代码块，例如：

# for循环语句举例--else
add = "http://c.biancheng.net/python/"
for i in add:
    print(i,end="")
else:
    print("\n执行 else 代码块")

程序执行结果为：

http://c.biancheng.net/python/
执行 else 代码块

循环语句嵌套

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

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

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

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

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

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

下面程序演示了 while-for 嵌套结构：

# 循环语句嵌套举例
i = 0
while i<5:
    for j in range(5):
        print("i=",i," j=",j)
    i=i+1

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

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

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

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

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

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

# 条件语句，循环语句嵌套举例
i = 0
if i<10:
    for j in range(5):
        print("i=",i," j=",j)

程序执行结果为：

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 ）嵌套。

Python提供了 2 种强制离开当前循环体的办法：

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

break语句

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

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

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

# break语句举例
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"

# 一个简单的for循环
for i in add:
    if i == ',' :
        #终止循环
        break
    print(i,end="")
print("\n执行循环体外的代码")

运行结果为：

http://c.biancheng.net/python/
执行循环体外的代码

说明：

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

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

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

# break语句举例
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"

for i in add:
    if i == ',' :
        #终止循环
        break
    print(i,end="")
else:
    print("执行 else 语句中的代码")
print("\n执行循环体外的代码")

程序执行结果为：

http://c.biancheng.net/python/
执行循环体外的代码

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

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

# break语句举例
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"

for i in range(3):
    for j in add:
        if j == ',':
            break
        print(j,end="")
    print("\n跳出内循环")

程序执行结果为：

http://c.biancheng.net/python/
跳出内循环
http://c.biancheng.net/python/
跳出内循环
http://c.biancheng.net/python/
跳出内循环

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

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

修改上面的程序：

# break语句举例
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"

#提前定义一个 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

程序的执行结果为：

http://c.biancheng.net/python/
跳出内循环
跳出外层循环

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

continue语句

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

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

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

# continue语句举例
add = "http://c.biancheng.net/python/,http://c.biancheng.net/shell/"
# 一个简单的for循环

for i in add:
    if i == ',' :
    # 忽略本次循环的剩下语句
        print('\n')
        continue
    print(i,end="")

运行上面程序，将看到如下运行结果：

http://c.biancheng.net/python/

http://c.biancheng.net/shell/

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

zip()

Python()内置函数之一，它可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组。

和 Python 3.x 版本不同，Python 2.x 版本中的 zip() 函数会直接返回列表，而不是返回 zip 对象。但是，返回的列表或者 zip 对象，其包含的元素（都是元组）是相同的。

zip() 函数的语法格式为：

zip(iterable, ...)

其中 iterable,... 表示多个列表、元组、字典、集合、字符串，甚至还可以为 range() 区间。

举例：

# zip函数举例
my_list = [11,12,13]
my_tuple = (21,22,23)

print([x for x in zip(my_list,my_tuple)])

my_dic = {31:2,32:4,33:5}
my_set = {41,42,43,44}

print([x for x in zip(my_dic)])

my_pychar = "python"
my_shechar = "shell"

print([x for x in zip(my_pychar,my_shechar)])

程序执行结果为：

[(11, 21), (12, 22), (13, 23)]
[(31,), (32,), (33,)]
[('p', 's'), ('y', 'h'), ('t', 'e'), ('h', 'l'), ('o', 'l')]

在使用 zip() 函数“压缩”多个序列时，它会分别取各序列中第 1 个元素、第 2 个元素、... 第 n 个元素，各自组成新的元组。需要注意的是，当多个序列中元素个数不一致时，会以最短的序列为准进行压缩。

另外，对于 zip() 函数返回的 zip 对象，既可以像上面程序那样，通过遍历提取其存储的元组，也可以向下面程序这样，通过调用 list() 函数将 zip() 对象强制转换成列表：

# zip函数举例
my_list = [11,12,13]
my_tuple = (21,22,23)

print(list(zip(my_list,my_tuple)))

程序执行结果为：

[(11, 21), (12, 22), (13, 23)]

总结

本文主要介绍了python中的流程控制。包括顺序结构，选择结构和循环结构。主要介绍了选择结构和循环结构，选择结构包括if,if else和if elif else语句以及嵌套语句，循环结构包括for循环，while循环以及嵌套循环，还介绍了pass语句，assert语句，break语句和continue语句。

m0_70968573

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Python学习笔记系列】[万字长文] 一文带你彻底搞懂流程控制

本文主要介绍了python中的流程控制。
复制链接

扫一扫

语法格式	执行流程
if 表达式：代码块
if 表达式：代码块 1 else：代码块 2
if 表达式 1：代码块 1 elif 表达式 2：代码块 2 elif 表达式 3：代码块 3 ...//其它elif语句 else：代码块 n