2025年Python新手入门：异常处理完全指南

# NameError: 访问未定义的变量
try:
    print(undefined_variable)
except NameError as e:
    print(f"发生错误: {e}")

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

# ValueError: 值错误
try:
    num = int("abc")
except ValueError as e:
    print(f"发生错误: {e}")

# ZeroDivisionError: 除零错误
try:
    result = 10 / 0
except ZeroDivisionError 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": "Alice", "age": 25}
    print(my_dict["city"])
except KeyError as e:
    print(f"发生错误: {e}")

try:
    # 可能会引发异常的代码
    risky_operation()
except ExceptionType:
    # 当发生指定类型的异常时执行的代码
    handle_exception()

try:
    # 尝试将用户输入转换为整数
    num = int(input("请输入一个整数: "))
    result = 10 / num
    print(f"10 除以 {num} 的结果是: {result}")
except ValueError:
    # 处理值错误（用户输入的不是整数）
    print("错误: 请输入有效的整数!")
except ZeroDivisionError:
    # 处理除零错误
    print("错误: 除数不能为零!")

# 方法1: 在一个except语句中捕获多个异常类型
try:
    # 可能会引发多种异常的代码
    num = int(input("请输入一个整数: "))
    result = 10 / num
    my_list = [1, 2, 3]
    print(my_list[num])
except (ValueError, ZeroDivisionError, IndexError) as e:
    # 处理多种异常，使用as关键字获取异常对象
    print(f"发生错误: {e}")

# 方法2: 使用多个except语句处理不同类型的异常
try:
    # 可能会引发多种异常的代码
    num = int(input("请输入一个整数: "))
    result = 10 / num
    my_list = [1, 2, 3]
    print(my_list[num])
except ValueError as e:
    print(f"值错误: {e}")
except ZeroDivisionError as e:
    print(f"除零错误: {e}")
except IndexError as e:
    print(f"索引错误: {e}")

try:
    # 可能会引发任何异常的代码
    perform_complex_operation()
except Exception as e:
    # 捕获所有异常
    print(f"发生未预期的错误: {e}")
    # 可以选择记录错误日志
    import logging
    logging.error(f"未预期的错误: {e}")

try:
    # 尝试将用户输入转换为整数
    num = int(input("请输入一个整数: "))
except ValueError:
    # 处理值错误
    print("错误: 请输入有效的整数!")
else:
    # 当try块中没有引发异常时执行
    print(f"你输入的整数是: {num}")
    # 可以在这里安全地使用num变量，因为它已经被正确初始化
    result = num * 2
    print(f"这个整数的两倍是: {result}")

try:
    # 尝试打开文件
    file = open("example.txt", "r")
    # 尝试读取文件内容
    content = file.read()
    print(content)
except FileNotFoundError:
    # 处理文件不存在的错误
    print("错误: 文件不存在!")
except IOError:
    # 处理I/O错误
    print("错误: 读取文件时发生I/O错误!")
finally:
    # 无论是否发生异常，都会执行这里的代码
    # 确保文件被关闭
    try:
        file.close()
        print("文件已关闭")
    except NameError:
        # 如果file变量从未被定义（例如，当文件不存在时）
        print("没有需要关闭的文件")

try:
    # 可能会引发异常的代码
    risky_operation()
except ExceptionType1:
    # 处理特定类型的异常
    handle_exception_type1()
except ExceptionType2:
    # 处理另一种特定类型的异常
    handle_exception_type2()
else:
    # 当try块中没有引发异常时执行
    handle_success()
finally:
    # 无论是否发生异常，都会执行这里的代码
    perform_cleanup()

BaseException
├── Exception
│   ├── ArithmeticError
│   │   ├── ZeroDivisionError
│   │   ├── OverflowError
│   │   └── FloatingPointError
│   ├── LookupError
│   │   ├── IndexError
│   │   └── KeyError
│   ├── SyntaxError
│   ├── TypeError
│   ├── ValueError
│   └── ...
├── SystemExit
├── KeyboardInterrupt
└── GeneratorExit

