Python控制流语句

Python控制流语句

条件语句：if - elif - else

在Python编程中，条件语句是控制程序执行流程的重要工具。if - elif - else结构允许根据不同的条件来执行不同的代码块。

1. 基本的if语句 最简单的形式是if语句，它的语法如下：

x = 10
if x > 5:
    print("x大于5")

在上述代码中，首先定义变量x并赋值为10。然后if语句检查条件x > 5，如果这个条件为True，就会执行缩进块中的代码，即打印"x大于5"。

2. if - else语句 if - else语句提供了在条件为False时执行另一部分代码的能力。语法如下：

x = 3
if x > 5:
    print("x大于5")
else:
    print("x小于或等于5")

这里，x的值为3，if条件x > 5为False，所以程序执行else块中的代码，打印"x小于或等于5"。

3. if - elif - else语句 当有多个条件需要依次检查时，if - elif - else结构就非常有用。elif是else if的缩写。语法如下：

x = 5
if x > 5:
    print("x大于5")
elif x < 5:
    print("x小于5")
else:
    print("x等于5")

在这个例子中，首先检查if条件x > 5，由于x的值为5，该条件为False。接着检查elif条件x < 5，同样为False。最后执行else块中的代码，打印"x等于5"。

循环语句：for循环

for循环在Python中用于迭代序列（如列表、元组、字符串等）或其他可迭代对象。

1. 遍历列表

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

上述代码中，fruits是一个列表。for循环依次从fruits列表中取出每个元素，并赋值给变量fruit，然后执行缩进块中的代码，即打印出每个水果的名称。

2. 使用range()函数 range()函数常用于生成数字序列。它可以接受1到3个参数：

• range(stop)：生成从0到stop - 1的整数序列。
• range(start, stop)：生成从start到stop - 1的整数序列。
• range(start, stop, step)：生成从start到stop - 1，步长为step的整数序列。

for i in range(5):
    print(i)

这段代码中，range(5)生成了序列0, 1, 2, 3, 4。for循环依次将这些值赋给i，并打印出来。

for i in range(2, 7):
    print(i)

这里range(2, 7)生成序列2, 3, 4, 5, 6，并依次打印。

for i in range(1, 10, 2):
    print(i)

range(1, 10, 2)生成序列1, 3, 5, 7, 9，步长为2。

3. 嵌套for循环 可以在一个for循环内部再嵌套一个或多个for循环。

for i in range(2):
    for j in range(3):
        print(f"i: {i}, j: {j}")

在这个例子中，外层for循环执行2次，每次外层循环执行时，内层for循环执行3次。因此，总共会打印6次，输出不同的i和j的组合。

循环语句：while循环

while循环在条件为True时，会重复执行一段代码块。

1. 基本的while循环

count = 0
while count < 5:
    print(count)
    count = count + 1

这里，首先定义变量count并初始化为0。while循环检查条件count < 5，只要这个条件为True，就会执行缩进块中的代码。在缩进块中，先打印count的值，然后将count的值增加1。当count的值达到5时，条件count < 5为False，循环结束。

2. while循环中的break和continue
   • break：用于立即终止循环。

count = 0
while count < 10:
    if count == 5:
        break
    print(count)
    count = count + 1

在这个例子中，当count的值为5时，if条件count == 5为True，执行break语句，立即终止while循环。因此，只打印出0到4。 - continue：用于跳过当前循环的剩余部分，直接开始下一次循环。

count = 0
while count < 10:
    count = count + 1
    if count % 2 == 0:
        continue
    print(count)

这里，每次循环开始时，count的值先增加1。然后if条件count % 2 == 0检查count是否为偶数。如果是偶数，执行continue语句，跳过本次循环中剩余的代码（即不打印偶数），直接开始下一次循环。所以只会打印出奇数。

控制流语句的应用场景

1. 数据验证 在处理用户输入或读取外部数据时，条件语句可以用于验证数据的合法性。

age = input("请输入你的年龄：")
try:
    age = int(age)
    if age < 0 or age > 120:
        print("年龄不合法")
    else:
        print(f"你的年龄是：{age}")
except ValueError:
    print("输入的不是有效的年龄")

在这段代码中，首先通过input()获取用户输入，然后尝试将其转换为整数。如果转换成功，使用if - else语句检查年龄是否在合理范围内。如果转换失败，捕获ValueError异常并提示输入无效。

2. 迭代处理数据集合 无论是for循环还是while循环，都广泛用于对数据集合（如列表、字典等）进行迭代处理。

students = [
    {'name': 'Alice', 'age': 20},
    {'name': 'Bob', 'age': 22},
    {'name': 'Charlie', 'age': 19}
]
for student in students:
    if student['age'] >= 20:
        print(f"{student['name']} 年龄达到或超过20岁")

在这个例子中，使用for循环遍历students列表，每个元素是一个字典，包含学生的姓名和年龄。通过条件语句判断学生年龄是否达到或超过20岁，并打印相应信息。

3. 实现算法 许多算法都依赖于控制流语句。例如，计算斐波那契数列可以使用while循环。

n = 10
a, b = 0, 1
count = 0
while count < n:
    print(a)
    a, b = b, a + b
    count = count + 1

在这个代码中，使用while循环生成斐波那契数列的前n项。a和b分别初始化为0和1，每次循环打印a的值，然后更新a和b的值，count用于记录生成的项数，当count达到n时，循环结束。

条件表达式（三元运算符）

除了if - elif - else这种常规的条件语句，Python还提供了条件表达式，也称为三元运算符，它是一种简洁的写法，用于根据条件返回不同的值。

1. 语法 条件表达式的语法为：value_if_true if condition else value_if_false。

