Python工程化必备：文件、JSON、异常与日志处理实战

1. Python工程化基础核心四件套

刚接触Python时，我们往往只关注功能实现，却忽略了工程化必备的四个基础组件：文件读写、JSON处理、异常捕获和日志记录。这些看似简单的模块，在实际项目中能避免80%的"低级错误"。最近重构一个老旧数据处理系统时，我发现原始代码库竟然用字符串拼接生成JSON，用print调试错误，这让我意识到有必要系统梳理这些基础技能的正确打开方式。

2. 文件读写：从基础操作到性能优化

2.1 文件操作基础模式

Python文件操作主要涉及open()函数的模式选择：

python复制# 安全读取示例
with open('data.txt', 'r', encoding='utf-8') as f:
    content = f.read()  # 小文件一次性读取

常见模式包括：

• 'r'：只读（默认）
• 'w'：写入（会清空原有内容）
• 'a'：追加
• 'b'：二进制模式
• '+'：读写模式

重要提示：务必使用with语句管理文件对象，它能自动处理文件关闭，避免资源泄漏

2.2 大文件处理技巧

处理GB级日志文件时，切忌直接read()：

python复制# 高效逐行处理
with open('huge.log', 'r') as f:
    for line in f:  # 利用文件对象的迭代特性
        process_line(line)

# 分块读取方案
chunk_size = 1024*1024  # 1MB
with open('large.bin', 'rb') as f:
    while chunk := f.read(chunk_size):
        process_chunk(chunk)

2.3 路径处理最佳实践

避免硬编码路径，推荐使用pathlib：

python复制from pathlib import Path

config_path = Path('config') / 'settings.ini'  # 自动处理路径分隔符
if not config_path.exists():
    config_path.parent.mkdir(parents=True, exist_ok=True)
    
content = config_path.read_text(encoding='utf-8')

3. JSON处理：从基础到高级技巧

3.1 基本序列化与反序列化

python复制import json

data = {'name': 'Alice', 'score': 95.5}

# 序列化
json_str = json.dumps(data, ensure_ascii=False, indent=2)  # 中文不转码

# 反序列化
restored = json.loads(json_str)

3.2 文件JSON操作

python复制# 写入JSON文件
with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, ensure_ascii=False)

# 读取JSON文件
with open('data.json', 'r', encoding='utf-8') as f:
    loaded = json.load(f)

3.3 高级JSON技巧

处理特殊数据类型（如datetime）：

python复制from datetime import datetime

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        return super().default(obj)

json.dumps({'time': datetime.now()}, cls=CustomEncoder)

4. 异常处理的艺术

4.1 基础try-except结构

python复制try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error occurred: {e}")
    result = float('inf')  # 优雅降级

4.2 异常处理最佳实践

1. 捕获具体异常而非裸except
2. 使用异常链保留原始堆栈
3. 合理使用finally进行资源清理

python复制try:
    f = open('data.txt', 'r')
    try:
        content = f.read()
    except UnicodeDecodeError:
        content = f.read(encoding='latin1')
finally:
    f.close()  # 确保文件关闭

4.3 自定义异常体系

python复制class DataValidationError(Exception):
    """自定义数据验证异常"""
    def __init__(self, field, message):
        self.field = field
        self.message = message
        super().__init__(f"{field} error: {message}")

def validate_user(user):
    if not user.get('name'):
        raise DataValidationError('name', 'name is required')

5. 日志记录：从基础配置到高级用法

5.1 基础日志配置

python复制import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('app.log'),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)
logger.info('System started')

5.2 结构化日志实践

python复制import json
from logging import Formatter

class JsonFormatter(Formatter):
    def format(self, record):
        log_record = {
            'timestamp': self.formatTime(record),
            'level': record.levelname,
            'message': record.getMessage(),
            'module': record.module
        }
        return json.dumps(log_record)

handler = logging.StreamHandler()
handler.setFormatter(JsonFormatter())
logger.addHandler(handler)

5.3 日志分级策略

• DEBUG：开发调试细节
• INFO：常规运行信息
• WARNING：潜在问题
• ERROR：功能错误
• CRITICAL：系统级错误

python复制def process_data(data):
    logger.debug('Processing started with data: %s', data[:100])
    try:
        result = complex_operation(data)
        logger.info('Processed %d items', len(result))
        return result
    except Exception as e:
        logger.error('Processing failed: %s', str(e), exc_info=True)
        raise

