Python 基础之流程控制（二）

菜鸡在沪漂

已于 2023-07-03 17:21:48 修改

阅读量86

点赞数

分类专栏： Python 文章标签： python

于 2023-06-18 17:37:49 首次发布

本文链接：https://blog.csdn.net/weixin_53846408/article/details/131274032

版权

Python 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了Python编程中的流程控制，包括顺序结构、分支结构（单分支、二分支、多分支）和循环结构（while循环、for循环）。此外，还讲解了如何使用break和continue关键字以及else子句来控制循环行为，并提到了range函数在循环中的应用。最后，文章讨论了异常处理，包括try-except语句及其与else和finally子句的配合使用，以及常见异常类型。

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

流程控制

流程控制指的是代码运行逻辑、分支走向、循环控制，是真正体现我们程序执行顺序的操作。

流程控制一般分为顺序执行、条件判断和循环控制。

程序结构

计算机程序是一条条按顺序执行的指令。顺序结构是是计算机程序的基础，但单一的顺序结构不能解决所有问题。计算机程序由三种基本结构组成：

顺序结构
分支结构
循环结构

1. 顺序结构

我们每天早上起床，穿衣服，洗脸，刷牙，吃早餐，上班，工作，吃午饭，下班，吃晚饭，睡觉，这些按照单一顺序进行的就是顺序结构。

顺序结构是程序执行的基本流程，它会按照代码从上往下的顺序依次执行。

a = 1
a += 1
print(a)
运行结果: 2

例如上面的代码，执行流程为:

定义变量a,并赋值为整数1
变量a自加1
调用函数print输出变量a的值

从上往下依次执行

2. 分支结构

出门时是否带雨伞要根据天气条件进行判断，如果天气好就不带，如果可能下雨或正在下雨就要带，这就是分支结构。

分支结构是程序根据条件判断结果而选择不同代码向前执行的一种方式，也叫条件分支。

分支结构包括：

单分支
二分支
多分支

2.1 单分支

在 Python 中单分支结构通过 if 语句来实现，语法如下：

if <条件>：
    语句块

注意：
1、注意条件语句结束后要紧跟冒号；
2、语句块是if条件满足后执行的一条或多条语句序列；
3、语句块中语句通过缩进与if语句所在行形成包含关系；
4、缩进按照规范为4个空格；

if 语句会首先计算<条件>表达式，如果结果为 True 则会执行所包含的语句块，结果为 False 则会跳过所包含的语句块。

if 语句中的语句块的执行与否依赖于条件判断。但无论什么情况，控制都会转到与 if 语句同级别的下一条语句。

案例1:

age = 18

if age >= 18:
    print("您已经成年了，可以去投票。")
运行结果: 您已经成年了，可以去投票。

详解：在这个案例中，首先定义了一个变量 age，并将其赋值为 18。然后，我们使用 if 语句来检查 age 是否大于或等于 18。如果是，我们就输出一条消息，表示这个人可以去投票了。
值得注意的是，这个案例只有一个分支，即当条件满足时执行的分支。如果条件不满足，程序将不会执行任何操作。

案例2：

age = int(input('请输入你的年龄:'))
if age >= 18:
    print('恭喜你已成年！')
if age < 18:
    print('你还未成年！')


运行结果: 输入 19
恭喜你已成年！

运行结果: 输入 17
你还未成年！

2.2 二分支

Python中二分支结构通过 if-else 语句来实现的，语法格式如下：

if <条件>:
	<语句块1>
else:
	<语句块2>

详解: 
    <语句块1>是在if条件满足后执行的一个或多个语句序列
    <语句块2>是if条件不满足后执行的语句序列
    注意缩进，<语句块2>通过缩进与else所在行形成包含关系

二分支语句用于区分<条件>的两种可能True或者False，分别形成执行路径;

案例1:

age = int(input('请输入你的年龄：'))
if age >=60:
    print('你已半截黄土入土，请注意身体！')
else:
    print('身体相当可以!')

运行结果: 输入 60
你已半截黄土入土，请注意身体！

运行结果：输入 40
身体相当可以!

2.3. 多分支

Python 通过 if - elif - else 表示多分支结构，语法如下：

if <条件1>:
	<代码块1>
elif <条件2>:
	<代码块2>
...
else:
	<代码块3>

