---
title: 控制语句
description: Python 控制语句
keywords:
  - Python
  - 控制语句
tags:
  - Python/入门
sidebar_position: 3
author: 7Wate
date: 2023-08-03
---

Python 中的控制语句有条件语句，循环语句，异常处理，以及其他一些特殊的控制语句。

## 条件语句

Python 中的条件语句是通过一条或多条语句的执行结果（即 True 或 False）来决定执行的代码块。

判断的值可以分为：

- 假值 ：None、空列表、空集合、空字典，空元组、空字符串、0、False 等。
- 真值 ：非空列表、非空集合、非空字典，非空元组、非空字符串、非 0 数值、True 等。

### If

在 Python 中，要构造分支结构可以使用 `if`、`elif` 和 `else` 关键字。`elif` 和 `else` 都是可选的，可以根据需要进行使用。

```python
# 示例
>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
        x = 0
        print('Negative changed to zero')
    elif x == 0:
        print('Zero')
    elif x == 1:
        print('Single')
    else:
        print('More')
```

当然如果要构造出更多的分支，可以使用 `if...elif...else...` 结构或者嵌套的 `if...else...` 结构。

### Match

Python 3.10 引入了新的 `match` 语句，它是模式匹配的一种形式。`match` 语句接受一个表达式并将它的值与一系列的模式进行比较。 每个模式都关联到一个代码块，当模式与表达式的值匹配时，该代码块将被执行。这在某种程度上类似于其他语言中的 switch 语句。

```python
def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        #"变量名" `_` 被作为 通配符 并必定会匹配成功
        case _: 
            return "Something's wrong with the internet"
```

你可以使用 `|` （“ or ”）在一个模式中组合几个字面值:

```python
case 401 | 403 | 404:
    return "Not allowed"
```

*注意，`match` 语句和模式匹配的概念是 Python 3.10 中新增的特性，可能在更早版本的 Python 中无法使用。*

## 循环语句

### For

Python 的 for 语句用于遍历任何序列的项目，如列表或字符串。

Python 的 for 语句与 C 或 Pascal 中的不同。**Python 的 for 语句不迭代算术递增数值**（如 Pascal），或是给予用户定义迭代步骤和暂停条件的能力（如 C），而是迭代列表或字符串等任意序列，元素的迭代顺序与在序列中出现的顺序一致。

```python
"""
用for循环实现1~100求和
"""

sum = 0
for x in range(101):
    sum += x
print(sum)
```

**内置函数 range() 表示不可变的数字序列，通常用于在 for 循环中循环指定的次数。**

在 Python 中，`range()` 是一个内置函数，用于生成一个不可变的数字序列。通常，这个函数在 for 循环中使用，用于指定循环的次数。`range(101)` 可以用来生成一个包含 0 到 100（不包含 101）的整数序列。

你也可以根据需要更改 `range()` 函数的参数，例如：

- `range(1, 101)`：生成一个包含 1 到 100（不包含 101）的整数序列。
- `range(1, 101, 2)`：生成一个包含 1 到 100 的奇数序列，其中 2 是步长。
- `range(100, 0, -2)`：生成一个包含 100 到 1 的偶数序列，其中 -2 是步长。

### While

`while` 循环语句用于在条件满足的情况下重复执行一个代码块。条件表达式的结果为 `True` 时，继续循环；结果为 `False` 时，结束循环。

```python
"""
猜数字游戏
"""
import random

answer = random.randint(1, 100)
counter = 0
while True:
    counter += 1
    number = int(input('请输入: '))
    if number < answer:
        print('大一点')
    elif number > answer:
        print('小一点')
    else:
        print('恭喜你猜对了!')
        break
print('你总共猜了%d次' % counter)
if counter > 7:
    print('你的智商余额明显不足')
```

### Break

`break` 语句可以提前退出循环。具体来说，**`break` 用于完全结束一个循环，并跳出该循环体。**

### Continue

`continue` 语句用于**跳过当前循环的剩余语句，然后继续进行下一轮循环。**

### Else

在 Python 中，`else` 子句可以与 `for` 循环和 `while` 循环一起使用。当循环正常完成（即没有碰到 `break` 语句）时，`else` 块的内容会被执行。这个特性在很多其他语言中都没有，因此对于初学者来说可能会感到有些不熟悉。

```python
# 使用 else 的 for 循环的示例
for i in range(5):
    if i == 10:
        break
else:
    print("循环正常完成")
```

在这个示例中，循环会正常完成，因为没有任何一个元素使得 `i == 10` 为 `True`，所以 `break` 语句不会被执行，`else` 块的内容会被打印出来。

如果我们修改 `if` 语句的条件使得 `break` 语句被执行，那么 `else` 块的内容就不会被打印出来：

```Python
for i in range(5):
    if i == 3:
        break
else:
    print("循环正常完成")
```

在这个示例中，当 `i` 等于 3 时，`break` 语句就会被执行，所以循环没有正常完成，`else` 块的内容不会被打印出来。

同样的，`else` 也可以与 `while` 循环一起使用，当 `while` 循环的条件变为 `False` 时，`else` 块的内容会被执行。

```python
i = 0
while i < 5:
    if i == 3:
        break
    i += 1
else:
    print("循环正常完成")
```

在这个示例中，当 `i` 等于 3 时，`break` 语句就会被执行，所以循环没有正常完成，`else` 块的内容不会被打印出来。

## 异常语句

### try、except、finally

```mermaid
graph TD
    A(开始)
    B[try 块]
    C[except 块1]
    D[except 块2]
    E[else 块]
    F[finally 块]
    G(结束)
    A --> B
    B -- 异常1 --> C
    B -- 异常2 --> D
    B -- 无异常 --> E
    C --> F
    D --> F
    E --> F
    F --> G

```

