Python错误和异常详解

1. 概述

在Python编程中，程序执行过程中可能会遇到两种主要问题：错误（Error）和异常（Exception）。理解和正确处理这些问题对于编写健壮、可靠的程序至关重要。

1.1 错误与异常的区别

• 错误：通常指程序中的语法错误或逻辑错误，导致程序无法正常编译或执行。错误一旦发生，程序将立即终止。

  • 语法错误：不符合Python语法规则的错误
  • 逻辑错误：程序能运行但结果不符合预期

• 异常：程序执行过程中出现的意外情况，如文件不存在、除以零等。异常可以被捕获和处理，程序可以从异常中恢复并继续执行。

2. 语法错误

语法错误（SyntaxError）是最常见的错误类型，通常是由于不符合Python语法规则导致的。

2.1 常见语法错误

# 缺少冒号
if 5 > 3
    print("5大于3")

# 括号不匹配
print("Hello, World!" 

# 缩进错误（Python最常见的语法错误）
def func():
print("Hello")  # 缺少缩进

# 错误的变量名
123abc = "hello"  # 变量名不能以数字开头

# 错误的关键字使用
class = "Python"  # class是关键字，不能用作变量名

2.2 语法错误的处理

语法错误必须在程序运行前修复，Python解释器会指出错误的位置和原因：

  File "example.py", line 2
    if 5 > 3
           ^
SyntaxError: invalid syntax

3. 内置异常类型

Python定义了大量内置异常类，用于表示不同类型的异常情况。这些异常类都继承自BaseException类，形成了一个层次结构。

3.1 异常层次结构

BaseException
├── SystemExit
├── KeyboardInterrupt
├── GeneratorExit
└── Exception
    ├── StopIteration
    ├── StopAsyncIteration
    ├── ArithmeticError
    │   ├── FloatingPointError
    │   ├── OverflowError
    │   └── ZeroDivisionError
    ├── AssertionError
    ├── AttributeError
    ├── BufferError
    ├── EOFError
    ├── ImportError
    │   └── ModuleNotFoundError
    ├── LookupError
    │   ├── IndexError
    │   └── KeyError
    ├── MemoryError
    ├── NameError
    │   └── UnboundLocalError
    ├── OSError
    │   ├── BlockingIOError
    │   ├── ChildProcessError
    │   ├── ConnectionError
    │   │   ├── BrokenPipeError
    │   │   ├── ConnectionAbortedError
    │   │   ├── ConnectionRefusedError
    │   │   └── ConnectionResetError
    │   ├── FileExistsError
    │   ├── FileNotFoundError
    │   ├── InterruptedError
    │   ├── IsADirectoryError
    │   ├── NotADirectoryError
    │   ├── PermissionError
    │   ├── ProcessLookupError
    │   └── TimeoutError
    ├── ReferenceError
    ├── RuntimeError
    │   └── RecursionError
    ├── SyntaxError
    │   └── IndentationError
    │       └── TabError
    ├── SystemError
    ├── TypeError
    ├── ValueError
    │   └── UnicodeError
    │       ├── UnicodeDecodeError
    │       ├── UnicodeEncodeError
    │       └── UnicodeTranslateError
    └── Warning
        ├── DeprecationWarning
        ├── PendingDeprecationWarning
        ├── RuntimeWarning
        ├── SyntaxWarning
        ├── UserWarning
        ├── FutureWarning
        ├── ImportWarning
        ├── UnicodeWarning
        ├── BytesWarning
        └── ResourceWarning

3.2 常见内置异常

3.3 异常示例

# ZeroDivisionError
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"错误: {e}")

# TypeError
try:
    result = "5" + 5
except TypeError as e:
    print(f"错误: {e}")

# ValueError
try:
    number = int("abc")
except ValueError as e:
    print(f"错误: {e}")

# NameError
try:
    print(undefined_variable)
except NameError as e:
    print(f"错误: {e}")

# IndexError
try:
    my_list = [1, 2, 3]
    print(my_list[5])
except IndexError as e:
    print(f"错误: {e}")

# KeyError
try:
    my_dict = {"name": "Zhang San", "age": 30}
    print(my_dict["city"])
except KeyError as e:
    print(f"错误: {e}")

# FileNotFoundError
try:
    with open("nonexistent.txt", "r") as f:
        content = f.read()
except FileNotFoundError as e:
    print(f"错误: {e}")

4. 异常处理机制

Python使用try-except语句来捕获和处理异常，基本语法如下：

