异常处理：优雅地处理错误
🎯 前言：当程序遇到"意外"
想象一下，你正在厨房里做饭，突然发现盐罐子空了、鸡蛋坏了、或者煤气没了。如果你是个新手厨师，可能会手忙脚乱，甚至放弃做饭。但如果你是个经验丰富的厨师，你会优雅地处理这些"意外"：没盐就用其他调料、鸡蛋坏了就重新拿一个、煤气没了就改用电磁炉。
编程也是如此！程序在运行时总会遇到各种"意外"：文件找不到、网络连接断开、用户输入了奇怪的数据...这些就是我们所说的"异常"。今天我们要学习如何像资深厨师一样，优雅地处理这些编程中的"意外"。
让我们一起成为处理异常的高手吧！🚀
📚 目录
🧠 什么是异常？
异常就像是程序运行时的"突发状况"。当程序遇到无法正常处理的情况时，Python会抛出一个异常对象，告诉我们"出事了！"
🎭 没有异常处理的悲剧
python
# 这个程序看起来很正常，但是...
def divide_numbers():
a = int(input("请输入第一个数字："))
b = int(input("请输入第二个数字："))
result = a / b
print(f"结果是：{result}")
# 当用户输入0作为除数时...
divide_numbers()
# 💥 ZeroDivisionError: division by zero
# 程序直接崩溃了！🎪 有异常处理的优雅
python
# 优雅的版本
def divide_numbers_gracefully():
try:
a = int(input("请输入第一个数字："))
b = int(input("请输入第二个数字："))
result = a / b
print(f"结果是：{result}")
except ZeroDivisionError:
print("哎呀！除数不能为0哦，数学老师会生气的！")
except ValueError:
print("请输入有效的数字，不要调皮输入文字！")
# 现在程序不会崩溃了，而是友好地提示用户
divide_numbers_gracefully()🎨 异常的种类
Python中的异常就像是不同类型的"意外事件"，每种异常都有自己的"个性"：
🔢 常见的内置异常
python
# 1. ValueError：值错误（数据类型对，但值不对）
try:
age = int("abc") # 想把字母转换成数字？门都没有！
except ValueError as e:
print(f"数值错误：{e}")
# 2. TypeError：类型错误（数据类型不对）
try:
result = "hello" + 5 # 字符串和数字谈恋爱？不可能！
except TypeError as e:
print(f"类型错误：{e}")
# 3. IndexError：索引错误（数组越界）
try:
my_list = [1, 2, 3]
print(my_list[10]) # 想访问不存在的位置？超出范围了！
except IndexError as e:
print(f"索引错误：{e}")
# 4. KeyError：键错误（字典中不存在的键）
try:
my_dict = {"name": "张三", "age": 25}
print(my_dict["salary"]) # 想要不存在的键？没有这个字段！
except KeyError as e:
print(f"键错误：{e}")
# 5. FileNotFoundError：文件未找到
try:
with open("不存在的文件.txt", "r") as file:
content = file.read()
except FileNotFoundError as e:
print(f"文件未找到：{e}")🎯 异常的"家族谱"
python
# 所有异常都有一个共同的祖先：BaseException
# 我们通常处理的是Exception及其子类
print("异常家族谱：")
print("BaseException（所有异常的祖宗）")
print("├── Exception（我们主要处理的异常）")
print("│ ├── ValueError（值错误）")
print("│ ├── TypeError（类型错误）")
print("│ ├── IndexError（索引错误）")
print("│ ├── KeyError（键错误）")
print("│ ├── FileNotFoundError（文件未找到）")
print("│ └── ... 还有很多其他异常")🛡️ try-except：异常处理的基本套路
try-except就像是给程序穿上了"防护服"，让它在遇到危险时不会受伤。
🎪 基本语法
python
# 基本模式
try:
# 可能出错的代码放这里
risky_code()
except 异常类型:
# 出错时的处理方案
handle_error()🎭 实际例子
python
# 例子1：安全的数字输入
def safe_input_number():
while True: # 一直循环直到用户输入正确
try:
num = int(input("请输入一个整数："))
return num # 成功了就返回
except ValueError:
print("这不是一个有效的整数！请重新输入。")
# 不返回，继续循环
# 例子2：安全的列表访问
def safe_list_access(my_list, index):
try:
return my_list[index]
except IndexError:
print(f"索引{index}超出了列表范围！")
return None
# 测试
numbers = [1, 2, 3, 4, 5]
print(safe_list_access(numbers, 2)) # 正常访问
print(safe_list_access(numbers, 10)) # 越界访问🎨 多种异常处理
有时候一段代码可能产生多种异常，我们需要分别处理：
🎯 方法1：多个except块
python
def comprehensive_calculator():
try:
# 获取用户输入
expression = input("请输入计算表达式（如：10 / 2）：")
# 分割表达式
parts = expression.split()
num1 = float(parts[0])
operator = parts[1]
num2 = float(parts[2])
# 执行计算
if operator == '+':
result = num1 + num2
elif operator == '-':
result = num1 - num2
elif operator == '*':
result = num1 * num2
elif operator == '/':
result = num1 / num2
else:
raise ValueError("不支持的运算符")
print(f"结果：{result}")
except IndexError:
print("输入格式不正确！请按照'数字 运算符 数字'的格式输入")
except ValueError as e:
print(f"数值错误：{e}")
except ZeroDivisionError:
print("除数不能为0！数学老师说了算！")
except Exception as e:
print(f"发生了未知错误：{e}")
# 测试不同的异常情况
comprehensive_calculator()🎪 方法2：捕获多种异常
python
# 把相似的异常放在一个tuple里
def process_data(data):
try:
# 尝试处理数据
result = int(data) * 2
return result
except (ValueError, TypeError) as e:
print(f"数据处理错误：{e}")
return None
except Exception as e:
print(f"其他错误：{e}")
return None
# 测试
print(process_data("123")) # 正常
print(process_data("abc")) # ValueError
print(process_data(None)) # TypeError🎭 else和finally：锦上添花的控制
else和finally是异常处理的高级技巧，让我们的代码更加精细：
🎯 else：没有异常时执行
python
def read_file_safely(filename):
try:
file = open(filename, 'r', encoding='utf-8')
content = file.read()
except FileNotFoundError:
print(f"文件{filename}不存在！")
return None
except PermissionError:
print(f"没有权限读取文件{filename}！")
return None
else:
# 只有当没有异常时才执行
print(f"成功读取文件{filename}")
file.close()
return content
finally:
# 无论是否有异常都会执行
print("文件读取操作完成")
# 测试
content = read_file_safely("test.txt")
if content:
print(f"文件内容：{content}")🎪 finally：无论如何都要执行
python
def database_operation():
"""模拟数据库操作"""
database_connection = None
try:
print("正在连接数据库...")
database_connection = "模拟数据库连接"
# 模拟可能出错的操作
risky_operation = int(input("输入1执行成功，输入0产生错误："))
if risky_operation == 0:
raise ValueError("模拟数据库错误")
print("数据库操作成功！")
except ValueError as e:
print(f"数据库操作失败：{e}")
finally:
# 无论成功失败都要关闭连接
if database_connection:
print("正在关闭数据库连接...")
database_connection = None
print("数据库连接已关闭")
# 测试
database_operation()🚀 主动抛出异常
有时候我们需要主动抛出异常，就像是设置"警报器"：
🎯 使用raise抛出异常
python
def check_age(age):
"""检查年龄是否合法"""
if not isinstance(age, (int, float)):
raise TypeError("年龄必须是数字！")
if age < 0:
raise ValueError("年龄不能是负数！时光倒流了吗？")
if age > 150:
raise ValueError("年龄不能超过150岁！你是神仙吗？")
return True
def register_user(name, age):
"""用户注册"""
try:
# 检查年龄
check_age(age)
# 其他验证...
if not name.strip():
raise ValueError("姓名不能为空！")
print(f"用户{name}（{age}岁）注册成功！")
return True
except (TypeError, ValueError) as e:
print(f"注册失败：{e}")
return False
# 测试
register_user("张三", 25) # 正常
register_user("李四", -5) # 年龄负数
register_user("王五", "abc") # 年龄非数字
register_user("", 30) # 姓名为空🎪 重新抛出异常
python
def divide_with_logging(a, b):
"""带日志的除法运算"""
try:
result = a / b
print(f"计算成功：{a} / {b} = {result}")
return result
except ZeroDivisionError as e:
print(f"错误日志：尝试除以零 - {e}")
# 记录日志后重新抛出异常
raise # 重新抛出同样的异常
def main():
try:
result = divide_with_logging(10, 0)
except ZeroDivisionError:
print("主程序：检测到除零错误，使用默认值")
result = 0
print(f"最终结果：{result}")
# 测试
main()🎨 自定义异常
当内置异常不够用时，我们可以创建自己的异常类：
🎯 创建自定义异常
python
# 自定义异常类
class CustomError(Exception):
"""自定义错误基类"""
pass
class InvalidPasswordError(CustomError):
"""密码不符合要求的错误"""
def __init__(self, message="密码不符合要求"):
self.message = message
super().__init__(self.message)
class UserNotFoundError(CustomError):
"""用户不存在的错误"""
def __init__(self, username):
self.username = username
self.message = f"用户'{username}'不存在"
super().__init__(self.message)
class InsufficientFundsError(CustomError):
"""余额不足的错误"""
def __init__(self, balance, amount):
self.balance = balance
self.amount = amount
self.message = f"余额不足！当前余额：{balance}，尝试支付：{amount}"
super().__init__(self.message)
# 使用自定义异常
class BankAccount:
def __init__(self, username, balance=0):
self.username = username
self.balance = balance
def withdraw(self, amount):
"""取款"""
if amount > self.balance:
raise InsufficientFundsError(self.balance, amount)
self.balance -= amount
print(f"成功取款{amount}元，余额：{self.balance}元")
def deposit(self, amount):
"""存款"""
if amount <= 0:
raise ValueError("存款金额必须大于0！")
self.balance += amount
print(f"成功存款{amount}元，余额：{self.balance}元")
# 测试自定义异常
def test_bank_account():
try:
account = BankAccount("张三", 1000)
account.withdraw(500) # 正常取款
account.withdraw(600) # 余额不足
except InsufficientFundsError as e:
print(f"取款失败：{e}")
except ValueError as e:
print(f"操作失败：{e}")
test_bank_account()🎭 异常处理的最佳实践
🎯 DO：好的做法
python
# 1. 具体异常优于通用异常
def good_practice_1():
try:
data = {"name": "张三"}
print(data["age"])
except KeyError: # 具体的异常
print("缺少age字段")
# 2. 不要忽略异常
def good_practice_2():
try:
risky_operation()
except SpecificError as e:
logger.error(f"操作失败：{e}") # 记录日志
return default_value # 返回默认值
# 3. 使用异常链
def good_practice_3():
try:
process_data()
except ValueError as e:
raise ProcessingError("数据处理失败") from e # 保留原始异常
# 4. 资源管理用with语句
def good_practice_4():
# 推荐：自动管理资源
with open("file.txt", "r") as f:
content = f.read()
# 文件会自动关闭🚫 DON'T：不好的做法
python
# 1. 避免捕获所有异常
def bad_practice_1():
try:
risky_operation()
except: # 🚫 太宽泛了
pass # 🚫 还忽略了异常
# 2. 避免异常用于控制流程
def bad_practice_2():
try:
return my_dict[key]
except KeyError:
return None # 🚫 应该用 dict.get(key) 代替
# 3. 避免在异常处理中抛出新异常
def bad_practice_3():
try:
risky_operation()
except Exception as e:
print(f"Error: {e.invalid_attribute}") # 🚫 可能再次抛出异常🚀 实战项目：健壮的计算器
让我们创建一个健壮的计算器，展示异常处理的实际应用：
python
import math
import operator
class AdvancedCalculator:
"""高级计算器类"""
def __init__(self):
self.operations = {
'+': operator.add,
'-': operator.sub,
'*': operator.mul,
'/': operator.truediv,
'**': operator.pow,
'%': operator.mod,
'//': operator.floordiv,
}
self.history = []
def calculate(self, expression):
"""计算表达式"""
try:
# 记录历史
self.history.append(expression)
# 解析表达式
tokens = self.parse_expression(expression)
# 执行计算
result = self.evaluate_tokens(tokens)
print(f"✅ {expression} = {result}")
return result
except ZeroDivisionError:
error_msg = "❌ 除零错误：不能除以零！"
print(error_msg)
raise CalculationError(error_msg)
except ValueError as e:
error_msg = f"❌ 数值错误：{e}"
print(error_msg)
raise CalculationError(error_msg)
except KeyError as e:
error_msg = f"❌ 不支持的运算符：{e}"
print(error_msg)
raise CalculationError(error_msg)
except Exception as e:
error_msg = f"❌ 计算错误：{e}"
print(error_msg)
raise CalculationError(error_msg)
def parse_expression(self, expression):
"""解析表达式"""
# 简单的解析，支持基本运算
expression = expression.replace(' ', '')
# 处理特殊函数
if expression.startswith('sqrt(') and expression.endswith(')'):
value = float(expression[5:-1])
if value < 0:
raise ValueError("不能计算负数的平方根")
return ['sqrt', value]
# 处理基本运算
for op in ['**', '//', '+', '-', '*', '/', '%']:
if op in expression:
parts = expression.split(op, 1)
if len(parts) == 2:
left = float(parts[0])
right = float(parts[1])
return [left, op, right]
# 如果没有运算符，可能是单个数字
return [float(expression)]
def evaluate_tokens(self, tokens):
"""计算token列表"""
if len(tokens) == 1:
return tokens[0]
elif len(tokens) == 2 and tokens[0] == 'sqrt':
return math.sqrt(tokens[1])
elif len(tokens) == 3:
left, op, right = tokens
if op not in self.operations:
raise KeyError(op)
return self.operations[op](left, right)
else:
raise ValueError("无效的表达式格式")
def show_history(self):
"""显示计算历史"""
if not self.history:
print("📝 暂无计算历史")
return
print("📝 计算历史：")
for i, expr in enumerate(self.history, 1):
print(f" {i}. {expr}")
def clear_history(self):
"""清空历史"""
self.history.clear()
print("🧹 历史记录已清空")
# 自定义异常
class CalculationError(Exception):
"""计算错误"""
pass
# 主程序
def main():
calc = AdvancedCalculator()
print("🔢 欢迎使用高级计算器！")
print("支持的运算：+, -, *, /, **, %, //, sqrt()")
print("输入 'history' 查看历史，'clear' 清空历史，'quit' 退出")
print("-" * 50)
while True:
try:
user_input = input("\n请输入表达式：").strip()
if not user_input:
continue
if user_input.lower() == 'quit':
print("👋 再见！")
break
elif user_input.lower() == 'history':
calc.show_history()
elif user_input.lower() == 'clear':
calc.clear_history()
else:
result = calc.calculate(user_input)
except CalculationError:
# 计算错误已经在calculate方法中处理了
continue
except KeyboardInterrupt:
print("\n\n👋 程序被中断，再见！")
break
except Exception as e:
print(f"😱 发生了意外错误：{e}")
print("请检查输入格式或联系开发者")
if __name__ == "__main__":
main()🎮 使用示例
python
# 测试计算器
def test_calculator():
calc = AdvancedCalculator()
# 测试各种情况
test_cases = [
"10 + 5", # 正常计算
"10 / 0", # 除零错误
"sqrt(16)", # 平方根
"sqrt(-4)", # 负数平方根
"2 ** 3", # 幂运算
"10 % 3", # 取模
"abc + def", # 无效输入
]
for expression in test_cases:
print(f"\n测试：{expression}")
try:
result = calc.calculate(expression)
print(f"结果：{result}")
except CalculationError as e:
print(f"计算失败：{e}")
except Exception as e:
print(f"其他错误：{e}")
# 运行测试
test_calculator()🔧 常见问题与解决方案
❓ Q: 什么时候应该使用异常处理？
A: 当你的程序可能遇到以下情况时：
- 用户输入不合法
- 文件操作失败
- 网络连接问题
- 数据转换错误
- 资源不足
❓ Q: 应该捕获所有异常吗？
A: 不应该！只捕获你知道如何处理的异常：
python
# 🚫 错误做法
try:
some_operation()
except: # 捕获所有异常
pass # 忽略所有错误
# ✅ 正确做法
try:
some_operation()
except SpecificError as e:
handle_specific_error(e)
except AnotherError as e:
handle_another_error(e)❓ Q: 异常处理会影响性能吗？
A: 在正常情况下影响很小，但在异常频繁发生时影响较大。不要用异常来控制程序流程！
python
# 🚫 错误：用异常控制流程
def find_item(items, target):
try:
return items[target]
except KeyError:
return None
# ✅ 正确：用正常逻辑
def find_item(items, target):
return items.get(target, None)📖 扩展阅读
📚 推荐资源
🛠️ 相关工具
logging模块：记录异常日志traceback模块：获取异常详细信息warnings模块：处理警告信息
🎯 进阶主题
- 上下文管理器（
with语句） - 异常链（
raise ... from） - 自定义异常层次结构
- 异步编程中的异常处理
🎬 下集预告
恭喜你！🎉 完成了Python基础语法篇的最后一课！现在你已经掌握了：
- ✅ Python基础语法
- ✅ 变量与数据类型
- ✅ 条件判断
- ✅ 循环结构
- ✅ 函数定义与使用
- ✅ 列表与字典
- ✅ 文件操作
- ✅ 异常处理
接下来，我们将进入Python进阶特性篇，第一站是"面向对象编程：给代码穿上西装"。我们将学习如何：
- 创建类和对象
- 理解封装、继承、多态
- 设计优雅的代码结构
- 构建可重用的代码模块
准备好迎接更高级的Python编程挑战了吗？让我们一起进入面向对象的精彩世界！🚀
📝 总结与思考题
🎯 关键知识点总结
- 异常处理的重要性：让程序更加健壮和用户友好
- try-except语法：捕获和处理异常的基本方法
- 异常类型：了解常见异常并针对性处理
- else和finally：精细控制异常处理流程
- 自定义异常：创建符合业务需求的异常类
- 最佳实践：写出优雅的异常处理代码
🤔 思考题
-
基础题：写一个函数，安全地将字符串转换为整数，如果转换失败返回默认值。
-
进阶题：设计一个文件处理类，能够安全地读写文件，并在出错时提供详细的错误信息。
-
挑战题：创建一个网络爬虫的错误处理系统，能够处理各种网络异常并自动重试。
🎯 实践作业
-
改进计算器：在我们的计算器基础上，添加更多数学函数（如三角函数、对数等）的支持。
-
配置文件读取器：编写一个配置文件读取器，能够优雅地处理文件不存在、格式错误等各种异常。
-
用户输入验证器：创建一个通用的用户输入验证系统，能够处理各种输入错误并给出友好提示。
记住，优秀的程序员不仅要会写能运行的代码，更要会写能优雅处理错误的代码！异常处理是你迈向高级程序员的重要一步。🎓
"在编程的世界里，异常不是敌人，而是程序健壮性的守护者。学会与异常共舞，你的代码将更加优雅和可靠。" 💫