异常的作用#

• 保证数据、逻辑的正确性，避免程序执行混乱
• 在开发阶段，尽量发现更多的问题，尽早解决问题，保障程序正常执行

常见异常类型#

异常不是坏东西，而是编写健壮程序的重要工具

语法格式#

1
try:
2
    可能出现异常的业务代码1
3
    可能出现异常的业务代码2
4
    ...
5
except [异常类型 as 变量名]:
6
    出现异常时的预案
7
[finally:
8
    不管是否出现异常，都会执行的代码]

示例1：基础用法#

1
try:
2
    print("=" * 30)
3
    print(my_name)
4
    print("=" * 30)
5
except NameError as e:
6
    print("程序运行报错，错误信息：", e)
7
finally:
8
    print("释放资源 ~")

示例2：捕获多种异常#

1
try:
2
    print("=" * 30)
3
    # print(my_name)        # NameError
4
    # print(1 / 0)          # ZeroDivisionError
5
    # print("ABC"[10])      # IndexError
6
    print("ABC".hello)      # AttributeError
7
    print("=" * 30)
8
except NameError as e:  # 捕获的是 NameError 类型的异常
9
    print("名字不存在，请检查变量或函数名字，异常信息：", e)
10
except ZeroDivisionError as e:
11
    print("0不能做被除数，异常信息：", e)
12
except IndexError as e:
13
    print("索引错误，异常信息：", e)
14
except Exception as e:  # 捕获所有的异常
15
    print("程序运行出错了，请联系管理员，错误信息：", e)
16
finally:  # 无论程序是否正常运行，finally代码块中的代码都会运行
17
    print("资源释放 ~")

示例#

1
def fun1():
2
    print("fun1 ... running ...")
3
    fun2()
4

5
def fun2():
6
    print("fun2 ... running ...")
7
    fun3()
8

9
def fun3():
10
    print("fun3 ... running ...")
11
    print(my_color)  # 异常发生在这里
12

13
if __name__ == '__main__':
14
    fun1()

异常传递流程#

1
__main__ (fun1调用)
2
    ↓
3
fun1() (fun2调用)
4
    ↓
5
fun2() (fun3调用)
6
    ↓
7
fun3() (print(my_color) 报错)
8
    ↑
9
    │ 异常向上传递
10
    │
11
Exception被捕获或程序崩溃

异常传递说明#

• 异常会从发生错误的地方，沿着函数调用链向上传递
• 如果每一层都没有捕获异常，最终会导致程序崩溃
• 如果某一层捕获了异常，程序可以继续执行

一、知识回顾（读完直接做下面的实践题）#

1. 异常（也叫 Bug）是程序运行过程中出现的错误，它会中断程序的正常执行流程；异常的作用是保证数据、逻辑的正确性，并在开发阶段尽量发现问题
2. 常见异常类型：变量或函数名不存在 NameError、类型不匹配 TypeError、索引超出范围 IndexError、字典的键不存在 KeyError、值不合法 ValueError、访问不存在的属性（如 "ABC".hello）AttributeError
3. 处理异常有两种方案：不做处理（整个程序因为一个 Bug 中断执行）和捕获异常（按预案处理，程序继续执行）
4. 语法结构：可能出错的业务代码写在 try 块里；出现异常时的预案写在 except 块里；不管是否出现异常都要执行的代码写在 finally 块里
5. 捕获异常并拿到错误信息：except 异常类型 as 变量名:（变量名如 e）
6. 要为不同异常写不同预案时，可以写多个 except 分支；兜底捕获所有异常写 except Exception as e:，它要放在最后面
7. finally 是可有可无的；无论程序正常执行（没出异常）还是出现异常，它里面的代码都会执行，常用来释放资源
8. 异常传递：异常会从发生错误的地方沿着函数调用链向上传递；如果每一层都没捕获，最终会程序崩溃；如果某一层捕获了，程序可以继续执行
9. 笔记示例里的捕获顺序是 NameError → ZeroDivisionError → IndexError → Exception，说明：越具体的异常类型要写在越前面，兜底的写在最后

二、裸写题#

• 2-1 基础捕获 写一段代码：打印分隔线 → 打印一个不存在的变量 → 再打印分隔线。用捕获结构处理这个”名字不存在”的错误，打印”程序运行报错，错误信息：xxx”，并加上收尾块打印”释放资源 ~“。运行后观察：报错那行后面的分隔线有没有打印出来？

  提示（先自己想，实在想不出再点开）

  一级 · 思路：可能出错的代码放一个块，出错的预案放另一个块，收尾代码再放一个块 二级 · 方法：try / except 异常类型 as e / finally 三级 · 骨架：except ____ as e: / finally:（“名字不存在”的异常类型是 NameError）

  参考答案（做完再点开）

  1
  # 2-1
  2
  try:
  3
      print("=" * 30)
  4
      print(my_name)          # 变量不存在 → NameError
  5
      print("=" * 30)         # 这行不会执行（出错后直接跳到 except）
  6
  except NameError as e:
  7
      print("程序运行报错，错误信息：", e)
  8
  finally:
  9
      print("释放资源 ~")