try:
    # 尝试执行可能会引发多种算术异常的代码
    result1 = 10 / 0  # 引发ZeroDivisionError
    result2 = int("abc")  # 引发ValueError
except ArithmeticError as e:
    # 捕获所有算术异常（包括ZeroDivisionError）
    print(f"算术错误: {e}")
except ValueError as e:
    # 捕获值错误
    print(f"值错误: {e}")

try:
    # 执行可能会引发多种异常的操作
    process_data()
except (ValueError, TypeError) as e:
    # 处理数据类型相关的异常
    print(f"数据错误: {e}")
except (IOError, FileNotFoundError) as e:
    # 处理I/O相关的异常
    print(f"I/O错误: {e}")
except Exception as e:
    # 处理其他所有非系统退出的异常
    print(f"未预期的错误: {e}")

# 创建一个简单的自定义异常类
class CustomError(Exception):
    # 可以添加自定义的初始化方法
    def __init__(self, message):
        super().__init__(message)
        self.message = message

# 使用自定义异常
try:
    # 在某些条件下引发自定义异常
    raise CustomError("这是一个自定义异常")
except CustomError as e:
    # 处理自定义异常
    print(f"捕获到自定义异常: {e}")

# 创建一个基础异常类
class AppException(Exception):
    """应用程序基础异常"""
    pass

# 创建特定领域的异常类
class DataException(AppException):
    """数据处理相关异常"""
    pass

class NetworkException(AppException):
    """网络相关异常"""
    pass

# 创建更具体的异常类
class ValidationError(DataException):
    """数据验证错误"""
    pass

class DatabaseError(DataException):
    """数据库操作错误"""
    pass

class ConnectionError(NetworkException):
    """网络连接错误"""
    pass

# 使用自定义异常层次结构
try:
    # 模拟数据验证失败
    raise ValidationError("数据格式不正确")
except ValidationError as e:
    # 处理特定的验证错误
    print(f"验证错误: {e}")
except DataException as e:
    # 处理一般的数据异常
    print(f"数据异常: {e}")
except AppException as e:
    # 处理一般的应用程序异常
    print(f"应用程序异常: {e}")
except Exception as e:
    # 处理其他所有异常
    print(f"未预期的异常: {e}")

class InsufficientFundsError(Exception):
    """当账户余额不足时引发的异常"""
    def __init__(self, account_number, current_balance, required_amount):
        self.account_number = account_number
        self.current_balance = current_balance
        self.required_amount = required_amount
        message = (f"账户 {account_number} 余额不足: 当前余额为 {current_balance}, "
                 f"需要至少 {required_amount}")
        super().__init__(message)

# 使用自定义异常
def withdraw(account_number, amount):
    # 模拟账户余额
    balances = {"12345": 1000, "67890": 500}
    
    if account_number not in balances:
        raise ValueError(f"账户 {account_number} 不存在")
        
    current_balance = balances[account_number]
    if amount > current_balance:
        raise InsufficientFundsError(account_number, current_balance, amount)
        
    # 执行取款操作
    balances[account_number] -= amount
    return balances[account_number]

# 测试自定义异常
try:
    new_balance = withdraw("12345", 1500)
except InsufficientFundsError as e:
    print(f"取款失败: {e}")
    print(f"账户: {e.account_number}")
    print(f"当前余额: {e.current_balance}")
    print(f"尝试取款金额: {e.required_amount}")
except ValueError as e:
    print(f"取款失败: {e}")
else:
    print(f"取款成功! 新余额: {new_balance}")

def level3():
    # 在最内层函数中引发异常
    print("进入level3")
    raise ValueError("从level3引发的异常")
    print("这行代码不会执行")


def level2():
    # 调用level3，但不捕获异常
    print("进入level2")
    level3()
    print("这行代码不会执行")


def level1():
    # 调用level2，但不捕获异常
    print("进入level1")
    level2()
    print("这行代码不会执行")

# 调用level1，捕获异常
try:
    level1()