6. 工程化整合实战

6.1 配置文件读取方案

python复制import json
from pathlib import Path
import logging

def load_config(config_path):
    """安全加载JSON配置"""
    config_file = Path(config_path)
    if not config_file.exists():
        raise FileNotFoundError(f"Config file {config_path} missing")
    
    try:
        with open(config_path, 'r', encoding='utf-8') as f:
            return json.load(f)
    except json.JSONDecodeError as e:
        logging.error("Invalid JSON config: %s", str(e))
        raise
    except UnicodeDecodeError:
        with open(config_path, 'r', encoding='latin1') as f:
            return json.load(f)

6.2 数据管道错误处理模板

python复制def data_pipeline(input_file, output_file):
    logger.info("Starting pipeline for %s", input_file)
    try:
        with open(input_file, 'r') as f_in, \
             open(output_file, 'w') as f_out:
            
            for line in f_in:
                try:
                    processed = process_line(line)
                    f_out.write(processed + '\n')
                except DataValidationError as e:
                    logger.warning("Skipping invalid line: %s", str(e))
                    continue
                    
    except IOError as e:
        logger.error("File operation failed: %s", str(e))
        raise PipelineError("I/O failure") from e
    finally:
        logger.info("Pipeline completed with status: %s", 
                   "success" if not sys.exc_info()[0] else "failed")

6.3 性能敏感场景优化

对于高频文件操作：

1. 使用缓冲区减少IO次数
2. 考虑内存映射(mmap)处理超大文件
3. 异步写入降低延迟影响

python复制import mmap

def search_large_file(filename, pattern):
    with open(filename, 'r+b') as f:
        # 内存映射文件
        mm = mmap.mmap(f.fileno(), 0)
        try:
            if mm.find(pattern.encode()) != -1:
                return True
        finally:
            mm.close()
    return False

7. 常见问题排坑指南

7.1 编码问题解决方案

python复制# 自动检测编码
import chardet

def detect_encoding(file_path):
    with open(file_path, 'rb') as f:
        raw = f.read(1024)  # 读取前1KB用于检测
    return chardet.detect(raw)['encoding']

# 使用示例
encoding = detect_encoding('unknown.txt')
with open('unknown.txt', 'r', encoding=encoding) as f:
    content = f.read()

7.2 JSON特殊值处理

python复制# 处理NaN/Infinity等特殊值
import math

def json_safe_encoder(obj):
    if isinstance(obj, float):
        if math.isnan(obj):
            return "NaN"
        if math.isinf(obj):
            return "Infinity" if obj > 0 else "-Infinity"
    return obj

json.dumps({'value': float('nan')}, default=json_safe_encoder)

7.3 日志文件轮转方案

python复制from logging.handlers import RotatingFileHandler

# 每个日志文件最大10MB，保留5个备份
handler = RotatingFileHandler(
    'app.log', maxBytes=10*1024*1024, backupCount=5
)
logger.addHandler(handler)

8. 工具链推荐

1. 文件差异比较：difflib模块
2. JSON验证：jsonschema库
3. 日志分析：ELK Stack
4. 性能分析：cProfile + snakeviz
5. 配置管理：python-decouple

python复制# 使用jsonschema验证JSON结构
from jsonschema import validate

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "number", "minimum": 0}
    },
    "required": ["name"]
}

validate(instance={"name": "Alice"}, schema=schema)

9. 性能对比实测数据

测试环境：Python 3.10，SSD硬盘，16GB内存

10. 工程化进阶建议

1. 为关键操作添加审计日志
2. 实现配置热重载机制
3. 建立统一的错误代码体系
4. 开发环境与生产环境日志分级
5. 重要操作添加操作前确认提示

python复制# 审计日志示例
audit_logger = logging.getLogger('audit')
audit_logger.setLevel(logging.INFO)
audit_handler = logging.FileHandler('audit.log')
audit_handler.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))
audit_logger.addHandler(audit_handler)

def critical_operation(user, action):
    audit_logger.info(f"User {user} performed {action}")
    try:
        perform_action(action)
    except Exception as e:
        audit_logger.error(f"Action failed: {action} by {user}: {str(e)}")
        raise