• 2-2 一份代码里捕获多种异常

  1. 写一段业务代码，依次可能触发三种错误：取列表的第 10 个元素（列表只有 3 个元素）、取字典里不存在的键、用一个数除以 0
  2. 每种错误写一个单独的捕获分支，分别打印中文提示 + 错误信息
  3. 最后加一个兜底分支捕获其它所有异常，打印”程序运行出错了，请联系管理员，错误信息：xxx”
  4. 加上收尾块打印”资源释放 ~”
  5. 运行后想一想：三个错误会依次都触发吗？第一个错误发生后，后面的代码还会不会往下走？
  提示（先自己想，实在想不出再点开）

  一级 · 思路：一个 try 可以配多个 except，按异常类型从上往下匹配，匹配上就跳出去，不会回到出错的那一行继续 二级 · 方法：except IndexError as e / except KeyError as e / except ZeroDivisionError as e / except Exception as e 三级 · 骨架：except ____ as e: # 索引错误 / except ____ as e: # 兜底，放最后

  参考答案（做完再点开）

  1
  # 2-2
  2
  try:
  3
      print("=" * 30)
  4
      print([1, 2, 3][10])          # 索引越界 → IndexError
  5
      print({"a": 1}["b"])          # 键不存在 → KeyError
  6
      print(1 / 0)                  # 除零 → ZeroDivisionError
  7
      print("=" * 30)
  8
  except IndexError as e:
  9
      print("索引错误，请检查下标是否越界，异常信息：", e)
  10
  except KeyError as e:
  11
      print("键不存在，请检查字典的键，异常信息：", e)
  12
  except ZeroDivisionError as e:
  13
      print("0 不能做除数，异常信息：", e)
  14
  except Exception as e:
  15
      print("程序运行出错了，请联系管理员，错误信息：", e)
  16
  finally:
  17
      print("资源释放 ~")
  18
  # 实际只会走到第一个出错的那行：先报 IndexError，剩下两行不会执行

  显示更多显示更少

• 2-3 异常的传递

  1. 写三个函数 fun1() → 调用 fun2() → 调用 fun3()，每个函数进来先打印一行 xxx running ...
  2. 在 fun3() 里访问一个不存在的变量，制造异常
  3. 先在主程序里直接调用 fun1()，运行并观察报错信息里显示的调用链顺序
  4. 再把调用放进捕获结构里（在最外层捕获），打印”在最外层捕获到异常：xxx”，观察程序不再崩溃
  提示（先自己想，实在想不出再点开）

  一级 · 思路：底层函数不处理，异常就沿着”谁调用了我”一层层往上报，谁接住谁负责 二级 · 方法：if __name__ == "__main__": 里写 try: fun1() + except NameError as e 三级 · 骨架：def fun3(): print(my_color) 制造异常；报错信息最后一行就是异常类型和说明

  参考答案（做完再点开）

  1
  # 2-3
  2
  def fun1():
  3
      print("fun1 ... running ...")
  4
      fun2()
  5
  
  6
  def fun2():
  7
      print("fun2 ... running ...")
  8
      fun3()
  9
  
  10
  def fun3():
  11
      print("fun3 ... running ...")
  12
      print(my_color)          # 异常发生在这里
  13
  
  14
  if __name__ == "__main__":
  15
      try:
  16
          fun1()
  17
      except NameError as e:
  18
          print("在最外层捕获到异常：", e)
  19
      finally:
  20
          print("资源释放 ~")
  21
  # 不捕获时，报错信息里的调用链是：<module> → fun1 → fun2 → fun3

  显示更多显示更少

三、综合题#

• 3-1 批量数据体检 把异常类型、多分支捕获、兜底和收尾块串成一个能用的小工具：

  1. 准备一个列表，放 5 条”待处理数据”：2 条正常的数字字符串（如 "88"、"92"）、1 条不能转成数字的字符串（如 "abc"）、1 条空字符串、1 个数字 0
  2. 循环处理每条数据：先把它转成整数，再用 100 除以它，成功就打印算式和结果
  3. 用捕获结构分别处理”转不成数字”和”除数为 0”两类错误，每条错误打印提示后继续处理下一条（不要让程序崩掉）
  4. 统计成功条数，循环结束后打印”处理完成，成功 N 条”
  5. 加一个收尾块，每处理一条就打印一行分隔线，观察它是不是成功失败都会执行
  提示（先自己想，实在想不出再点开）

  一级 · 思路：把 try 写在循环里面，一条数据出错只影响这一条；转整数和做除法分别会抛不同的异常 二级 · 方法：int(文本) 抛 ValueError；除以 0 抛 ZeroDivisionError；finally 放在 except 之后 三级 · 骨架：for item in raw_data: → try: → num = int(item) → result = 100 / num；except ____ as e: / except ____ as e: / finally: print("-" * 30)

  参考答案（做完再点开）

  1
  raw_data = ["88", "abc", "0", "", "92"]
  2
  
  3
  success = 0
  4
  for item in raw_data:
  5
      try:
  6
          num = int(item)             # "abc"、"" 转不了 → ValueError
  7
          result = 100 / num          # 除数为 0 → ZeroDivisionError
  8
          print(f"「{item}」通过：100 ÷ {num} = {result:.2f}")
  9
          success += 1
  10
      except ValueError as e:
  11
          print(f"「{item}」不能转成数字，跳过。异常信息：{e}")
  12
      except ZeroDivisionError as e:
  13
          print(f"「{item}」是 0，不能做除数，跳过。异常信息：{e}")
  14
      except Exception as e:
  15
          print(f"「{item}」出现其它错误，跳过。异常信息：{e}")
  16
      finally:
  17
          print("-" * 30)             # 每条数据成功失败都会执行
  18
  
  19
  print(f"处理完成，成功 {success} 条")
  20
  # 运行结果：88 和 92 通过，abc / 空字符串 / 0 各自被对应分支拦下，最后打印"成功 2 条"

  显示更多显示更少