except ValueError as e:
    print(f"在顶层捕获到异常: {e}")

进入level1
进入level2
进入level3
在顶层捕获到异常: 从level3引发的异常

# 策略1: 在函数内部捕获异常
def read_file_safe(filename):
    try:
        with open(filename, 'r') as file:
            return file.read()
    except FileNotFoundError:
        print(f"错误: 文件 '{filename}' 不存在")
        return ""
    except IOError:
        print(f"错误: 读取文件 '{filename}' 时发生I/O错误")
        return ""

# 策略2: 让异常向上传递
def read_file_unsafe(filename):
    """读取文件内容
    
    参数:
        filename: 要读取的文件路径
        
    返回:
        文件内容字符串
        
    异常:
        FileNotFoundError: 文件不存在
        IOError: 读取文件时发生I/O错误
    """
    with open(filename, 'r') as file:
        return file.read()

# 使用策略1的函数
content1 = read_file_safe("nonexistent.txt")
print(f"策略1读取的内容长度: {len(content1)}")

# 使用策略2的函数
try:
    content2 = read_file_unsafe("nonexistent.txt")
except FileNotFoundError as e:
    print(f"捕获到异常: {e}")
    content2 = ""
print(f"策略2读取的内容长度: {len(content2)}")

# 记录异常后重新引发
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"记录错误: {e}")
    # 重新引发异常
    raise

# 将原始异常包装在自定义异常中
try:
    try:
        result = 10 / 0
except ZeroDivisionError as e:
        # 创建一个新的异常，并保留原始异常的上下文
        raise CustomError("发生除零错误") from e
except CustomError as e:
    print(f"捕获到自定义异常: {e}")
    # 打印原始异常信息
    if e.__cause__:
        print(f"原始异常: {e.__cause__}")

# 不好的做法: 捕获所有异常
try:
    process_data()
except:
    # 不知道发生了什么错误
    print("发生了一个错误")

# 好的做法: 只捕获特定的异常
try:
    process_data()
except (ValueError, TypeError) as e:
    # 知道发生了什么类型的错误
    print(f"数据错误: {e}")
except IOError as e:
    print(f"I/O错误: {e}")
# 如果有其他类型的异常，让它们继续传递

# 不好的做法: 不提供有用的错误消息
try:
    open("nonexistent.txt", "r")
except FileNotFoundError:
    print("错误")

# 好的做法: 提供有用的错误消息
try:
    filename = "nonexistent.txt"
    open(filename, "r")
except FileNotFoundError:
    print(f"错误: 无法找到文件 '{filename}'。请检查文件路径是否正确，以及文件是否存在。")