try:
    # 可能引发异常的代码块
except ExceptionType1:
    # 处理ExceptionType1类型的异常
except ExceptionType2:
    # 处理ExceptionType2类型的异常
except:
    # 处理所有其他类型的异常
else:
    # 没有发生异常时执行的代码块
finally:
    # 无论是否发生异常都会执行的代码块

4.1 try-except基本用法

# 捕获特定类型的异常
try:
    num1 = int(input("请输入第一个数字: "))
    num2 = int(input("请输入第二个数字: "))
    result = num1 / num2
    print(f"结果: {result}")
except ZeroDivisionError:
    print("错误: 除数不能为零!")
except ValueError:
    print("错误: 请输入有效的整数!")

4.2 捕获多个异常

# 方法1：分别捕获
try:
    num1 = int(input("请输入第一个数字: "))
    num2 = int(input("请输入第二个数字: "))
    result = num1 / num2
    print(f"结果: {result}")
except ZeroDivisionError:
    print("错误: 除数不能为零!")
except ValueError:
    print("错误: 请输入有效的整数!")

# 方法2：捕获多个异常类型
try:
    num1 = int(input("请输入第一个数字: "))
    num2 = int(input("请输入第二个数字: "))
    result = num1 / num2
    print(f"结果: {result}")
except (ZeroDivisionError, ValueError) as e:
    print(f"错误: {e}")

4.3 捕获所有异常

try:
    # 可能引发任何异常的代码
    num1 = int(input("请输入第一个数字: "))
    num2 = int(input("请输入第二个数字: "))
    result = num1 / num2
    print(f"结果: {result}")
except Exception as e:
    # 捕获所有Exception类型的异常
    print(f"发生异常: {e}")
except:
    # 捕获所有异常（包括非Exception类型）
    print("发生未知异常!")

4.4 else子句

else子句中的代码在try块没有发生异常时执行：

try:
    num1 = int(input("请输入第一个数字: "))
    num2 = int(input("请输入第二个数字: "))
    result = num1 / num2
except (ZeroDivisionError, ValueError) as e:
    print(f"错误: {e}")
else:
    # 只有在没有异常时才执行
    print(f"结果: {result}")
    print("计算成功!")

4.5 finally子句

finally子句中的代码无论是否发生异常都会执行，常用于资源清理：

try:
    file = open("example.txt", "r")
    content = file.read()
    print(content)
except FileNotFoundError:
    print("错误: 文件不存在!")
finally:
    # 无论是否发生异常，都会关闭文件
    if 'file' in locals() and not file.closed:
        file.close()
        print("文件已关闭")

# 更简洁的方式（使用with语句）
try:
    with open("example.txt", "r") as file:
        content = file.read()
        print(content)
except FileNotFoundError:
    print("错误: 文件不存在!")
# with语句自动关闭文件，无需finally

5. 抛出异常

使用raise语句可以主动抛出异常：

5.1 基本用法

def divide(a, b):
    if b == 0:
        raise ZeroDivisionError("除数不能为零!")
    return a / b

try:
    result = divide(10, 0)
except ZeroDivisionError as e:
    print(f"捕获到异常: {e}")

5.2 重新抛出异常

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"记录错误: {e}")
    raise  # 重新抛出相同的异常

5.3 抛出不同的异常

try:
    num = int(input("请输入一个正数: "))
    if num <= 0:
        raise ValueError("必须输入正数!")
    print(f"您输入的正数是: {num}")
except ValueError as e:
    print(f"错误: {e}")

6. 自定义异常

可以通过继承Exception类或其子类来创建自定义异常：

6.1 基本自定义异常

class MyCustomError(Exception):
    """自定义异常类"""
    pass

def func(value):
    if value < 0:
        raise MyCustomError("值不能为负数!")
    return value * 2

try:
    result = func(-5)
except MyCustomError as e:
    print(f"捕获到自定义异常: {e}")

6.2 带参数的自定义异常

class InvalidAgeError(Exception):
    """年龄无效异常"""
    def __init__(self, age, message="年龄必须在0到120之间"):
        self.age = age
        self.message = message
        super().__init__(self.message)
    
    def __str__(self):
        return f"{self.age} -> {self.message}"

def check_age(age):
    if age < 0 or age > 120:
        raise InvalidAgeError(age)
    return True

try:
    check_age(150)
except InvalidAgeError as e:
    print(f"无效年龄: {e}")

6.3 异常层次结构

# 基础异常类
class BaseError(Exception):
    pass

