python程序的分支结构（专题）_掌握python分支程序结构的编程

python程序的分支结构

前言

程序的分支结构分为三种，分别是单分支结构，二分支结构，多分支结构。同时需要掌握条件判断及组合，程序的异常处理。

在编程的世界里，分支结构是每位程序员都应熟练掌握的利器。就像生活中的抉择一样，程序也需要在不同的条件下做出选择。在Python的舞台上，分支结构以清晰简洁的语法展现，让你能够以一种直观的方式控制程序的流程。本篇技术博客将引导你深入探索Python程序中的分支结构，为你揭开这个编程世界中的一道神秘面纱。

无论你是初学者还是经验丰富的开发者，理解和灵活运用分支结构是提高代码可读性和功能性的关键一步。我们将深入研究条件语句、循环结构和异常处理，为你呈现一个全面的分支结构指南。准备好迎接这场代码之旅，让我们一同揭示分支结构的精妙之处，掌握Python编程的更高层次。

一、单分支结构

根据判断条件结果而选择不同向前路径的运行方式。

if <条件>： 
    <语句块>

1
2
3

if语句的控制流程图：
单分支示例：``guess = eval(input())
if guess == 99:
print(“猜对了”)
`

二、二分支结构

1.根据判断条件结果而选择不同向前路径的运行方式

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

二分支示例：guess = eval(input()) if guess == 99: print("猜对了") else : print("猜错了")

2.紧凑形式：适用于简单表达式的二分支结构

代码如下（示例）：

<表达式1> if <条件> else <表达式2>
guess = eval(input())
print("猜{}了".format("对" if guess==99 else "错")
1
2
3

三、多分支结构

if <条件1> :
<语句块1>
elif <条件2> :
<语句块2>
……
else :
<语句块N>
1
2
3
4
5
6
7

多分支结构
对不同分数分级的问题：

score = eval(input())
if score >= 60:
grade = "D"
elif score >= 70:
grade = "C"
elif score >= 80:
grade = "B"
elif score >= 90:
grade = "A"
print("输入成绩属于级别{}".format(grade))
1
2
3
4
5
6
7
8
9
10

注：- 注意多条件之间的包含关系
注意变量取值范围的覆盖

四，条件判断及组合

条件判断及组合
示例

guess = eval(input())
if guess > 99 or guess < 99:
print("猜错了")
else :
print("猜对了")
1
2
3
4
5

if not True:
print("语句块2")
else :
print("语句块1")

1
2
3
4
5

五，程序的异常处理

异常处理的基本使用：

try :
<语句块1>
except :
<语句块2>
``

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

1
2
3
4
5
6
7
8
9
10
11
12

示例1

try :
num = eval(input("请输入一个整数: "))
print(num**2)
except :
print("输入不是整数")
1
2
3
4
5

示例2

try :
num = eval(input("请输入一个整数: "))
print(num**2)
except NameError:
print("输入不是整数")
1
2
3
4
5

标注异常类型后，仅响应此类异常
异常类型名字等同于变量名

异常处理的高级使用

try : 
<语句块1>
except :
<语句块2>
else :
<语句块3>
finally :
<语句块4>
1
2
3
4
5
6
7
8

• finally对应语句块4一定执行
• else对应语句块3在不发生异常时执行

实践案例与最佳实践具体介绍

1. 用户输入验证：
   实例： 在一个用户登录系统中，使用条件语句验证用户输入的用户名和密码是否符合规范，避免无效的登录尝试。

最佳实践：

使用if语句检查用户名和密码是否为空，并使用elif语句验证输入是否符合预定的格式要求。

将输入验证的逻辑封装在函数中，以提高代码的可重用性。

利用异常处理来捕获不符合规范的输入，给予用户友好的错误提示。

def login(username, password):
    if not username or not password:
        raise ValueError("用户名和密码不能为空")

    elif not (6 <= len(password) <= 12):
        raise ValueError("密码长度应在6到12个字符之间")

    # 其他验证逻辑...

    print("登录成功")

# 调用
try:
    login("user123", "pass123")
except ValueError as e:
    print(f"登录失败：{e}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2. 文件操作中的条件处理：
   实例： 在处理文件时，根据文件类型执行不同的操作，例如读取文本文件或解析JSON文件。

使用文件扩展名等条件判断文件类型，决定采取何种处理方式。

通过函数封装文件操作，使代码更易读且具有可维护性。

使用异常处理来应对文件不存在等意外情况。

import json

def process_file(file_path):
    if file_path.endswith(".txt"):
        with open(file_path, 'r') as txt_file:
            # 处理文本文件逻辑...
            print("处理文本文件")

    elif file_path.endswith(".json"):
        with open(file_path, 'r') as json_file:
            data = json.load(json_file)
            # 处理JSON文件逻辑...
            print("处理JSON文件")

    else:
        raise ValueError("不支持的文件类型")

# 调用
try:
    process_file("example.txt")
except ValueError as e:
    print(f"处理文件失败：{e}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

性能考虑

在使用分支结构时，除了代码的清晰性和逻辑合理性之外，我们还需要考虑程序的性能。不同的分支结构方式可能对程序的执行效率产生影响，因此在编写代码时需要谨慎选择和优化。以下是一些性能考虑的具体展开：

1. if-elif-else语句与switch语句的对比：
   在Python中，并没有直接的switch语句，而是使用if-elif-else语句来处理多个条件分支。性能上的考虑主要集中在这两者的可读性和执行效率上。

在较简单的情况下，使用if-elif-else语句，因为这样更加Pythonic和易读。
在大量条件分支的情况下，可以考虑使用字典映射或函数映射来优化代码。

# if-elif-else 语句
def process_data(option):
    if option == 'A':
        # 处理 A
    elif option == 'B':
        # 处理 B
    elif option == 'C':
        # 处理 C
    else:
        # 默认处理
        pass

# 字典映射
def process_data_dict(option):
    options = {
        'A': process_A,
        'B': process_B,
        'C': process_C,
    }
    options.get(option, default_process)()

# 函数映射
def process_A():
    # 处理 A

def process_B():
    # 处理 B

def process_C():
    # 处理 C

def default_process():
    # 默认处理
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

2. 避免不必要的嵌套：
   嵌套过多的条件语句可能导致代码难以阅读，也可能对性能产生一定影响。过深的嵌套可能使得代码更难优化和维护。
   尽量避免过深的嵌套，考虑将复杂的逻辑分解成函数或者通过其他结构化方式组织。
   使用逻辑运算符（如and、or、not）合理组合条件，以避免多层嵌套。

# 避免过深嵌套
if condition_1:
    if condition_2:
        # 处理逻辑...
    else:
        # 处理逻辑...
else:
    # 处理逻辑...

# 使用逻辑运算符
if condition_1 and condition_2:
    # 处理逻辑...
else:
    # 处理逻辑...
1
2
3
4
5
6
7
8
9
10
11
12
13
14

总结

程序的分支结构

单分支 if 二分支 if-else 及紧凑形式

• 多分支 if-elif-else 及条件之间关系
• not and or > >= == <= < !=
• 异常处理 try-except-else-finally
  程

在这篇博客的探索中，我们漫游于Python程序的分支结构之中，发现了其奇妙而灵活的本质。无论是简单的条件语句，还是复杂的循环结构，每一行代码都是一次选择，每一个分支都是一次决策。通过理解和运用这些分支结构，我们能够使程序在不同的情境下表现出多样性和强大的适应性。

分支结构不仅仅是代码的组织方式，更是程序员与计算机交流的桥梁。在这个由选择构成的编程世界中，我们逐渐认识到每一个判断、每一个路径都在塑造程序的行为。随着对分支结构的深入理解，你将更加游刃有余地驾驭Python编程的舞台，将思想转化为代码，创造出更为强大、灵活的程序。愿你在代码的分支丛林中找到灵感，点燃编程的激情。

另外，如果想要了解not的用法，可以移步我的另一篇文章。
python中not的用法