多分支是二分支的扩展，用于多个判断条件多条执行路径的情况。Python 依次执行判断条件，寻找第一个结果为 True 的条件，执行该条件下的代码块，同时结束后跳过整个 if-elif-else 结构，执行后面的语句。如果没有任何条件成立，则执行else下的代码块，且 else 语句是可选的，也即是说可以没有 else 语句。

案例1：

age = int(input('请输入你的年龄：'))
if age >=60:
    print('你已半截黄土入土，请注意身体！')
elif 50 <= age < 60:
    print('身体还算硬朗!')
elif 40 <= age < 50:
    print('身体还行!')
else:
    print('身体相当可以!')

详解：如果输入的年龄。不满足 elif 里面的判断，就输出 else 的内容

3. 循环结构

工作日每天9:00到公司上班，17:30下班，周而复始，这就是循环结构。

Python中循环结构有两种：

条件循环也叫while循环
遍历循环也叫for循环

3.1 条件循环

Python 中的条件循环通过 while 循环语句来实现，所以也叫 while 循环，语法格式如下：

while <条件>:
	代码块

注意：
    while关键字空格后接条件表达式末尾加上冒号组成while语句
    代码块中的代码通过4个空格和while语句形成包含关系

while语句首先计算<条件>表达式，如果结果 True，则执行对应代码块中的语句，执行结束后再次执行<条件>

表达式，再次判断结果，如果为 True 则循环执行，直到<条件>表达式为 False 时跳出循环，执行和while语句相同缩进的下一条语句。

当<条件>表达式恒为True时，形成无限循环，也叫死循环，需要小心使用。

死循环案例

while 4 < 10:
    print(4)

运行结果:
4
4
4
4
4
4
4
4
4
4
.......

详解: 4 小于 10，为真，所以一直进行循环；

案例1：

1、 依次打印 0 ~ 9
i = 0
while i < 10:
    print(i)
    i +=1
运行结果: 
0
1
2
3
4
5
6
7
8
9

案例2

# 序列的循环
# 列表的元素循环
ls = ['a','b','c','d','e','f'] # 列表
index = 0 #索引从0开始
while index < len(ls): #len()获取列表的元素数量。是否小于索引0
    print(ls[index]) #输出 每次循环的元素内容
    index += 1 # 在自加1索引

运行结果:
a
b
c
d
e
f

案例3

# 散列的循环
# 字典没办法循环
dc = {'name': 'felix', 'age': 18}  # 字典
index = 0 #索引位置从0开始
print(list(dc.keys()))
# 转换成列表
keys = list(dc.keys()) #转换成列表。并获取键
while index < len(keys): #len获取keys内多少数量。并是否小于 index索引
    print(dc[keys[index]]) #根据键的索引获取对应的值并进行输出
    index += 1 #索引自加1

运行结果:
['name', 'age']
felix
18

3.2 遍历循环

Python中使用关键字 for 来实现遍历循环，也叫 for 循环，也叫迭代循环，语法格式如下：

for <循环变量> in <遍历结构>：
	代码块

注意：

    关键字for+空格+<循环变量>+关键字in+<遍历结构>+冒号组成for语句
    代码块通过缩进和for语句形成包含关系

for 循环会依次取出遍历结构中的元素，然后赋值给循环变量，每次遍历都会执行代码块，只到取出遍历结构中的所有元素。

所有可迭代对象都可以作为遍历结构进行for循环。

基本数据类型中序列数据类型，散列数据类型都可以进行迭代。

案例

# for循环来遍历可迭代对象非常方便
# 序列的迭代
# 列表的迭代

res = [1,2,3,4,5,6]
for i in res:
    print(i)

运行结果:
1
2
3
4
5
6

案例1

# 集合的迭代
res = {1,2,3,4,5,6}
for i in res:
    print(i)

运行结果：
1
2
3
4
5
6

案例2

# 字典的迭代,获取键
dc = {
    'user':'max',
    'name':'min'
}
for i in dc:
    print(i)

运行结果:
user
name

# 字典的迭代,获取键
dc = {
    'user':'max',
    'name':'min'
}
for keys in dc.keys():
    print(keys) # 获取 键

运行结果:
user
name



# 字典的迭代,根据键获取对应的值
dc = {
    'user':'max',
    'name':'min'
}
for key in dc:
    print(dc[key]) # 根据键获取对应的值
    
运行结果:
max
min

# 字典的迭代,根据键获取对应的值
dc = {
    'user':'max',
    'name':'min'
}
for value in dc.values():
    print(value) # 获取 值

