Python文件操作与异常处理：构建健壮的应用程序
引言：当代码遇见现实世界
想象你正在驾驶一辆汽车。在理想的封闭测试场中，你不需要考虑突然出现的行人、恶劣的天气或突发的机械故障。但现实世界的道路充满了不确定性。同样，完美的代码在理想环境中运行顺畅，但真实的应用程序必须处理各种异常情况：文件不存在、网络中断、用户输入错误、内存不足...
根据行业统计数据，超过70%的软件故障是由于异常处理不当导致的。文件操作和异常处理是Python程序员从"玩具代码"迈向"工业级代码"的关键一步。今天，我们将学习如何让程序优雅地应对各种意外情况，如何安全地读写数据，以及如何构建能够在现实世界中稳定运行的应用程序。
第一部分：文件操作基础------数据的持久化存储
1.1 理解文件与文件系统
在开始编码之前，先理解文件的基本概念：
python
# 文件路径的基础知识
import os
# 当前工作目录
print(f"当前工作目录: {os.getcwd()}")
# 路径拼接（跨平台安全）
file_path = os.path.join("data", "files", "example.txt")
print(f"文件路径: {file_path}")
# 检查路径是否存在
print(f"路径存在吗? {os.path.exists(file_path)}")
# 常见的文件路径问题
print("\n常见路径表示方法:")
print(f"绝对路径示例: {os.path.abspath('.')}")
print(f"相对路径: ./data/files/example.txt")
print(f"上级目录: ../parent.txt")
print(f"家目录: ~/myfile.txt (展开后: {os.path.expanduser('~/myfile.txt')})")
# 路径解析
path = "/home/user/data/files/example.txt"
print(f"\n路径解析:")
print(f"目录名: {os.path.dirname(path)}")
print(f"文件名: {os.path.basename(path)}")
print(f"分割扩展名: {os.path.splitext(path)}") # ('/home/user/data/files/example', '.txt')1.2 打开文件：open()函数详解
Python使用内置的open()函数打开文件，需要理解不同的打开模式：
python
# open()函数的基本语法
# open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
# 演示不同的打开模式
modes = {
'r': '只读（默认）。文件必须存在，否则抛出FileNotFoundError',
'w': '只写。如果文件存在则清空，不存在则创建',
'a': '追加。如果文件存在则在末尾追加，不存在则创建',
'x': '排他性创建。文件必须不存在，否则抛出FileExistsError',
'b': '二进制模式（如rb, wb）。用于处理图片、视频等非文本文件',
't': '文本模式（默认）。处理文本文件，自动处理编码',
'+': '读写模式（如r+, w+, a+）'
}
print("文件打开模式详解:")
for mode, description in modes.items():
print(f" '{mode}': {description}")
# 示例：安全地打开文件
def safe_open_file(filename, mode='r'):
"""安全地打开文件，处理可能出现的异常"""
try:
file = open(filename, mode, encoding='utf-8')
print(f"✅ 成功打开文件: {filename} (模式: {mode})")
return file
except FileNotFoundError:
print(f"❌ 文件不存在: {filename}")
return None
except PermissionError:
print(f"❌ 没有权限访问文件: {filename}")
return None
except IsADirectoryError:
print(f"❌ 这是一个目录，不是文件: {filename}")
return None
except Exception as e:
print(f"❌ 打开文件时发生未知错误: {e}")
return None
# 测试安全打开函数
print("\n测试文件打开:")
test_files = ["test.txt", "/root/secret.txt", ".", "nonexistent.txt"]
for file in test_files:
f = safe_open_file(file, 'r')
if f:
f.close()1.3 读取文件内容
读取文件有多种方式，适合不同的场景：
python
# 创建示例文件用于演示
sample_content = """Python文件操作指南
===================
第1章：文件基础
- 打开文件
- 读取内容
- 写入内容
第2章：高级操作
- 二进制文件
- 上下文管理器
- 文件指针操作
第3章：实战应用
- 日志分析
- 数据清洗
- 配置文件管理
作者：Python开发者
创建时间：2023-10-01
版本：1.0.0
"""
# 写入示例文件
with open("sample.txt", "w", encoding="utf-8") as f:
f.write(sample_content)
print("示例文件创建完成: sample.txt")
# 方法1：read() - 读取整个文件
print("\n方法1: read() 读取整个文件")
with open("sample.txt", "r", encoding="utf-8") as f:
content = f.read()
print(f"文件大小: {len(content)} 字符")
print(f"前100个字符: {content[:100]}...")
# 方法2：readline() - 逐行读取
print("\n方法2: readline() 逐行读取")
with open("sample.txt", "r", encoding="utf-8") as f:
print("前3行内容:")
for i in range(3):
line = f.readline()
print(f" 第{i+1}行: {line.rstrip()}")
# 方法3：readlines() - 读取所有行到列表
print("\n方法3: readlines() 读取所有行")
with open("sample.txt", "r", encoding="utf-8") as f:
lines = f.readlines()
print(f"总行数: {len(lines)}")
print(f"第1行: {lines[0].rstrip()}")
print(f"最后1行: {lines[-1].rstrip()}")
# 方法4：直接迭代文件对象（最Pythonic的方式）
print("\n方法4: 直接迭代文件对象")
with open("sample.txt", "r", encoding="utf-8") as f:
print("包含'文件'的行:")
for line_num, line in enumerate(f, 1):
if "文件" in line:
print(f" 第{line_num}行: {line.rstrip()}")
# 方法5：读取指定字节数（适合大文件）
print("\n方法5: 读取指定字节数")
with open("sample.txt", "r", encoding="utf-8") as f:
# 读取前50个字节
chunk = f.read(50)
print(f"前50字节: {chunk}")
# 继续读取下50个字节
next_chunk = f.read(50)
print(f"接下来50字节: {next_chunk}")
# 方法6：使用tell()和seek()控制文件指针
print("\n方法6: 使用tell()和seek()控制文件指针")
with open("sample.txt", "r", encoding="utf-8") as f:
# 获取当前位置
pos1 = f.tell()
print(f"初始位置: {pos1}")
# 读取一行
line1 = f.readline()
pos2 = f.tell()
print(f"读取一行后位置: {pos2}")
print(f"读取的内容: {line1.rstrip()}")
# 回到文件开头
f.seek(0)
print(f"使用seek(0)后位置: {f.tell()}")
# 移动到第100个字符处
f.seek(100)
print(f"使用seek(100)后位置: {f.tell()}")
print(f"从位置100开始的内容: {f.read(50)}...")
# 清理示例文件
import os
os.remove("sample.txt")
print("\n✅ 示例文件已清理")1.4 写入文件内容
写入文件同样有多种方式，需要根据需求选择：
python
# 方法1：write() - 写入字符串
print("方法1: write() 写入字符串")
with open("output1.txt", "w", encoding="utf-8") as f:
f.write("这是第一行\n")
f.write("这是第二行\n")
f.write("这是第三行，包含数字: 123\n")
print("✅ output1.txt 创建完成")
# 方法2：writelines() - 写入字符串列表
print("\n方法2: writelines() 写入字符串列表")
lines = [
"Python是一种高级编程语言\n",
"它强调代码的可读性和简洁性\n",
"Python的哲学是：优美胜于丑陋\n"
]
with open("output2.txt", "w", encoding="utf-8") as f:
f.writelines(lines)
print("✅ output2.txt 创建完成")
# 方法3：追加模式（append）
print("\n方法3: 追加模式")
with open("output3.txt", "w", encoding="utf-8") as f:
f.write("这是初始内容\n")
with open("output3.txt", "a", encoding="utf-8") as f:
f.write("这是追加的第一行\n")
f.write("这是追加的第二行\n")
# 也可以使用writelines
f.writelines(["这是追加的第三行\n", "这是追加的第四行\n"])
print("✅ output3.txt 创建并追加完成")
# 方法4：读写模式（r+/w+/a+）
print("\n方法4: 读写模式")
with open("output4.txt", "w+", encoding="utf-8") as f: # w+：读写，会覆盖文件
# 写入内容
f.write("第一行\n第二行\n第三行\n")
# 回到文件开头读取
f.seek(0)
content = f.read()
print(f"写入后读取的内容:\n{content}")
# 方法5：格式化写入
print("\n方法5: 格式化写入")
students = [
{"name": "张三", "score": 88, "grade": "B"},
{"name": "李四", "score": 92, "grade": "A"},
{"name": "王五", "score": 78, "grade": "C"}
]
with open("students.txt", "w", encoding="utf-8") as f:
# 写入表头
f.write(f"{'姓名':<10} {'分数':<6} {'等级':<6}\n")
f.write("-" * 25 + "\n")
# 写入数据
for student in students:
f.write(f"{student['name']:<10} {student['score']:<6} {student['grade']:<6}\n")
print("✅ students.txt 创建完成")
print("文件内容预览:")
with open("students.txt", "r", encoding="utf-8") as f:
print(f.read())
# 方法6：批量写入大数据（避免内存问题）
print("\n方法6: 批量写入大数据")
def generate_large_file(filename, num_lines=10000):
"""生成大文件（用于演示）"""
with open(filename, "w", encoding="utf-8") as f:
for i in range(num_lines):
# 每次写入一行，避免内存占用过大
f.write(f"这是第{i+1}行，包含一些数据: {i*123 % 1000}\n")
print(f"✅ 生成大文件: {filename} ({num_lines}行)")
generate_large_file("large_file.txt", 1000)
# 清理生成的文件
files_to_clean = ["output1.txt", "output2.txt", "output3.txt", "output4.txt", "students.txt", "large_file.txt"]
for file in files_to_clean:
if os.path.exists(file):
os.remove(file)
print(f"清理: {file}")
print("\n✅ 所有演示文件已清理")1.5 二进制文件操作
处理图片、视频、音频等二进制文件：
python
# 二进制文件操作示例
import struct
# 示例1：读写二进制数据
print("示例1: 读写二进制数据")
# 创建一些二进制数据
binary_data = bytes([65, 66, 67, 68, 69]) # ASCII: A, B, C, D, E
print(f"原始字节数据: {binary_data}")
print(f"解码为字符串: {binary_data.decode('ascii')}")
# 写入二进制文件
with open("binary.bin", "wb") as f:
f.write(binary_data)
# 写入更多数据
f.write(b"\x00\x01\x02\x03\x04")
# 写入字符串（需要编码）
f.write("Hello".encode('utf-8'))
print("✅ binary.bin 创建完成")
# 读取二进制文件
with open("binary.bin", "rb") as f:
# 读取前5个字节
data1 = f.read(5)
print(f"前5字节: {data1}")
# 读取接下来5个字节
data2 = f.read(5)
print(f"接下来5字节: {data2}")
# 读取剩余所有字节
data3 = f.read()
print(f"剩余字节: {data3}")
print(f"解码为字符串: {data3.decode('utf-8')}")
# 示例2：使用struct模块处理结构化二进制数据
print("\n示例2: 使用struct模块")
# 打包数据：将Python值转换为字节
packed_data = struct.pack('iif', 123, 456, 3.14) # 格式: 整数, 整数, 浮点数
print(f"打包后的字节: {packed_data}")
# 写入文件
with open("structured.bin", "wb") as f:
f.write(packed_data)
# 从文件读取并解包
with open("structured.bin", "rb") as f:
data = f.read()
unpacked = struct.unpack('iif', data)
print(f"解包后的数据: {unpacked}")
# 示例3：复制文件（二进制模式）
print("\n示例3: 复制文件（二进制模式）")
def copy_file_binary(src, dst, buffer_size=4096):
"""使用二进制模式复制文件"""
try:
with open(src, "rb") as src_file:
with open(dst, "wb") as dst_file:
while True:
buffer = src_file.read(buffer_size)
if not buffer:
break
dst_file.write(buffer)
print(f"✅ 文件复制成功: {src} -> {dst}")
return True
except Exception as e:
print(f"❌ 复制失败: {e}")
return False
# 创建一个测试文件
with open("test_copy.txt", "w", encoding="utf-8") as f:
f.write("这是一个测试文件，用于演示文件复制功能。\n" * 100)
# 复制文件
copy_file_binary("test_copy.txt", "test_copy_backup.txt")
# 验证复制结果
with open("test_copy_backup.txt", "r", encoding="utf-8") as f:
first_line = f.readline().strip()
print(f"备份文件第一行: {first_line}")
# 示例4：处理图片文件（简单元数据读取）
print("\n示例4: 图片文件处理")
def get_image_info(filename):
"""获取图片文件的基本信息"""
try:
with open(filename, "rb") as f:
# 读取文件头判断图片类型
header = f.read(30)
# 检查常见的图片格式
if header.startswith(b'\xff\xd8\xff'): # JPEG
img_type = "JPEG"
# JPEG文件大小就是文件大小
f.seek(0, 2) # 移动到文件末尾
size = f.tell()
return {"type": img_type, "size": size}
elif header.startswith(b'\x89PNG\r\n\x1a\n'): # PNG
img_type = "PNG"
# PNG文件在头部包含尺寸信息
f.seek(16)
width_bytes = f.read(4)
height_bytes = f.read(4)
width = int.from_bytes(width_bytes, 'big')
height = int.from_bytes(height_bytes, 'big')
f.seek(0, 2)
size = f.tell()
return {"type": img_type, "size": size, "width": width, "height": height}
else:
return {"type": "未知", "error": "不支持的文件格式"}
except FileNotFoundError:
return {"type": "错误", "error": "文件不存在"}
except Exception as e:
return {"type": "错误", "error": str(e)}
# 测试（注意：这里只是演示，实际需要真实图片文件）
print("图片信息检测示例:")
print("（需要真实图片文件进行测试）")
# 清理文件
for file in ["binary.bin", "structured.bin", "test_copy.txt", "test_copy_backup.txt"]:
if os.path.exists(file):
os.remove(file)
print(f"清理: {file}")
print("\n✅ 二进制文件演示完成")第二部分：上下文管理器与with语句
2.1 with语句的魔法
with语句是Python中最优雅的资源管理方式：
python
# with语句的基本用法
print("with语句的基本用法:")
# 传统方式（容易忘记关闭文件）
print("\n1. 传统方式（容易出错）:")
try:
f = open("traditional.txt", "w")
f.write("传统方式写入")
# 如果这里发生异常，文件可能不会关闭
# f.close() # 容易忘记这一行
finally:
if 'f' in locals() and not f.closed:
f.close()
print("文件已关闭")
# with语句方式（自动管理资源）
print("\n2. with语句方式（推荐）:")
with open("with_example.txt", "w") as f:
f.write("使用with语句写入")
print(f"文件是否已关闭? {f.closed}") # False
print(f"退出with块后文件是否已关闭? {f.closed}") # True
# with语句处理多个文件
print("\n3. with语句处理多个文件:")
with open("source.txt", "w") as src, open("destination.txt", "w") as dst:
src.write("这是源文件内容")
dst.write("这是目标文件内容")
print("同时打开两个文件进行写入")
# 验证文件已关闭
print(f"source.txt已关闭? {src.closed}")
print(f"destination.txt已关闭? {dst.closed}")
# 清理文件
for file in ["traditional.txt", "with_example.txt", "source.txt", "destination.txt"]:
if os.path.exists(file):
os.remove(file)
print("\n✅ with语句演示完成")2.2 自定义上下文管理器
理解上下文管理器的工作原理，并创建自定义的上下文管理器：
python
# 方法1：使用类实现上下文管理器
print("方法1: 使用类实现上下文管理器")
class TimerContext:
"""计时上下文管理器"""
def __init__(self, name="操作"):
self.name = name
self.start_time = None
self.end_time = None
def __enter__(self):
"""进入上下文时调用"""
import time
self.start_time = time.time()
print(f"[{self.name}] 开始...")
return self # 可以返回一个对象供as使用
def __exit__(self, exc_type, exc_val, exc_tb):
"""退出上下文时调用"""
import time
self.end_time = time.time()
elapsed = self.end_time - self.start_time
# 处理异常
if exc_type is not None:
print(f"[{self.name}] 发生异常: {exc_type.__name__}: {exc_val}")
print(f"[{self.name}] 完成，耗时: {elapsed:.4f}秒")
# 返回True表示异常已处理，False表示异常继续传播
return False
# 使用自定义上下文管理器
with TimerContext("文件操作") as timer:
import time
# 模拟耗时操作
time.sleep(0.5)
# 可以访问timer对象
print(f"开始时间: {timer.start_time}")
# 方法2：使用contextlib模块
print("\n方法2: 使用contextlib模块")
from contextlib import contextmanager
@contextmanager
def open_file_safely(filename, mode="r", encoding="utf-8"):
"""安全的文件打开上下文管理器"""
file = None
try:
file = open(filename, mode, encoding=encoding)
print(f"✅ 成功打开文件: {filename}")
yield file # 将文件对象传递给with语句
except FileNotFoundError:
print(f"❌ 文件不存在: {filename}")
yield None # 返回None表示失败
except Exception as e:
print(f"❌ 打开文件时出错: {e}")
yield None
finally:
if file is not None:
file.close()
print(f"✅ 文件已关闭: {filename}")
# 使用装饰器创建的上下文管理器
print("\n使用自定义文件上下文管理器:")
# 成功的情况
with open_file_safely("test_file.txt", "w") as f:
if f: # 检查是否成功打开
f.write("测试内容")
print("文件写入成功")
# 失败的情况（文件不存在）
with open_file_safely("nonexistent.txt", "r") as f:
if f is None:
print("文件打开失败，进行错误处理")
# 方法3：数据库连接上下文管理器
print("\n方法3: 数据库连接上下文管理器（模拟）")
class DatabaseConnection:
"""模拟数据库连接上下文管理器"""
def __init__(self, db_name):
self.db_name = db_name
self.connection = None
self.is_connected = False
def __enter__(self):
"""建立数据库连接"""
print(f"连接数据库: {self.db_name}")
# 模拟连接建立
self.connection = f"Connection to {self.db_name}"
self.is_connected = True
return self
def execute_query(self, query):
"""执行查询"""
if not self.is_connected:
raise ConnectionError("数据库未连接")
print(f"执行查询: {query}")
# 模拟查询结果
return f"Result of: {query}"
def __exit__(self, exc_type, exc_val, exc_tb):
"""关闭数据库连接"""
print(f"关闭数据库连接: {self.db_name}")
self.connection = None
self.is_connected = False
# 如果有异常，可以记录日志等
if exc_type is not None:
print(f"数据库操作异常: {exc_type.__name__}")
# 返回False让异常继续传播
return False
# 使用数据库上下文管理器
with DatabaseConnection("my_database") as db:
result = db.execute_query("SELECT * FROM users")
print(f"查询结果: {result}")
# 如果这里发生异常，连接会自动关闭
print(f"退出后是否仍连接? {db.is_connected}")
# 方法4：临时目录上下文管理器
print("\n方法4: 临时目录上下文管理器")
import tempfile
from contextlib import contextmanager
import shutil
@contextmanager
def temporary_directory():
"""创建临时目录的上下文管理器"""
temp_dir = None
try:
# 创建临时目录
temp_dir = tempfile.mkdtemp()
print(f"创建临时目录: {temp_dir}")
yield temp_dir # 将目录路径传递给with语句
finally:
# 清理临时目录
if temp_dir and os.path.exists(temp_dir):
shutil.rmtree(temp_dir)
print(f"清理临时目录: {temp_dir}")
# 使用临时目录
with temporary_directory() as temp_dir:
# 在临时目录中创建文件
temp_file = os.path.join(temp_dir, "test.txt")
with open(temp_file, "w") as f:
f.write("临时文件内容")
# 验证文件创建
print(f"在临时目录中创建了文件: {temp_file}")
print(f"文件内容: {open(temp_file, 'r').read()}")
# 退出with块后，临时目录会被自动清理
print(f"临时目录是否还存在? {os.path.exists(temp_dir) if 'temp_dir' in locals() else 'N/A'}")
print("\n✅ 自定义上下文管理器演示完成")2.3 高级上下文管理器技巧
python
# 1. 可嵌套的上下文管理器
print("1. 可嵌套的上下文管理器")
class IndentContext:
"""缩进上下文管理器"""
def __init__(self, name):
self.name = name
self.level = 0
def __enter__(self):
self.level += 1
print(" " * (self.level - 1) + f"┌ 进入: {self.name}")
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print(" " * (self.level - 1) + f"└ 退出: {self.name}")
self.level -= 1
return False
# 嵌套使用
print("嵌套上下文管理器演示:")
with IndentContext("外层") as outer:
with IndentContext("中层") as middle:
with IndentContext("内层") as inner:
print(" 正在执行操作...")
print(" 中层继续执行...")
print(" 外层继续执行...")
# 2. 重定向输出上下文管理器
print("\n2. 重定向输出上下文管理器")
from contextlib import redirect_stdout, redirect_stderr
import io
print("原始输出:")
print("这是正常输出")
# 重定向标准输出
print("\n重定向到内存:")
output = io.StringIO()
with redirect_stdout(output):
print("这条消息不会显示在控制台")
print("而是被重定向到内存缓冲区")
x = 10 + 20
print(f"计算结果: {x}")
# 获取重定向的输出
captured_output = output.getvalue()
print(f"捕获的输出:\n{captured_output}")
# 重定向到文件
print("\n重定向到文件:")
with open("redirect_output.txt", "w") as f:
with redirect_stdout(f):
print("这条消息被写入文件")
print("而不是显示在控制台")
# 验证文件内容
with open("redirect_output.txt", "r") as f:
print(f"文件内容: {f.read()}")
# 3. 错误抑制上下文管理器
print("\n3. 错误抑制上下文管理器")
from contextlib import suppress
# 使用suppress抑制特定异常
print("使用suppress抑制异常:")
# 传统方式
try:
result = 1 / 0
except ZeroDivisionError:
print("发生了除零错误（传统方式）")
# 使用suppress
with suppress(ZeroDivisionError):
result = 1 / 0
print("这行不会执行")
print("程序继续执行...")
# 抑制多个异常
with suppress(FileNotFoundError, PermissionError):
with open("nonexistent.txt", "r") as f:
content = f.read()
print("文件操作失败被抑制，程序继续执行")
# 4. 上下文管理器组合
print("\n4. 上下文管理器组合")
from contextlib import ExitStack
def process_files(filenames):
"""同时处理多个文件，使用ExitStack管理资源"""
with ExitStack() as stack:
files = []
for filename in filenames:
try:
f = stack.enter_context(open(filename, 'r'))
files.append(f)
print(f"打开文件: {filename}")
except FileNotFoundError:
print(f"文件不存在: {filename}")
# 处理所有打开的文件
for f in files:
content = f.read(100) # 读取前100个字符
print(f"文件 {f.name} 的前100字符: {content[:50]}...")
# 创建测试文件
for i in range(3):
with open(f"test_file_{i}.txt", "w") as f:
f.write(f"这是测试文件 {i} 的内容\n" * 10)
# 使用ExitStack处理多个文件
print("\n使用ExitStack处理多个文件:")
process_files([f"test_file_{i}.txt" for i in range(3)] + ["nonexistent.txt"])
# 清理测试文件
for i in range(3):
if os.path.exists(f"test_file_{i}.txt"):
os.remove(f"test_file_{i}.txt")
if os.path.exists("redirect_output.txt"):
os.remove("redirect_output.txt")
print("\n✅ 高级上下文管理器技巧演示完成")第三部分：异常处理------优雅地处理错误
3.1 Python异常体系
理解Python的异常层次结构：
python
# Python异常层次结构
print("Python异常层次结构:")
# 显示异常类的继承关系
def print_exception_hierarchy(exception_class, indent=0):
"""打印异常类的继承层次"""
print(" " * indent + exception_class.__name__)
for subclass in exception_class.__subclasses__():
print_exception_hierarchy(subclass, indent + 1)
# 从BaseException开始
print("BaseException (所有异常的基类):")
print_exception_hierarchy(BaseException)
# 常见的异常类型
print("\n常见异常类型示例:")
common_exceptions = {
"Exception": "所有非退出异常的基类",
"SystemExit": "解释器请求退出",
"KeyboardInterrupt": "用户中断执行（通常是Ctrl+C）",
"GeneratorExit": "生成器发生异常来通知退出",
"StopIteration": "迭代器没有更多的值",
"ArithmeticError": "所有算术计算错误的基类",
"FloatingPointError": "浮点计算错误",
"OverflowError": "数值运算超出最大限制",
"ZeroDivisionError": "除（或取模）零",
"AssertionError": "assert语句失败",
"AttributeError": "对象没有这个属性",
"BufferError": "缓冲区操作错误",
"EOFError": "没有内建输入，到达EOF标记",
"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": "在检测到不属于任何其他类别的错误时触发",
"NotImplementedError": "尚未实现的方法",
"RecursionError": "超过最大递归深度",
"SyntaxError": "语法错误",
"IndentationError": "缩进错误",
"TabError": "制表符和空格混合使用",
"SystemError": "解释器内部错误",
"TypeError": "操作或函数应用于不适当类型的对象",
"ValueError": "操作或函数接收到具有正确类型但不适当的值的参数",
"UnicodeError": "与Unicode相关的错误",
"UnicodeDecodeError": "Unicode解码错误",
"UnicodeEncodeError": "Unicode编码错误",
"UnicodeTranslateError": "Unicode转换错误",
"Warning": "警告的基类"
}
# 显示一些常见异常的描述
print("\n部分常见异常说明:")
for exc_name, description in list(common_exceptions.items())[:15]:
print(f" {exc_name:25} - {description}")3.2 基本的异常处理
python
# try-except基础
print("1. 基本的try-except语句")
# 示例1：处理除零错误
try:
result = 10 / 0
print(f"结果: {result}")
except ZeroDivisionError:
print("错误：不能除以零！")
# 示例2：处理多个异常
print("\n2. 处理多个异常")
def divide_numbers(a, b):
try:
result = a / b
print(f"{a} / {b} = {result}")
return result
except ZeroDivisionError:
print("错误：除数不能为零！")
except TypeError:
print("错误：参数类型不正确！")
except Exception as e:
print(f"未知错误: {type(e).__name__}: {e}")
# 测试
divide_numbers(10, 2) # 正常
divide_numbers(10, 0) # ZeroDivisionError
divide_numbers(10, "2") # TypeError
# 示例3：捕获异常对象
print("\n3. 捕获异常对象")
try:
file = open("nonexistent.txt", "r")
content = file.read()
except FileNotFoundError as e:
print(f"文件未找到错误:")
print(f" 错误类型: {type(e).__name__}")
print(f" 错误信息: {e}")
print(f" 文件名: {e.filename}")
print(f" 错误号: {e.errno}")
print(f" 错误消息: {e.strerror}")
# 示例4：使用else子句
print("\n4. 使用else子句")
def read_file_safely(filename):
try:
with open(filename, "r") as f:
content = f.read()
except FileNotFoundError:
print(f"文件 {filename} 不存在")
return None
except IOError as e:
print(f"读取文件 {filename} 时发生IO错误: {e}")
return None
else:
# 只有在try块没有引发异常时才执行
print(f"成功读取文件 {filename}")
return content
finally:
# 无论是否发生异常都会执行
print(f"文件读取操作完成: {filename}")
# 测试
read_file_safely("nonexistent.txt")
read_file_safely(__file__) # 读取当前文件
# 示例5：finally子句的用途
print("\n5. finally子句的用途")
def process_data(data):
"""模拟数据处理，演示finally的清理作用"""
resource = None
try:
print("分配资源...")
resource = "模拟的资源（如数据库连接）"
# 模拟数据处理
if not data:
raise ValueError("数据不能为空")
result = len(data) * 2
print(f"处理结果: {result}")
return result
except ValueError as e:
print(f"数据处理错误: {e}")
return None
finally:
# 无论是否发生异常，都会执行清理
if resource:
print(f"释放资源: {resource}")
print("清理完成")
# 测试
process_data([1, 2, 3])
process_data([])
print("\n✅ 基本异常处理演示完成")3.3 高级异常处理技巧
python
# 1. 异常链
print("1. 异常链（Exception Chaining）")
def process_file(filename):
"""处理文件，演示异常链"""
try:
with open(filename, "r") as f:
content = f.read()
# 模拟处理过程中的错误
if "error" in content:
raise ValueError("文件中包含'error'关键字")
return content
except FileNotFoundError as e:
# 使用raise ... from None隐藏原始异常
raise RuntimeError(f"无法处理文件: {filename}") from None
except IOError as e:
# 使用raise ... from e保留原始异常
raise RuntimeError(f"读取文件时发生错误: {filename}") from e
# 测试异常链
print("测试异常链（保留原始异常）:")
try:
process_file("nonexistent.txt")
except RuntimeError as e:
print(f"捕获到运行时错误: {e}")
if e.__cause__:
print(f"原始异常: {type(e.__cause__).__name__}: {e.__cause__}")
# 2. 自定义异常类
print("\n2. 自定义异常类")
class BankError(Exception):
"""银行相关异常的基类"""
def __init__(self, message, account_number=None):
super().__init__(message)
self.account_number = account_number
self.timestamp = __import__('datetime').datetime.now()
def __str__(self):
base_msg = super().__str__()
if self.account_number:
return f"[{self.timestamp}] 账户 {self.account_number}: {base_msg}"
return f"[{self.timestamp}] {base_msg}"
class InsufficientFundsError(BankError):
"""余额不足异常"""
pass
class AccountFrozenError(BankError):
"""账户冻结异常"""
pass
class InvalidTransactionError(BankError):
"""无效交易异常"""
pass
# 使用自定义异常
class BankAccount:
def __init__(self, account_number, balance=0):
self.account_number = account_number
self.balance = balance
self.is_frozen = False
def withdraw(self, amount):
if self.is_frozen:
raise AccountFrozenError("账户已被冻结", self.account_number)
if amount <= 0:
raise InvalidTransactionError("取款金额必须大于0", self.account_number)
if amount > self.balance:
raise InsufficientFundsError(
f"余额不足。当前余额: {self.balance}，请求取款: {amount}",
self.account_number
)
self.balance -= amount
return self.balance
def freeze(self):
self.is_frozen = True
def unfreeze(self):
self.is_frozen = False
# 测试自定义异常
print("测试自定义异常类:")
account = BankAccount("123456", 1000)
try:
account.freeze()
account.withdraw(500)
except BankError as e:
print(f"银行错误: {e}")
try:
account.unfreeze()
account.withdraw(1500)
except InsufficientFundsError as e:
print(f"余额不足错误: {e}")
print(f"账户: {e.account_number}")
print(f"时间: {e.timestamp}")
# 3. 异常处理的最佳实践
print("\n3. 异常处理的最佳实践")
def process_user_input_bad(user_input):
"""不好的异常处理示例"""
try:
# 过于宽泛的异常捕获
value = int(user_input)
result = 100 / value
return result
except:
# 捕获所有异常，隐藏问题
return None
def process_user_input_good(user_input):
"""好的异常处理示例"""
try:
value = int(user_input)
except ValueError:
# 明确处理特定异常
raise ValueError(f"无效的数字: {user_input}")
try:
result = 100 / value
except ZeroDivisionError:
# 明确处理除零错误
raise ValueError("除数不能为零")
return result
print("好的异常处理示例:")
try:
result = process_user_input_good("abc")
except ValueError as e:
print(f"预期中的错误: {e}")
try:
result = process_user_input_good("0")
except ValueError as e:
print(f"预期中的错误: {e}")
# 4. 使用异常进行控制流（谨慎使用）
print("\n4. 使用异常进行控制流")
# 通常不推荐使用异常进行正常的控制流，但有些情况下是合适的
class StopProcessing(Exception):
"""停止处理的信号异常"""
pass
def process_items(items):
"""处理项目列表，遇到特定条件时停止"""
results = []
for item in items:
try:
if item == "stop":
raise StopProcessing("遇到停止信号")
# 正常处理
processed = f"处理后的{item}"
results.append(processed)
except StopProcessing as e:
print(f"处理停止: {e}")
break # 跳出循环
return results
# 测试
items = ["apple", "banana", "stop", "orange", "grape"]
result = process_items(items)
print(f"处理结果: {result}")
# 5. 异常处理的性能考虑
print("\n5. 异常处理的性能考虑")
import timeit
# 测试异常处理对性能的影响
def with_exception(n):
"""使用异常处理"""
result = 0
for i in range(n):
try:
result += i / (i % 10) # 每10次会有一次除零错误
except ZeroDivisionError:
result += 0
return result
def without_exception(n):
"""使用条件判断避免异常"""
result = 0
for i in range(n):
divisor = i % 10
if divisor != 0:
result += i / divisor
else:
result += 0
return result
# 性能测试
n = 10000
time_with_exception = timeit.timeit(lambda: with_exception(n), number=100)
time_without_exception = timeit.timeit(lambda: without_exception(n), number=100)
print(f"测试 {n} 次迭代（100轮）:")
print(f"使用异常处理: {time_with_exception:.4f}秒")
print(f"使用条件判断: {time_without_exception:.4f}秒")
print(f"性能差异: {time_with_exception/time_without_exception:.2f}倍")
print("\n✅ 高级异常处理技巧演示完成")3.4 调试与日志记录
python
# 调试和日志记录
import logging
print("1. 基本的日志记录")
# 配置日志系统
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler("app.log", encoding="utf-8"),
logging.StreamHandler()
]
)
logger = logging.getLogger(__name__)
def process_data_with_logging(data):
"""使用日志记录处理数据"""
logger.info(f"开始处理数据，长度: {len(data)}")
try:
if not data:
logger.warning("接收到空数据")
return None
# 模拟数据处理
result = sum(data) / len(data)
logger.debug(f"计算结果: {result}")
return result
except TypeError as e:
logger.error(f"数据类型错误: {e}", exc_info=True)
return None
except ZeroDivisionError as e:
logger.error(f"除零错误（数据长度为零）: {e}")
return None
except Exception as e:
logger.exception(f"处理数据时发生未知错误: {e}")
return None
finally:
logger.info("数据处理完成")
# 测试日志记录
print("测试日志记录（查看控制台输出和app.log文件）:")
process_data_with_logging([1, 2, 3, 4, 5])
process_data_with_logging([])
process_data_with_logging("not a list")
print("\n2. 使用pdb进行调试")
def buggy_function(data):
"""有bug的函数，用于演示调试"""
result = 0
for i in range(len(data)):
# 这里有一个bug：当data[i]为0时会除零
result += 100 / data[i]
return result
# 传统调试方式：添加print语句
def debug_with_print(data):
"""使用print调试"""
result = 0
for i in range(len(data)):
print(f"处理第{i}个元素: data[{i}] = {data[i]}")
if data[i] == 0:
print(f"警告：第{i}个元素为零，跳过")
continue
result += 100 / data[i]
print(f"当前结果: {result}")
return result
# 使用pdb调试
import pdb
def debug_with_pdb(data):
"""使用pdb调试"""
result = 0
for i in range(len(data)):
# 设置断点
pdb.set_trace() # 程序会在这里暂停，进入pdb调试器
result += 100 / data[i]
return result
print("调试演示:")
# 小心运行这个，因为它会进入交互式调试器
# debug_with_pdb([1, 2, 0, 4])
# 更好的方式：使用断点函数（Python 3.7+）
def debug_with_breakpoint(data):
"""使用breakpoint()调试（Python 3.7+）"""
result = 0
for i in range(len(data)):
# 这等价于 import pdb; pdb.set_trace()
breakpoint() # 可以根据环境变量控制是否启用
result += 100 / data[i]
return result
print("\n3. 断言（Assertions）用于调试")
def calculate_discount(price, discount_rate):
"""计算折扣价，使用断言验证前提条件"""
# 使用断言验证输入有效性（仅在调试模式生效）
assert price >= 0, f"价格不能为负: {price}"
assert 0 <= discount_rate <= 1, f"折扣率必须在0-1之间: {discount_rate}"
# 计算折扣
discounted_price = price * (1 - discount_rate)
# 后置条件断言
assert discounted_price >= 0, f"折扣价不能为负: {discounted_price}"
assert discounted_price <= price, f"折扣价不能超过原价: {discounted_price} > {price}"
return discounted_price
# 测试断言
print("测试断言（正常情况）:")
try:
result = calculate_discount(100, 0.2)
print(f"折扣价: {result}")
except AssertionError as e:
print(f"断言失败: {e}")
print("\n测试断言（错误情况）:")
try:
result = calculate_discount(-100, 0.2)
print(f"折扣价: {result}")
except AssertionError as e:
print(f"断言失败: {e}")
# 注意：在生产环境中，断言可能被禁用（使用-O选项运行Python）
print("\n注意：可以使用 -O 选项运行Python来禁用断言")
# 清理日志文件
if os.path.exists("app.log"):
os.remove("app.log")
print("\n✅ 已清理日志文件: app.log")
print("\n✅ 调试与日志记录演示完成")第四部分：实战项目------日志分析工具
现在，让我们创建一个完整的日志分析工具，综合应用文件操作、异常处理和上下文管理器：
python
"""
日志分析工具 v6.0
功能：
1. 读取和解析多种格式的日志文件
2. 分析错误、警告和信息级别的日志
3. 生成统计报告和可视化图表
4. 实时监控日志文件
5. 日志归档和压缩
6. 异常处理和恢复机制
"""
import os
import re
import json
import gzip
import shutil
from datetime import datetime, timedelta
from collections import defaultdict, Counter
from pathlib import Path
from typing import Dict, List, Tuple, Optional, Any, Generator
import logging
from contextlib import contextmanager
# 设置日志
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger("LogAnalyzer")
# 自定义异常
class LogAnalyzerError(Exception):
"""日志分析器异常基类"""
pass
class LogFormatError(LogAnalyzerError):
"""日志格式错误"""
pass
class LogFileError(LogAnalyzerError):
"""日志文件错误"""
pass
# 日志解析器基类
class LogParser:
"""日志解析器基类"""
# 常见日志级别模式
LOG_LEVELS = {
'ERROR': r'(?i)(error|err|e\/)',
'WARNING': r'(?i)(warn|warning|w\/)',
'INFO': r'(?i)(info|information|i\/)',
'DEBUG': r'(?i)(debug|dbg|d\/)',
'CRITICAL': r'(?i)(critical|crit|c\/)'
}
# 常见时间格式模式
TIME_FORMATS = [
r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}', # 2023-10-01 12:30:45
r'\d{2}/\d{2}/\d{4} \d{2}:\d{2}:\d{2}', # 01/10/2023 12:30:45
r'\w{3} \w{3} \d{2} \d{2}:\d{2}:\d{2} \d{4}', # Tue Oct 01 12:30:45 2023
]
def __init__(self):
self.stats = {
'total_lines': 0,
'parsed_lines': 0,
'errors': 0,
'warnings': 0,
'infos': 0,
'debugs': 0,
'criticals': 0,
'unknown_levels': 0
}
self.log_entries = []
def parse_line(self, line: str, line_num: int) -> Optional[Dict]:
"""解析单行日志（子类必须实现）"""
raise NotImplementedError("子类必须实现parse_line方法")
def detect_log_level(self, line: str) -> str:
"""检测日志级别"""
for level, pattern in self.LOG_LEVELS.items():
if re.search(pattern, line):
return level
return 'UNKNOWN'
def parse_file(self, filepath: str) -> List[Dict]:
"""解析整个文件"""
entries = []
try:
with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
for line_num, line in enumerate(f, 1):
self.stats['total_lines'] += 1
# 跳过空行
if not line.strip():
continue
try:
entry = self.parse_line(line.strip(), line_num)
if entry:
entries.append(entry)
self.stats['parsed_lines'] += 1
# 更新统计
level = entry.get('level', 'UNKNOWN')
if level in self.stats:
self.stats[level.lower() + 's'] += 1
else:
self.stats['unknown_levels'] += 1
except Exception as e:
logger.warning(f"解析第{line_num}行时出错: {e}")
continue
self.log_entries.extend(entries)
logger.info(f"成功解析文件: {filepath}, 有效行数: {len(entries)}/{self.stats['total_lines']}")
return entries
except FileNotFoundError:
raise LogFileError(f"文件不存在: {filepath}")
except PermissionError:
raise LogFileError(f"没有权限读取文件: {filepath}")
except UnicodeDecodeError:
raise LogFileError(f"文件编码错误: {filepath}")
except Exception as e:
raise LogAnalyzerError(f"解析文件时出错: {e}")
# 通用日志解析器（支持多种格式）
class GenericLogParser(LogParser):
"""通用日志解析器"""
def __init__(self, pattern: str = None):
super().__init__()
self.pattern = pattern or self._detect_pattern()
def _detect_pattern(self) -> str:
"""自动检测日志模式"""
# 默认模式：[时间] [级别] [模块] 消息
return r'(?P<timestamp>.*?) \[?(?P<level>\w+)\]? (?P<module>\S+)?:?\s*(?P<message>.*)'
def parse_line(self, line: str, line_num: int) -> Optional[Dict]:
"""解析单行日志"""
# 尝试匹配模式
match = re.match(self.pattern, line)
if not match:
# 如果没有匹配到，使用简单解析
level = self.detect_log_level(line)
return {
'line_number': line_num,
'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
'level': level,
'message': line,
'raw': line
}
# 提取匹配的组
groups = match.groupdict()
# 确保必要的字段
entry = {
'line_number': line_num,
'raw': line
}
# 处理时间戳
timestamp = groups.get('timestamp')
if timestamp:
entry['timestamp'] = timestamp.strip()
else:
entry['timestamp'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
# 处理级别
level = groups.get('level')
if not level:
level = self.detect_log_level(line)
entry['level'] = level.upper()
# 处理模块/来源
module = groups.get('module')
if module:
entry['module'] = module
# 处理消息
message = groups.get('message')
if message:
entry['message'] = message.strip()
else:
# 如果没有消息，使用整行
entry['message'] = line
return entry
# Apache/Nginx日志解析器
class WebLogParser(LogParser):
"""Web服务器日志解析器（Apache/Nginx通用格式）"""
COMMON_LOG_FORMAT = r'(?P<ip>\S+) \S+ \S+ \[(?P<timestamp>.*?)\] "(?P<method>\S+) (?P<url>\S+) (?P<protocol>.*?)" (?P<status>\d{3}) (?P<size>\S+)'
COMBINED_LOG_FORMAT = r'(?P<ip>\S+) \S+ \S+ \[(?P<timestamp>.*?)\] "(?P<method>\S+) (?P<url>\S+) (?P<protocol>.*?)" (?P<status>\d{3}) (?P<size>\S+) "(?P<referrer>.*?)" "(?P<user_agent>.*?)"'
def __init__(self, log_format: str = 'combined'):
super().__init__()
if log_format == 'common':
self.pattern = self.COMMON_LOG_FORMAT
else:
self.pattern = self.COMBINED_LOG_FORMAT
# 扩展统计信息
self.stats.update({
'status_codes': defaultdict(int),
'methods': defaultdict(int),
'top_ips': Counter(),
'top_urls': Counter(),
'top_user_agents': Counter()
})
def parse_line(self, line: str, line_num: int) -> Optional[Dict]:
"""解析单行Web日志"""
match = re.match(self.pattern, line)
if not match:
# 如果不是标准格式，使用通用解析
generic_parser = GenericLogParser()
return generic_parser.parse_line(line, line_num)
groups = match.groupdict()
# 构建日志条目
entry = {
'line_number': line_num,
'ip': groups.get('ip', ''),
'timestamp': groups.get('timestamp', ''),
'method': groups.get('method', ''),
'url': groups.get('url', ''),
'protocol': groups.get('protocol', ''),
'status': int(groups.get('status', 0)) if groups.get('status') else 0,
'size': groups.get('size', '0'),
'raw': line
}
# 处理可选字段
if 'referrer' in groups:
entry['referrer'] = groups['referrer']
if 'user_agent' in groups:
entry['user_agent'] = groups['user_agent']
# 检测日志级别（基于状态码）
status = entry['status']
if 500 <= status <= 599:
entry['level'] = 'ERROR'
elif 400 <= status <= 499:
entry['level'] = 'WARNING'
elif 300 <= status <= 399:
entry['level'] = 'INFO'
elif 200 <= status <= 299:
entry['level'] = 'INFO'
else:
entry['level'] = 'UNKNOWN'
# 更新Web特定统计
self.stats['status_codes'][status] += 1
self.stats['methods'][entry['method']] += 1
self.stats['top_ips'][entry['ip']] += 1
self.stats['top_urls'][entry['url']] += 1
if 'user_agent' in entry:
self.stats['top_user_agents'][entry['user_agent']] += 1
return entry
# 日志分析器主类
class LogAnalyzer:
"""日志分析器主类"""
def __init__(self, log_dir: str = "."):
self.log_dir = Path(log_dir)
self.parsers = {
'generic': GenericLogParser(),
'web': WebLogParser('combined')
}
self.analyses = {}
self.reports_dir = self.log_dir / "reports"
self.reports_dir.mkdir(exist_ok=True)
logger.info(f"初始化日志分析器，日志目录: {self.log_dir}")
@contextmanager
def safe_file_operation(self, filepath: Path, mode: str = 'r'):
"""安全的文件操作上下文管理器"""
file = None
try:
# 处理压缩文件
if filepath.suffix == '.gz':
file = gzip.open(filepath, mode + 't', encoding='utf-8')
else:
file = open(filepath, mode, encoding='utf-8')
yield file
except FileNotFoundError:
logger.error(f"文件不存在: {filepath}")
raise LogFileError(f"文件不存在: {filepath}")
except PermissionError:
logger.error(f"没有权限访问文件: {filepath}")
raise LogFileError(f"没有权限访问文件: {filepath}")
except Exception as e:
logger.error(f"文件操作错误: {e}")
raise LogFileError(f"文件操作错误: {e}")
finally:
if file:
file.close()
def detect_log_type(self, filepath: Path) -> str:
"""检测日志类型"""
# 基于文件名和内容检测
filename = filepath.name.lower()
# 检查文件名关键词
if any(keyword in filename for keyword in ['access', 'nginx', 'apache', 'web']):
return 'web'
# 检查文件内容（抽样）
try:
with self.safe_file_operation(filepath) as f:
# 读取前10行进行检测
sample_lines = []
for i, line in enumerate(f):
if i >= 10:
break
sample_lines.append(line)
sample_text = '\n'.join(sample_lines)
# 检测Web日志格式
if re.search(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}.*HTTP/\d\.\d.*\d{3}', sample_text):
return 'web'
# 检测JSON日志
if sample_lines and sample_lines[0].strip().startswith('{'):
try:
json.loads(sample_lines[0].strip())
return 'json'
except:
pass
except:
pass
# 默认使用通用解析器
return 'generic'
def analyze_file(self, filepath: str, parser_type: str = None) -> Dict:
"""分析单个日志文件"""
path = Path(filepath)
if not path.exists():
raise LogFileError(f"文件不存在: {filepath}")
# 自动检测日志类型
if not parser_type:
parser_type = self.detect_log_type(path)
parser = self.parsers.get(parser_type, self.parsers['generic'])
logger.info(f"开始分析文件: {filepath} (类型: {parser_type})")
try:
# 解析文件
entries = parser.parse_file(str(path))
# 生成分析结果
analysis = {
'filename': filepath,
'parser_type': parser_type,
'file_size': path.stat().st_size,
'file_mtime': datetime.fromtimestamp(path.stat().st_mtime),
'entries_count': len(entries),
'stats': parser.stats.copy(),
'entries': entries[:1000], # 只保存前1000条用于报告
'analysis_time': datetime.now()
}
# 保存分析结果
self.analyses[filepath] = analysis
# 生成报告
self.generate_report(analysis)
logger.info(f"文件分析完成: {filepath}, 解析条目: {len(entries)}")
return analysis
except Exception as e:
logger.error(f"分析文件时出错: {filepath} - {e}")
raise
def analyze_directory(self, pattern: str = "*.log") -> Dict[str, Dict]:
"""分析目录下的所有日志文件"""
analyses = {}
# 查找所有日志文件
log_files = list(self.log_dir.glob(pattern))
log_files.extend(self.log_dir.glob("*.log.*")) # 包含轮转日志
log_files.extend(self.log_dir.glob("*.txt")) # 文本文件
# 也查找压缩的日志文件
log_files.extend(self.log_dir.glob("*.gz"))
log_files.extend(self.log_dir.glob("*.zip"))
logger.info(f"在目录 {self.log_dir} 中找到 {len(log_files)} 个日志文件")
for log_file in log_files:
try:
if log_file.is_file():
analysis = self.analyze_file(str(log_file))
analyses[str(log_file)] = analysis
except LogAnalyzerError as e:
logger.warning(f"跳过文件 {log_file}: {e}")
continue
except Exception as e:
logger.error(f"分析文件 {log_file} 时发生未知错误: {e}")
continue
return analyses
def generate_report(self, analysis: Dict) -> str:
"""生成分析报告"""
filename = Path(analysis['filename']).name
report_file = self.reports_dir / f"{filename}_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
try:
with open(report_file, 'w', encoding='utf-8') as f:
# 报告头部
f.write("=" * 80 + "\n")
f.write(f"日志分析报告\n")
f.write("=" * 80 + "\n\n")
f.write(f"文件: {analysis['filename']}\n")
f.write(f"大小: {analysis['file_size']:,} 字节\n")
f.write(f"修改时间: {analysis['file_mtime']}\n")
f.write(f"分析时间: {analysis['analysis_time']}\n")
f.write(f"解析器类型: {analysis['parser_type']}\n")
f.write(f"总条目数: {analysis['entries_count']:,}\n\n")
# 统计信息
stats = analysis['stats']
f.write("-" * 80 + "\n")
f.write("统计摘要\n")
f.write("-" * 80 + "\n\n")
f.write(f"总行数: {stats['total_lines']:,}\n")
f.write(f"有效解析行数: {stats['parsed_lines']:,}\n")
f.write(f"解析成功率: {(stats['parsed_lines']/stats['total_lines']*100 if stats['total_lines']>0 else 0):.1f}%\n\n")
f.write("日志级别分布:\n")
f.write(f" CRITICAL: {stats.get('criticals', 0):,}\n")
f.write(f" ERROR: {stats.get('errors', 0):,}\n")
f.write(f" WARNING: {stats.get('warnings', 0):,}\n")
f.write(f" INFO: {stats.get('infos', 0):,}\n")
f.write(f" DEBUG: {stats.get('debugs', 0):,}\n")
f.write(f" UNKNOWN: {stats.get('unknown_levels', 0):,}\n\n")
# Web特定统计
if analysis['parser_type'] == 'web':
f.write("-" * 80 + "\n")
f.write("Web访问统计\n")
f.write("-" * 80 + "\n\n")
# 状态码分布
if 'status_codes' in stats:
f.write("HTTP状态码分布:\n")
for code, count in sorted(stats['status_codes'].items()):
f.write(f" {code}: {count:,}\n")
f.write("\n")
# 请求方法分布
if 'methods' in stats:
f.write("HTTP方法分布:\n")
for method, count in sorted(stats['methods'].items()):
f.write(f" {method}: {count:,}\n")
f.write("\n")
# 顶级IP地址
if 'top_ips' in stats:
f.write("访问最多的IP地址 (前10):\n")
for ip, count in stats['top_ips'].most_common(10):
f.write(f" {ip}: {count:,}\n")
f.write("\n")
# 顶级URL
if 'top_urls' in stats:
f.write("访问最多的URL (前10):\n")
for url, count in stats['top_urls'].most_common(10):
# 缩短过长的URL
display_url = url if len(url) <= 60 else url[:57] + "..."
f.write(f" {display_url:60} : {count:,}\n")
f.write("\n")
# 错误摘要（如果有）
if stats.get('errors', 0) > 0 or stats.get('criticals', 0) > 0:
f.write("-" * 80 + "\n")
f.write("错误和严重日志摘要\n")
f.write("-" * 80 + "\n\n")
error_entries = [
entry for entry in analysis['entries']
if entry.get('level') in ['ERROR', 'CRITICAL']
][:20] # 只显示前20个
for entry in error_entries:
f.write(f"行号: {entry.get('line_number')}\n")
f.write(f"时间: {entry.get('timestamp', 'N/A')}\n")
f.write(f"级别: {entry.get('level', 'UNKNOWN')}\n")
f.write(f"消息: {entry.get('message', '')[:200]}\n")
f.write(f"{'-'*40}\n")
# 原始日志样本
f.write("-" * 80 + "\n")
f.write("日志样本 (前10行)\n")
f.write("-" * 80 + "\n\n")
for entry in analysis['entries'][:10]:
f.write(f"行 {entry.get('line_number')}: {entry.get('raw', '')[:200]}\n")
logger.info(f"报告已生成: {report_file}")
return str(report_file)
except Exception as e:
logger.error(f"生成报告时出错: {e}")
raise
def find_errors(self, hours_back: int = 24) -> List[Dict]:
"""查找最近指定小时内的错误"""
errors = []
cutoff_time = datetime.now() - timedelta(hours=hours_back)
for analysis in self.analyses.values():
for entry in analysis.get('entries', []):
# 尝试解析时间戳
timestamp_str = entry.get('timestamp')
if not timestamp_str:
continue
try:
# 尝试多种时间格式
for fmt in ['%Y-%m-%d %H:%M:%S', '%d/%m/%Y %H:%M:%S', '%b %d %H:%M:%S']:
try:
entry_time = datetime.strptime(timestamp_str[:19], fmt)
# 如果年份缺失，添加当前年份
if entry_time.year == 1900:
entry_time = entry_time.replace(year=datetime.now().year)
if entry_time >= cutoff_time and entry.get('level') in ['ERROR', 'CRITICAL']:
errors.append({
'file': analysis['filename'],
'time': entry_time,
'level': entry.get('level'),
'message': entry.get('message', ''),
'line': entry.get('line_number')
})
break
except ValueError:
continue
except Exception:
continue
# 按时间排序
errors.sort(key=lambda x: x['time'], reverse=True)
return errors[:100] # 只返回前100个
def archive_old_logs(self, days_old: int = 7, compress: bool = True) -> List[str]:
"""归档旧日志文件"""
archived = []
cutoff_time = datetime.now() - timedelta(days=days_old)
# 创建归档目录
archive_dir = self.log_dir / "archive"
archive_dir.mkdir(exist_ok=True)
# 查找旧日志文件
for log_file in self.log_dir.glob("*.log"):
try:
# 检查文件修改时间
mtime = datetime.fromtimestamp(log_file.stat().st_mtime)
if mtime < cutoff_time:
# 归档文件
archive_name = log_file.name
if compress:
archive_name += ".gz"
archive_path = archive_dir / archive_name
if compress:
# 压缩文件
with open(log_file, 'rb') as f_in:
with gzip.open(archive_path, 'wb') as f_out:
shutil.copyfileobj(f_in, f_out)
else:
# 直接移动
shutil.move(log_file, archive_path)
archived.append(str(log_file))
logger.info(f"已归档: {log_file} -> {archive_path}")
except Exception as e:
logger.error(f"归档文件 {log_file} 时出错: {e}")
return archived
def monitor_log_file(self, filepath: str, callback=None) -> Generator[Dict, None, None]:
"""监控日志文件（实时尾随）"""
import time
path = Path(filepath)
if not path.exists():
raise LogFileError(f"文件不存在: {filepath}")
# 记录上次读取的位置
last_position = path.stat().st_size
logger.info(f"开始监控日志文件: {filepath}")
try:
while True:
try:
with self.safe_file_operation(path) as f:
# 移动到上次读取的位置
f.seek(last_position)
# 读取新内容
new_lines = f.readlines()
if new_lines:
# 更新位置
last_position = f.tell()
# 解析新行
parser = GenericLogParser()
for line in new_lines:
try:
entry = parser.parse_line(line.strip(), 0)
if entry:
# 调用回调函数（如果有）
if callback and callable(callback):
callback(entry)
# 生成器返回
yield entry
except Exception as e:
logger.warning(f"解析监控行时出错: {e}")
# 短暂休眠
time.sleep(1)
except KeyboardInterrupt:
logger.info("监控被用户中断")
break
except Exception as e:
logger.error(f"监控时出错: {e}")
time.sleep(5) # 出错后等待更久
finally:
logger.info(f"停止监控日志文件: {filepath}")
def export_to_json(self, output_file: str = None) -> str:
"""导出分析结果到JSON文件"""
if not output_file:
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
output_file = self.reports_dir / f"log_analysis_{timestamp}.json"
export_data = {
'export_time': datetime.now().isoformat(),
'log_dir': str(self.log_dir),
'analyses_count': len(self.analyses),
'analyses': {}
}
# 准备导出数据（去掉原始日志条目以减少文件大小）
for filename, analysis in self.analyses.items():
export_analysis = analysis.copy()
export_analysis['entries'] = [] # 不导出原始条目
export_data['analyses'][filename] = export_analysis
try:
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(export_data, f, indent=2, default=str)
logger.info(f"分析结果已导出到: {output_file}")
return str(output_file)
except Exception as e:
logger.error(f"导出到JSON时出错: {e}")
raise
def cleanup_old_reports(self, days_old: int = 30):
"""清理旧的报告文件"""
cutoff_time = datetime.now() - timedelta(days=days_old)
cleaned = []
for report_file in self.reports_dir.glob("*_report_*.txt"):
try:
mtime = datetime.fromtimestamp(report_file.stat().st_mtime)
if mtime < cutoff_time:
report_file.unlink()
cleaned.append(str(report_file))
except Exception as e:
logger.warning(f"清理报告文件 {report_file} 时出错: {e}")
logger.info(f"清理了 {len(cleaned)} 个旧报告文件")
return cleaned
# 交互式日志分析工具
def interactive_log_analyzer():
"""交互式日志分析界面"""
analyzer = None
print("\n" + "="*80)
print(" 日志分析工具 v6.0")
print("="*80)
while True:
print("\n主菜单:")
print("1. 初始化分析器（设置日志目录）")
print("2. 分析单个日志文件")
print("3. 分析目录下的所有日志文件")
print("4. 查看最近错误")
print("5. 归档旧日志文件")
print("6. 实时监控日志文件")
print("7. 导出分析结果")
print("8. 清理旧报告")
print("0. 退出")
print("-"*80)
if analyzer:
print(f"当前日志目录: {analyzer.log_dir}")
print(f"已分析文件数: {len(analyzer.analyses)}")
else:
print("提示: 请先选择1初始化分析器")
print("-"*80)
choice = input("请选择操作 (0-8): ").strip()
if choice == "0":
print("👋 感谢使用日志分析工具，再见！")
break
elif choice == "1":
log_dir = input("请输入日志目录路径 (直接回车使用当前目录): ").strip()
if not log_dir:
log_dir = "."
try:
analyzer = LogAnalyzer(log_dir)
print(f"✅ 分析器初始化成功，日志目录: {analyzer.log_dir}")
except Exception as e:
print(f"❌ 初始化失败: {e}")
elif choice == "2":
if not analyzer:
print("❌ 请先初始化分析器")
continue
filepath = input("请输入日志文件路径: ").strip()
if not filepath:
print("❌ 文件路径不能为空")
continue
try:
analysis = analyzer.analyze_file(filepath)
print(f"✅ 文件分析完成!")
print(f" 文件: {analysis['filename']}")
print(f" 大小: {analysis['file_size']:,} 字节")
print(f" 条目数: {analysis['entries_count']:,}")
print(f" 报告文件: {analyzer.reports_dir}/")
except LogAnalyzerError as e:
print(f"❌ 分析失败: {e}")
except Exception as e:
print(f"❌ 发生未知错误: {e}")
elif choice == "3":
if not analyzer:
print("❌ 请先初始化分析器")
continue
pattern = input("请输入文件模式 (如 *.log, 直接回车使用默认): ").strip()
if not pattern:
pattern = "*.log"
print(f"正在分析目录 {analyzer.log_dir} 中的 {pattern} 文件...")
try:
analyses = analyzer.analyze_directory(pattern)
print(f"✅ 目录分析完成!")
print(f" 分析文件数: {len(analyses)}")
if analyses:
total_errors = sum(a['stats'].get('errors', 0) for a in analyses.values())
total_warnings = sum(a['stats'].get('warnings', 0) for a in analyses.values())
print(f" 总错误数: {total_errors}")
print(f" 总警告数: {total_warnings}")
except Exception as e:
print(f"❌ 分析失败: {e}")
elif choice == "4":
if not analyzer:
print("❌ 请先初始化分析器")
continue
try:
hours = input("查看最近多少小时内的错误? (直接回车使用24小时): ").strip()
hours = int(hours) if hours else 24
errors = analyzer.find_errors(hours)
if not errors:
print(f"最近 {hours} 小时内没有发现错误")
else:
print(f"\n最近 {hours} 小时内的错误 ({len(errors)}个):")
print("-"*100)
for i, error in enumerate(errors[:20], 1): # 只显示前20个
print(f"{i:2}. 文件: {Path(error['file']).name}")
print(f" 时间: {error['time']}")
print(f" 级别: {error['level']}")
print(f" 消息: {error['message'][:100]}")
print()
if len(errors) > 20:
print(f"... 还有 {len(errors)-20} 个错误未显示")
except Exception as e:
print(f"❌ 查找错误失败: {e}")
elif choice == "5":
if not analyzer:
print("❌ 请先初始化分析器")
continue
try:
days = input("归档多少天前的日志? (直接回车使用7天): ").strip()
days = int(days) if days else 7
compress_input = input("是否压缩归档? (y/n, 直接回车使用是): ").strip().lower()
compress = compress_input != 'n'
print(f"正在归档 {days} 天前的日志文件...")
archived = analyzer.archive_old_logs(days, compress)
if archived:
print(f"✅ 已归档 {len(archived)} 个文件:")
for file in archived[:5]: # 只显示前5个
print(f" - {file}")
if len(archived) > 5:
print(f" ... 还有 {len(archived)-5} 个")
else:
print("没有需要归档的文件")
except Exception as e:
print(f"❌ 归档失败: {e}")
elif choice == "6":
if not analyzer:
print("❌ 请先初始化分析器")
continue
filepath = input("请输入要监控的日志文件路径: ").strip()
if not filepath:
print("❌ 文件路径不能为空")
continue
print(f"开始监控文件: {filepath}")
print("按 Ctrl+C 停止监控")
print("-"*80)
try:
def handle_new_entry(entry):
"""处理新日志条目的回调函数"""
if entry.get('level') in ['ERROR', 'CRITICAL']:
print(f"🚨 [{entry.get('level')}] {entry.get('timestamp')} - {entry.get('message')[:100]}")
elif entry.get('level') == 'WARNING':
print(f"⚠️ [{entry.get('level')}] {entry.get('message')[:80]}")
else:
# 对于INFO/DEBUG，可以选择性显示
pass
# 开始监控
for entry in analyzer.monitor_log_file(filepath, handle_new_entry):
pass # 生成器会持续产生数据
except KeyboardInterrupt:
print("\n监控已停止")
except Exception as e:
print(f"❌ 监控失败: {e}")
elif choice == "7":
if not analyzer:
print("❌ 请先初始化分析器")
continue
try:
output_file = input("输出文件路径 (直接回车使用默认): ").strip()
if output_file:
exported = analyzer.export_to_json(output_file)
else:
exported = analyzer.export_to_json()
print(f"✅ 分析结果已导出到: {exported}")
except Exception as e:
print(f"❌ 导出失败: {e}")
elif choice == "8":
if not analyzer:
print("❌ 请先初始化分析器")
continue
try:
days = input("清理多少天前的报告? (直接回车使用30天): ").strip()
days = int(days) if days else 30
cleaned = analyzer.cleanup_old_reports(days)
print(f"✅ 清理了 {len(cleaned)} 个旧报告文件")
except Exception as e:
print(f"❌ 清理失败: {e}")
else:
print("❌ 无效选择，请重新输入")
# 运行日志分析工具
if __name__ == "__main__":
# 创建一些示例日志文件用于演示
print("正在创建示例日志文件...")
# 创建目录
log_dir = Path("example_logs")
log_dir.mkdir(exist_ok=True)
# 创建通用日志文件
generic_log = log_dir / "application.log"
with open(generic_log, "w", encoding="utf-8") as f:
f.write("2023-10-01 10:30:15 [INFO] 应用程序启动\n")
f.write("2023-10-01 10:30:20 [DEBUG] 加载配置文件\n")
f.write("2023-10-01 10:31:05 [WARNING] 配置项缺失，使用默认值\n")
f.write("2023-10-01 10:35:12 [ERROR] 数据库连接失败\n")
f.write("2023-10-01 10:35:30 [INFO] 尝试重新连接\n")
f.write("2023-10-01 10:36:00 [INFO] 连接恢复\n")
f.write("2023-10-01 10:40:00 [CRITICAL] 内存不足，应用程序即将退出\n")
# 创建Web访问日志文件
web_log = log_dir / "access.log"
with open(web_log, "w", encoding="utf-8") as f:
f.write('192.168.1.1 - - [01/Oct/2023:10:30:15 +0800] "GET /index.html HTTP/1.1" 200 1234\n')
f.write('192.168.1.2 - - [01/Oct/2023:10:30:20 +0800] "POST /login HTTP/1.1" 200 567\n')
f.write('192.168.1.3 - - [01/Oct/2023:10:31:05 +0800] "GET /admin HTTP/1.1" 403 234\n')
f.write('192.168.1.1 - - [01/Oct/2023:10:35:12 +0800] "GET /api/data HTTP/1.1" 500 123\n')
f.write('192.168.1.4 - - [01/Oct/2023:10:35:30 +0800] "GET /static/css/style.css HTTP/1.1" 200 4567\n')
print("示例日志文件创建完成!")
print(f"通用日志: {generic_log}")
print(f"Web访问日志: {web_log}")
print("-"*80)
# 运行交互式分析工具
interactive_log_analyzer()
# 清理示例文件
print("\n清理示例文件...")
shutil.rmtree(log_dir, ignore_errors=True)
print("✅ 示例文件已清理")第五部分：总结与下一步
本章要点回顾
通过本章学习，你已经掌握了：
- ✅ 文件操作基础：打开、读取、写入、关闭文件的各种方法
- ✅ 文件模式与编码：理解不同文件模式的区别和编码的重要性
- ✅ 二进制文件处理：处理图片、视频等非文本文件
- ✅ 上下文管理器：使用with语句安全管理资源
- ✅ 自定义上下文管理器：创建自己的资源管理类
- ✅ 异常处理基础：try-except-else-finally的完整使用
- ✅ 异常体系结构：理解Python异常类的层次结构
- ✅ 自定义异常：创建具有业务含义的异常类
- ✅ 调试与日志记录：使用pdb调试和logging记录
- ✅ 实战项目：创建了一个功能完整的日志分析工具
编程思维培养
- 防御式编程：预见并处理可能的错误和异常
- 资源管理思维：确保文件、连接等资源正确释放
- 错误处理策略：区分可恢复错误和不可恢复错误
- 日志驱动调试：使用日志而不是print进行调试
- 工程化思维：构建健壮、可维护的生产级代码
最佳实践总结
python
"""
文件操作最佳实践：
1. 总是使用with语句管理文件资源
2. 明确指定文件编码（推荐utf-8）
3. 处理文件不存在等异常情况
4. 大文件使用迭代或分块读取
5. 二进制文件使用二进制模式
异常处理最佳实践：
1. 只捕获你知道如何处理的异常
2. 异常信息应该有助于调试
3. 使用特定的异常类型而不是通用的Exception
4. 在finally块中清理资源
5. 自定义异常要有明确的业务含义
日志记录最佳实践：
1. 使用logging模块而不是print
2. 合理设置日志级别
3. 日志信息要包含足够的上下文
4. 敏感信息不要记录在日志中
5. 定期归档和清理日志文件
"""下一步学习路径
在下一篇文章中，我们将深入面向对象编程基础：
- 类与对象：理解面向对象的核心概念
- 属性与方法：实例属性、类属性、实例方法、类方法、静态方法
- 继承与多态：代码复用的面向对象方式
- 特殊方法 ：
__init__、__str__、__repr__等魔法方法 - 封装与属性访问控制：公有、保护、私有成员
- 实战项目：图书馆管理系统
练习挑战
- 挑战1：为日志分析工具添加数据库支持
- 挑战2：实现一个完整的文件同步工具
- 挑战3：创建一个配置管理系统
- 挑战4：实现一个简单的版本控制系统
- 挑战5：构建一个带异常恢复的数据处理管道
名言共勉
"优秀的程序员与普通程序员的区别不在于是否编写无bug的代码，而在于如何优雅地处理不可避免的错误。" ------ 编程界共识
你已经从一个处理理想情况的程序员，成长为能够构建健壮、可靠应用程序的开发者。文件操作和异常处理是工业级编程的基石，掌握它们意味着你的代码已经准备好面对真实世界的挑战。
今日挑战：改进日志分析工具，添加以下功能：
- 支持更多日志格式（JSON、XML、CSV）
- 添加Web界面实时展示分析结果
- 实现日志异常检测和警报功能
- 添加性能监控和优化建议
- 支持分布式日志收集和分析
保持学习，你已经具备了构建企业级应用的基础能力。文件操作和异常处理的技能将在你未来的每个项目中发挥作用。有任何问题或完成了挑战，欢迎继续交流！