1. **确定需要的异常处理结构**：在开始编写异常处理结构时，首先确定你需要 `try`, `except`, `else` 和/或 `finally` 语句块。要记住的是，`except` 和 `finally` 块至少需要一个，否则 `try` 将失去其意义。
2. **编写 `try` 语句块**：将可能抛出异常的代码放入 `try` 块。如果在 `try` 块中发生异常，Python 将停止执行 `try` 块的其余部分，并转到 `except` 块。
3. **编写 `except` 语句块**：为每种可能抛出的异常类型编写一个 `except` 块。Python 会按照它们在代码中出现的顺序来检查这些 `except` 块。如果匹配到异常，Python 将执行相应的 `except` 块并停止查找。
4. **处理多个异常**：你可以将多个异常类型放入一个元组中，然后使用一个 `except` 块来处理它们。例如：`except (TypeError, ValueError):`。
5. **处理所有异常**：如果 `except` 块后面没有指定异常类型，那么这个 `except` 块将处理所有异常。你可以通过 `logging` 或 `sys` 模块获取异常的详细信息。
6. **重新抛出异常**：如果你在 `except` 块中捕获了一个异常，然后想要再次抛出它，你可以使用 `raise` 语句而不需要附加任何参数或信息。
7. **编写 `else` 语句块**：`else` 块中的代码只有在 `try` 块没有发生任何异常时才会被执行。
8. **编写 `finally` 语句块**：无论是否发生异常，`finally` 块中的代码总是会被执行。这对于清理（例如关闭文件或网络连接）非常有用。
9. **重构代码**：考虑使用 `with` 语句或 `getattr()` 方法等内置的异常处理语句，而不是 `try/except`。此外，如果可能，尽量避免在同一个 `except` 块中捕获和抛出相同的异常。最后，除非你确定需要处理所有可能的异常，否则不应该捕获所有异常，因为这可能会隐藏严重的问题。

```python
# 示例
try:
    # 这里可能会抛出异常的代码
    do_something()
except SomeException as e:
    # 当捕获到SomeException时的处理代码
    handle_exception(e)

# 实例
def div(a, b):
    try:
        print(a / b)
    except ZeroDivisionError:
        print("错误：b 不应为 0 !!")
    except Exception as e:
        print("意外错误：{}".format(e))
    else:
        print('只有当一切正常时，才会运行 else')
    finally:
        print('始终运行 finally 块。')

# 测试
div(2, 0)
div(2, '错误的类型')
div(1, 2)


# 在一行中捕获多个异常
try:
    print(a / b)
except (ZeroDivisionError, TypeError) as e:
    print(e)


# 当存在 finally 时，except 是可选的
try:
    open(database)
finally:
    close(database)

# 捕获所有错误并记录下来
try:
    do_work()
except:    
    # 从 logging 模块获取详细信息
    logging.exception('捕获到异常!')
    
    # 从 sys.exc_info() 方法获取详细信息
    error_type, error_value, trace_back = sys.exc_info()
    print(error_value)
    raise
```

### With

Python 的 with 语句支持通过上下文管理器所定义的运行时上下文这一概念。

`with` 语句是一种处理上下文管理器的语句，上下文管理器通常包含 `__enter__` 和 `__exit__` 这两个方法。在 `with` 语句的代码块被执行前，会首先执行 `__enter__` 方法，在执行完毕后，会调用 `__exit__` 方法。这在你需要管理资源，如文件，网络连接或锁定等情况非常有用，因为它可以**保证在任何情况下都会执行必要的清理操作。**

```python
# 在这里，文件已经被关闭，无需再次手动关闭
with open("file.txt", "r") as file:
    for line in file:
        print(line)
```

```python
# 基本思想是 with 所求值的对象必须有一个 enter() 方法，一个 exit() 方法。
# 紧跟 with 后面的语句被求值后，返回对象的 enter() 方法被调用，并将返回值赋值给 as 后面的变量。
# 当 with 的代码块全部被执行完之后，将调用前面返回对象的 exit() 方法。

class ManagedFile:
    def __init__(self, filename):
        self.filename = filename

    def __enter__(self):
        self.file = open(self.filename, 'r')
        return self.file

    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()

# 使用自定义的上下文管理器
with ManagedFile("file.txt") as file:
    print(file.read())
```

### Raise

`raise` 语句用于引发特定的异常。你可以定义异常类型并附加一个错误消息：

```python
raise ValueError("这是一个无效的值！")
```

如果你在 `except` 块中使用 `raise` 语句，而不提供任何参数，它将默认重新引发最近的异常。

```python
try:
    print(5/0)
except ZeroDivisionError as e:
    print("发生了一个错误！")
    raise  # 重新引发最近的异常
```

## 其他语句

### Assert

`assert` 语句用于断言某个条件为真，如果条件为假，则会抛出 `AssertionError` 异常。它常常用于调试代码，确认代码的某些方面满足预期，例如：

```python
x = 1
assert x == 1  # 条件为真，没有问题

# 条件为假，抛出 AssertionError，并附带错误信息
assert x == 2, "x should be 2 but is actually " + str(x)  
```

*注意，`assert` 语句在优化模式下（使用 `-O` 参数启动 Python 时）会被全局禁用。*

### Pass

`pass` 语句是 Python 中的空语句，用于在需要语句的地方保持语法的完整性，但是**实际上不做任何事情**。通常，我们使用它作为未完成代码的占位符：

```python
def my_function():
    pass  # TODO: implement this function

class MyEmptyClass:
    pass
```

### Return

`return` 语句用于从函数返回一个值。所有函数都会返回一个值：如果函数执行到结尾而没有遇到 `return` 语句，它将返回特殊值 `None`：

```python
def add(a, b):
    return a + b

print(add(1, 2))  # 输出：3
```