3.3 循环控制关键字

循环有时候需要主动中断来提高程序执行效率。

while 循环和 break 的结构如下图所示：

break关键字

break 语句的基本形式为：

while 判断条件1：
    循环语句
    判断条件2：
    break

Python 中循环结构可以使用 break 跳出当前循环体，脱离该循环后代码继续执行。

# 迭代循环
for i in range(0,20,2):
    if i == 8: # 如果 i 等于 8，就停止循环
        break
    print(i)

运行结果: 
0
2
4
6

#  条件循环
count = 0
while count <= 10: # count 小于等于10
    print(count)
    count += 1 # count自加1
    if count > 5: #如果count 大于5 就停止循环
        break

运行结果：
0
1
2
3
4
5

continue关键字

Python中循环结构还可以使用 continue 关键字用来跳出当次循环，继续执行下一次循环。

1、迭代循环
for i in range(0,10,2):
    if i == 4: # 如果 i 等于 4就跳出循环，继续下一个循环
        continue
    print(i)

运行结果：
0
2
6
8

else关键字

循环结构还可以通过和 else 关键字进行配合，用来检测循环是否正常循环结束，还是break掉了。

for i in range(0,10,2):
    if i == 4:
        continue
    print(i)
else:
    print('循环正常结束')

运行结果：
0
2
6
8
循环正常结束

range函数

内建函数 range 可以创建输出整数序列的迭代器。

range(start, stop,step)

# 输出0-9
for i in range(10): #半区间，不包含10
    print(i)

运行结果：
0
1
2
3
4
5
6
7
8
9

# 输出1-10
for i in range(1,11):
    print(i)

运行结果：
1
2
3
4
5
6
7
8
9
10

for i in range(0,20,2): # 从0开始到20结束，每2个跳一下；
    print(i)

运行结果:
0
2
4
6
8
10
12
14
16
18

for 循环经常和 range 函数配合用来指定循环次数

异常处理

程序中有一种错误发生在程序运行后，可能是由于逻辑问题，又或者是业务发生了改变，为了能让用户有更好的体验，加强代码的健壮性，我们需要对这些错误进行处理，也叫异常处理。

Python 中通过 try-except 语句进行异常处理。

try-except语句的基本语法格式如下：

try:
	<语句块1>
except <异常类型1>:
	<语句块2>
except <异常类型2>:
    <语句块3>

结构图：

错误案例

age = int(input('请输入年龄：')) # 要求只能输入 整数。如果输入浮点数，会出现什么情况
if age >= 18:
    print('恭喜。你已成年!')
else:
    print('你还未成年!')

运行结果：输入 19
恭喜。你已成年!

运行结果：输入 12.5
Traceback (most recent call last):
  File "/Users/tankaihua/data/jenkins_home/workspace/qa/test/dcpp.py", line 1, in <module>
    age = int(input('请输入年龄：'))
ValueError: invalid literal for int() with base 10: '12.5'

Traceback: 表示代码回溯；
ValueError: 表示 错误类型；
invalid literal for int() with base 10: '12.23': 表示 异常提示信息；

正确案例

try:
    age = int(input('请输入年龄：'))
    if age >= 18:
        print('恭喜。你已成年!')
    else:
        print('你还未成年!')
except ValueError as e:
    print(e)
    print('请输入正确年龄!')

运行结果: 输入年龄：12.3
invalid literal for int() with base 10: '12.3'
请输入正确年龄!

除了try和except关键字外，异常语句还可以与else和finally关键字配合使用，语法格式如下：

try: 
	<语句块1>
except <异常类型>:
	<语句块2>
...
else:
	<语句块3>
finally:
	<语句块4>

代码执行流程如下：

没有发生异常时，会执行else语句后的代码块,不管有没有发生异常，finally语句后的代码块一定会执行

try:
    age = int(input('请输入年龄：'))
    if age >= 18:
        print('恭喜。你已成年!')
    else:
        print('你还未成年!')
except ValueError as e:
    print(e)
    print('请输入正确年龄!')
else:
    print('代码块没有发生异常执行!')
finally:
    print('一定会执行')

运行结果: 输入 12
你还未成年!
代码块没有发生异常执行!
一定会执行

运行结果: 输入 12.4
invalid literal for int() with base 10: '12.4'
请输入正确年龄!
一定会执行

注意：少输出 else 里面的内容；