# 特定异常类
class InputError(BaseError):
    pass

class ValidationError(BaseError):
    pass

class RangeError(ValidationError):
    pass

def func(value):
    if not isinstance(value, int):
        raise InputError("必须输入整数!")
    if value < 0 or value > 100:
        raise RangeError("值必须在0到100之间!")
    return value

try:
    result = func("abc")
except InputError as e:
    print(f"输入错误: {e}")
except RangeError as e:
    print(f"范围错误: {e}")
except BaseError as e:
    print(f"基础错误: {e}")

7. 异常链

在Python 3中，可以使用raise ... from ...语法创建异常链，保留原始异常的上下文信息：

7.1 基本用法

try:
    with open("nonexistent.txt", "r") as f:
        content = f.read()
except FileNotFoundError as e:
    # 创建异常链
    raise RuntimeError("文件处理失败") from e

输出：

Traceback (most recent call last):
  File "example.py", line 3, in <module>
    with open("nonexistent.txt", "r") as f:
FileNotFoundError: [Errno 2] No such file or directory: 'nonexistent.txt'

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "example.py", line 6, in <module>
    raise RuntimeError("文件处理失败") from e
RuntimeError: 文件处理失败

7.2 隐式异常链

当在except块中抛出新异常时，如果没有使用from关键字，Python会自动创建隐式异常链：

try:
    with open("nonexistent.txt", "r") as f:
        content = f.read()
except FileNotFoundError:
    # 隐式异常链
    raise RuntimeError("文件处理失败")

输出：

Traceback (most recent call last):
  File "example.py", line 3, in <module>
    with open("nonexistent.txt", "r") as f:
FileNotFoundError: [Errno 2] No such file or directory: 'nonexistent.txt'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "example.py", line 6, in <module>
    raise RuntimeError("文件处理失败")
RuntimeError: 文件处理失败

7.3 抑制异常链

使用raise ... from None可以抑制异常链：

try:
    with open("nonexistent.txt", "r") as f:
        content = f.read()
except FileNotFoundError as e:
    # 抑制异常链
    raise RuntimeError("文件处理失败") from None

输出：

Traceback (most recent call last):
  File "example.py", line 6, in <module>
    raise RuntimeError("文件处理失败") from None
RuntimeError: 文件处理失败

8. 断言

断言（Assertion）是一种调试辅助工具，使用assert语句来检查条件是否为真，如果条件为假，会引发AssertionError异常：

8.1 基本用法

def divide(a, b):
    assert b != 0, "除数不能为零"
    return a / b

try:
    result = divide(10, 0)
except AssertionError as e:
    print(f"断言失败: {e}")

8.2 禁用断言

在运行Python脚本时，可以使用-O选项（优化模式）禁用断言：

python -O example.py  # 断言将被忽略

8.3 断言与异常的区别

• 断言：用于调试，检查程序中的逻辑错误，生产环境中可以禁用
• 异常：用于处理运行时错误，生产环境中必须处理

9. 调试技术

9.1 print()调试

最简单的调试方法是使用print()函数输出变量值：

def func(value):
    print(f"当前值: {value}")
    # 其他代码
    return result

9.2 logging模块

使用logging模块可以更灵活地记录调试信息：

import logging

# 配置日志
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

def divide(a, b):
    logging.debug(f"a={a}, b={b}")
    try:
        result = a / b
        logging.debug(f"结果: {result}")
        return result
    except ZeroDivisionError as e:
        logging.error(f"错误: {e}")
        raise

divide(10, 2)
divide(10, 0)

9.3 pdb调试器

Python的内置调试器pdb提供了更强大的调试功能：

import pdb

def divide(a, b):
    pdb.set_trace()  # 设置断点
    return a / b

result = divide(10, 2)
print(f"结果: {result}")

在pdb调试器中，可以使用以下命令：

• n：执行下一行
• s：进入函数
• c：继续执行直到下一个断点
• l：列出当前代码
• p <变量名>：打印变量值
• q：退出调试器

9.4 现代IDE调试

大多数现代Python IDE（如PyCharm、VS Code）都提供了图形化的调试界面，支持断点设置、单步执行、变量查看等功能。

10. 最佳实践

10.1 异常处理的原则

1. 只捕获特定的异常，避免使用except:捕获所有异常

   # 错误示例
   try:
       # 代码
   except:
       pass  # 捕获所有异常，包括KeyboardInterrupt等
   
   # 正确示例
   try:
       # 代码
   except (ValueError, TypeError) as e:
       # 处理特定异常
       pass
   