# 不好的做法: 没有确保资源被释放
try:
    file = open("example.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("文件不存在")
# 如果发生异常，file.close()不会被执行
file.close()

# 好的做法: 使用finally确保资源被释放
try:
    file = open("example.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("文件不存在")
finally:
    # 无论是否发生异常，都会执行file.close()
    if 'file' in locals() and not file.closed:
        file.close()

# 更好的做法: 使用上下文管理器（with语句）
try:
    with open("example.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    print("文件不存在")
# 当with块结束时，文件会自动关闭，无论是否发生异常

# 不好的做法: 使用异常进行流程控制
def find_user_by_id(user_id):
    users = {1: "Alice", 2: "Bob", 3: "Charlie"}
    try:
        return users[user_id]
    except KeyError:
        return "User not found"

# 好的做法: 使用条件语句进行流程控制
def find_user_by_id_improved(user_id):
    users = {1: "Alice", 2: "Bob", 3: "Charlie"}
    if user_id in users:
        return users[user_id]
    else:
        return "User not found"

import logging

# 配置日志
logging.basicConfig(
    filename='app.log',
    level=logging.ERROR,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

try:
    # 可能会引发异常的代码
    result = 10 / 0
except ZeroDivisionError as e:
    # 向用户显示友好的错误消息
    print("抱歉，操作未能完成。请稍后再试。")
    # 记录详细的异常信息
    logging.error(f"除零错误: {e}", exc_info=True)

# 使用with语句打开文件
with open("example.txt", "r") as file:
    content = file.read()
    print(content)
# 当with块结束时，文件会自动关闭，无论是否发生异常

# 不使用with语句的等效代码
try:
    file = open("example.txt", "r")
    content = file.read()
    print(content)
except Exception as e:
    print(f"发生错误: {e}")
finally:
    if 'file' in locals() and not file.closed:
        file.close()

# 创建一个简单的上下文管理器类
class Timer:
    def __init__(self, name):
        self.name = name
    
    def __enter__(self):
        # 当进入with块时执行
        import time
        self.start_time = time.time()
        print(f"{self.name} 开始")
        # 返回值可以被as子句捕获
        return self
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        # 当离开with块时执行
        import time
        end_time = time.time()
        elapsed_time = end_time - self.start_time
        print(f"{self.name} 结束，耗时: {elapsed_time:.2f}秒")
        # 如果返回True，表示异常已被处理，不会向上传递
        # 如果返回False或None，异常会向上传递
        return False

# 使用自定义上下文管理器
with Timer("执行计算"):
    # 模拟耗时操作
    import time
    total = 0
    for i in range(1000000):
        total += i
    print(f"计算结果: {total}")

# 演示异常处理
with Timer("可能会出错的操作"):
    # 故意引发异常
    result = 10 / 0

import contextlib

# 使用contextmanager装饰器创建上下文管理器
@contextlib.contextmanager
def timer(name):
    import time
    start_time = time.time()
    print(f"{name} 开始")
    try:
        # yield之前的代码相当于__enter__方法
        # yield的值会被as子句捕获
        yield
    except Exception as e:
        print(f"{name} 发生错误: {e}")
        # 如果想要重新引发异常，可以使用raise
        # raise
    finally:
        # finally块中的代码相当于__exit__方法
        end_time = time.time()
        elapsed_time = end_time - start_time
        print(f"{name} 结束，耗时: {elapsed_time:.2f}秒")

# 使用装饰器创建的上下文管理器
with timer("执行计算"):
    # 模拟耗时操作
    import time
    total = 0
    for i in range(1000000):
        total += i
    print(f"计算结果: {total}")

# 演示异常处理
with timer("可能会出错的操作"):
    # 故意引发异常
    result = 10 / 0

# 生成异常追踪信息的示例
def level3():
    return 10 / 0  # 这里会引发ZeroDivisionError

def level2():
    return level3() + 5

def level1():
    return level2() * 2

# 调用函数，不捕获异常
level1()

Traceback (most recent call last):
  File "example.py", line 13, in <module>
    level1()
  File "example.py", line 10, in level1
    return level2() * 2
  File "example.py", line 6, in level2
    return level3() + 5
  File "example.py", line 3, in level3
    return 10 / 0  # 这里会引发ZeroDivisionError
ZeroDivisionError: division by zero

def calculate(a, b, operation):
    print(f"输入参数: a={a}, b={b}, operation={operation}")
    try:
        if operation == "add":
            result = a + b
        elif operation == "subtract":
            result = a - b
        elif operation == "multiply":
            result = a * b
        elif operation == "divide":
            result = a / b
        else:
            raise ValueError(f"不支持的操作: {operation}")
        print(f"计算结果: {result}")
        return result
    except Exception as e:
        print(f"捕获到异常: {e}")
        raise

# 测试函数
calculate(10, 0, "divide")

import pdb

def calculate(a, b, operation):
    # 在这一行设置断点
    pdb.set_trace()
    try:
        if operation == "add":
            result = a + b
        elif operation == "subtract":
            result = a - b
        elif operation == "multiply":
            result = a * b
        elif operation == "divide":
            result = a / b
        else:
            raise ValueError(f"不支持的操作: {operation}")
        return result
    except Exception as e:
        print(f"捕获到异常: {e}")
        raise

# 测试函数
calculate(10, 0, "divide")