x = 10
y = 5 if x > 10 else 15
print(y)

在上述代码中，条件是x > 10，由于x的值为10，x > 10为False，所以返回value_if_false，即15，并将其赋值给y，最后打印出15。

2. 嵌套条件表达式 条件表达式也可以嵌套使用，但过多的嵌套会使代码可读性变差。

x = 10
result = "大于10" if x > 10 else ("等于10" if x == 10 else "小于10")
print(result)

这里，先判断x > 10，为False，所以进入else部分，在else部分又有一个条件表达式，判断x == 10，为True，所以返回"等于10"，并赋值给result，最后打印出"等于10"。

循环控制语句的优化

1. 减少循环内的计算 尽量将不变的计算移出循环，以提高循环效率。

# 不好的做法
for i in range(1000):
    result = i * 3.141592653589793
    print(result)

# 好的做法
pi = 3.141592653589793
for i in range(1000):
    result = i * pi
    print(result)

在第一个例子中，每次循环都要重新计算3.141592653589793，而在第二个例子中，将这个值预先计算并存储在变量pi中，循环内只需要进行乘法运算，减少了不必要的计算开销。

2. 使用生成器 生成器是一种特殊的迭代器，它可以按需生成值，而不是一次性生成所有值。这在处理大数据集时非常有用，可以节省内存。

def my_generator(n):
    for i in range(n):
        yield i * 2

gen = my_generator(10)
for value in gen:
    print(value)

在这个例子中，my_generator是一个生成器函数，它使用yield关键字返回值。每次调用next(gen)（在for循环内部隐式调用）时，生成器函数会从上次yield的位置继续执行，生成下一个值。这样，不需要一次性生成所有10个值并存储在内存中，而是按需生成。

3. 避免不必要的循环 有时候可以通过数学公式或其他方法避免使用循环。例如，计算1到100的和，可以使用等差数列求和公式。

# 使用循环
sum_value = 0
for i in range(1, 101):
    sum_value = sum_value + i
print(sum_value)

# 使用公式
sum_value = (1 + 100) * 100 // 2
print(sum_value)

第二个方法直接使用等差数列求和公式(首项 + 末项) * 项数 // 2，避免了循环，执行效率更高。

控制流语句在面向对象编程中的应用

1. 类方法中的条件控制 在类的方法中，条件语句可以根据对象的状态执行不同的操作。

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def get_area(self):
        if self.width <= 0 or self.height <= 0:
            return 0
        return self.width * self.height

在这个Rectangle类中，get_area方法用于计算矩形的面积。首先通过条件语句检查矩形的宽度和高度是否为非正数，如果是，则返回0，否则返回宽度和高度的乘积。

2. 循环遍历对象集合 当有多个对象组成的集合时，可以使用循环进行遍历和操作。

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

students = [
    Student('Alice', 85),
    Student('Bob', 78),
    Student('Charlie', 92)
]
for student in students:
    if student.grade >= 90:
        print(f"{student.name} 成绩优秀")

这里，students列表包含多个Student对象。通过for循环遍历列表，使用条件语句判断每个学生的成绩是否达到90分及以上，如果是，则打印相应信息。

异常处理中的控制流

1. try - except语句中的条件判断 在异常处理中，try - except块本身就是一种控制流结构。在except块中，还可以根据异常类型进行进一步的条件判断。

try:
    num1 = input("请输入第一个数字：")
    num2 = input("请输入第二个数字：")
    result = int(num1) / int(num2)
    print(result)
except ValueError:
    print("输入的不是有效的数字")
except ZeroDivisionError:
    print("除数不能为零")

在这个例子中，try块尝试将用户输入转换为整数并进行除法运算。如果输入不是有效的数字，会引发ValueError异常，执行第一个except块中的代码；如果除数为零，会引发ZeroDivisionError异常，执行第二个except块中的代码。

2. 使用finally块进行清理操作 finally块无论try块中是否发生异常，都会被执行。这在需要进行资源清理（如关闭文件、数据库连接等）时非常有用。

try:
    file = open('test.txt', 'r')
    content = file.read()
    print(content)
except FileNotFoundError:
    print("文件不存在")
finally:
    file.close()

这里，try块尝试打开文件并读取内容。如果文件不存在，捕获FileNotFoundError异常并打印提示信息。无论是否发生异常，finally块中的file.close()都会被执行，确保文件被正确关闭。

总结与最佳实践

1. 保持代码的可读性

• 使用有意义的变量名和注释，特别是在复杂的控制流结构中。例如，在if - elif - else结构中，每个条件块前可以添加注释说明其用途。
• 避免过度嵌套控制流语句。如果嵌套层次过多，可以考虑将部分代码提取成函数，以提高代码的可读性和可维护性。

2. 选择合适的控制流语句

• if - elif - else适用于根据不同条件执行不同代码块的情况。
• for循环适用于已知迭代次数或遍历可迭代对象的场景。
• while循环适用于在条件满足时持续执行代码块，且迭代次数不明确的情况。

3. 合理使用异常处理

• 异常处理不应滥用，只捕获可能发生且需要处理的异常。过多的异常处理可能会掩盖真正的错误，使调试变得困难。
• 在except块中，尽量提供详细的错误信息，以便于调试和维护。

4. 优化性能

• 如前文所述，注意减少循环内的计算，合理使用生成器等技术来优化程序性能。在处理大数据集或对性能要求较高的场景下，这些优化措施尤为重要。

通过深入理解和合理使用Python的控制流语句，开发者能够编写出逻辑清晰、高效且易于维护的代码，无论是开发小型脚本还是大型复杂的应用程序，控制流语句都是不可或缺的关键部分。