2. 保持try块尽可能小，只包含可能引发异常的代码

   # 错误示例
   try:
       num1 = int(input("请输入第一个数字: "))
       num2 = int(input("请输入第二个数字: "))
       result = num1 / num2
       print(f"结果: {result}")
   except Exception as e:
       print(f"错误: {e}")
   
   # 正确示例
   num1 = int(input("请输入第一个数字: "))
   num2 = int(input("请输入第二个数字: "))
   try:
       result = num1 / num2
   except ZeroDivisionError:
       print("错误: 除数不能为零!")
   else:
       print(f"结果: {result}")
   

3. 提供有意义的错误信息

   # 错误示例
   try:
       file = open(filename, "r")
   except Exception:
       print("出错了!")
   
   # 正确示例
   try:
       file = open(filename, "r")
   except FileNotFoundError:
       print(f"错误: 文件 '{filename}' 不存在!")
   except PermissionError:
       print(f"错误: 没有权限读取文件 '{filename}'!")
   

4. 不要忽略异常

   # 错误示例
   try:
       # 可能引发异常的代码
   except Exception:
       pass  # 忽略异常，隐藏问题
   
   # 正确示例
   try:
       # 可能引发异常的代码
   except Exception as e:
       # 记录异常并处理
       logging.error(f"发生错误: {e}")
   

5. 使用finally清理资源

   # 正确示例
   file = None
   try:
       file = open("example.txt", "r")
       content = file.read()
   except FileNotFoundError:
       print("文件不存在!")
   finally:
       if file:
           file.close()
   
   # 更好的方式
   with open("example.txt", "r") as file:
       content = file.read()
   

10.2 自定义异常的最佳实践

1. 继承自Exception或其子类

   # 正确示例
   class MyError(Exception):
       pass
   
   # 更好的方式（继承特定异常类）
   class ValidationError(ValueError):
       pass
   

2. 提供有意义的异常名称

   # 错误示例
   class Error(Exception):
       pass
   
   # 正确示例
   class DatabaseConnectionError(Exception):
       pass
   

3. 添加有用的属性和方法

   class APIError(Exception):
       def __init__(self, status_code, message):
           self.status_code = status_code
           self.message = message
           super().__init__(f"{status_code}: {message}")
   

10.3 异常处理的常见模式

1. 重试模式

   import time
   
   def retry(func, max_retries=3, delay=1):
       for i in range(max_retries):
           try:
               return func()
           except Exception as e:
               print(f"尝试 {i+1}/{max_retries} 失败: {e}")
               time.sleep(delay)
       raise Exception("超过最大重试次数")
   
   # 使用重试装饰器
   @retry
   def connect_to_server():
       # 连接服务器的代码
       pass
   

2. 事务模式

   def transaction(func):
       def wrapper(*args, **kwargs):
           try:
               # 开始事务
               start_transaction()
               result = func(*args, **kwargs)
               # 提交事务
               commit_transaction()
               return result
           except Exception as e:
               # 回滚事务
               rollback_transaction()
               raise
       return wrapper
   
   @transaction
   def update_data():
       # 更新数据库的代码
       pass
   

3. 上下文管理器模式

   import contextlib
   
   @contextlib.contextmanager
   def database_connection():
       connection = None
       try:
           connection = create_connection()
           yield connection
       except Exception as e:
           print(f"数据库操作失败: {e}")
           raise
       finally:
           if connection:
               connection.close()
   
   # 使用上下文管理器
   with database_connection() as conn:
       # 使用连接执行操作
       pass
   

11. 总结

错误和异常是Python编程中不可避免的部分，正确处理它们对于编写健壮、可靠的程序至关重要。本文详细介绍了：

1. 错误与异常的区别：语法错误、逻辑错误和异常
2. 内置异常类型：Python提供的丰富异常类层次结构
3. 异常处理机制：try-except-else-finally语句的使用
4. 抛出异常：使用raise语句主动抛出异常
5. 自定义异常：创建和使用自己的异常类
6. 异常链：Python 3中的异常链接功能
7. 断言：用于调试的断言语句
8. 调试技术：各种调试方法和工具
9. 最佳实践：异常处理的原则和常见模式

通过学习和掌握这些内容，可以编写出更加健壮、可维护的Python程序，更好地处理各种运行时错误和异常情况。

发布网站：荣殿教程（zhangrongdian.com） 作者：张荣殿 发布日期：2026-01-19