Python 中的 with 语句与 try 语句：资源管理对比

2.3 多个上下文管理器

with 语句支持同时管理多个资源：

# 同时打开多个文件
with open("input.txt", "r") as input_file, \
     open("output.txt", "w") as output_file:
    data = input_file.read()
    output_file.write(data.upper())

3. try 语句：传统的异常处理机制

3.1 完整的 try 语法结构

try:
    # 可能引发异常的代码
    file = open("data.txt", "r")
    content = file.read()
    result = int(content)  # 可能引发 ValueError
except FileNotFoundError as e:
    # 处理特定异常
    print(f"文件未找到：{e}")
except ValueError as e:
    # 处理值错误
    print(f"数据格式错误：{e}")
except Exception as e:
    # 处理所有其他异常
    print(f"未知错误：{e}")
else:
    # 没有异常时执行
    print("操作成功完成")
finally:
    # 无论是否异常都会执行
    if 'file' in locals() and not file.closed:
        file.close()
        print("资源清理完成")

3.2 try 语句的执行流程

执行 try 代码块。若发生异常，匹配异常类型并执行对应 except 块；若无异常则执行 else 块。最后无论是否异常均执行 finally 块。

4. with vs try：详细对比分析

4.1 功能对比表

4.2 性能考虑

import timeit

# 测试 with 语句性能
with_time = timeit.timeit(
    '''
    with open("test.txt", "w") as f:
        f.write("test")
    ''',
    setup="open('test.txt', 'w').close()",
    number=10000
)

# 测试 try 语句性能
try_time = timeit.timeit(
    '''
    try:
        f = open("test.txt", "w")
        f.write("test")
    finally:
        f.close()
    ''',
    setup="open('test.txt', 'w').close()",
    number=10000
)
print(f"with 语句耗时：{with_time:.4f}秒")
print(f"try 语句耗时：{try_time:.4f}秒")
# 通常 with 语句稍快，因为优化了底层实现

5. 实际应用案例

5.1 数据库连接管理

import sqlite3
from contextlib import contextmanager

@contextmanager
def database_connection(db_path):
    """数据库连接上下文管理器"""
    conn = None
    try:
        conn = sqlite3.connect(db_path)
        print(f"连接到数据库：{db_path}")
        yield conn
    except sqlite3.Error as e:
        print(f"数据库错误：{e}")
        raise
    finally:
        if conn:
            conn.close()
            print("数据库连接已关闭")

# 使用示例
with database_connection("example.db") as conn:
    cursor = conn.cursor()
    cursor.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
    conn.commit()

5.2 线程锁管理

import threading
import time

class SafeCounter:
    def __init__(self):
        self.value = 0
        self.lock = threading.Lock()

    def increment(self):
        # 使用 with 自动管理锁
        with self.lock:
            current = self.value
            time.sleep(0.001)
            self.value = current + 1

    def increment_with_try(self):
        # 使用 try-finally 手动管理锁
        self.lock.acquire()
        try:
            current = self.value
            time.sleep(0.001)
            self.value = current + 1
        finally:
            self.lock.release()

5.3 临时目录管理

import tempfile
import os
from contextlib import contextmanager

@contextmanager
def temporary_directory():
    """创建临时目录并在使用后清理"""
    temp_dir = tempfile.mkdtemp()
    print(f"创建临时目录：{temp_dir}")
    try:
        yield temp_dir
    finally:
        import shutil
        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}")

6. 最佳实践指南

6.1 何时使用 with 语句？

优先使用 with 的情况：

• 文件操作（打开/关闭）
• 数据库连接
• 网络连接
• 锁的获取/释放
• 任何需要成对操作（setup/teardown）的场景

# 最佳实践示例
with open("data.csv", "r") as csv_file, \
     open("report.txt", "w") as report_file:
    for line in csv_file:
        processed = process_line(line)
        report_file.write(processed + "\n")

6.2 何时使用 try 语句？

需要使用 try 的情况：

• 复杂的异常处理逻辑
• 需要根据异常类型采取不同行动
• 需要记录或转换异常
• 资源管理不是主要关注点时

# 复杂异常处理示例
def process_user_input(user_input):
    try:
        if user_input.lower() == "true":
            return True
        elif user_input.lower() == "false":
            return False
        else:
            return int(user_input)
    except ValueError:
        try:
            return float(user_input)
        except ValueError:
            raise ValueError(f"无法解析输入：{user_input}")

6.3 结合使用：最佳组合

def safe_file_operation(filename, operation):
    """结合 with 和 try 的最佳实践"""
    try:
        with open(filename, "r") as file:
            return operation(file)
    except FileNotFoundError:
        print(f"文件 {filename} 不存在，使用默认值")
        return None
    except PermissionError:
        print(f"没有权限读取文件 {filename}")
        raise
    except Exception as e:
        print(f"处理文件时发生未知错误：{e}")
        raise

# 使用示例
result = safe_file_operation("config.json", lambda f: f.read())

7. 高级技巧与模式

7.1 嵌套上下文管理器

# 嵌套使用上下文管理器
with database_connection("app.db") as conn:
    with conn.cursor() as cursor:
        cursor.execute("SELECT * FROM users")
        with open("users_backup.csv", "w") as backup_file:
            for row in cursor.fetchall():
                backup_file.write(",".join(map(str, row)) + "\n")

7.2 忽略特定异常

from contextlib import suppress

# 使用 suppress 忽略特定异常
with suppress(FileNotFoundError):
    os.remove("temp_file.txt")
    print("文件已删除")

7.3 条件上下文管理器

from contextlib import nullcontext

use_logging = True
context_manager = open("log.txt", "a") if use_logging else nullcontext()

with context_manager as log_file:
    if use_logging:
        log_file.write("程序启动\n")
    print("程序运行中...")

8. 总结与建议

8.1 核心要点总结

1. with 语句是资源管理的首选工具，提供简洁、安全的资源管理
2. try 语句是异常处理的完整解决方案，提供最大的灵活性
3. 两者可以结合使用，发挥各自优势
4. 对于简单的资源管理，优先使用 with 语句
5. 对于复杂的错误处理逻辑，使用 try 语句

8.2 决策建议

记住这个简单的原则：用 with 管理资源，用 try 处理异常。当两者都需要时，让 with 负责资源的自动清理，让 try 负责异常的逻辑处理。这样既能保证代码的安全性，又能保持代码的清晰和可维护性。

# 终极最佳实践示例
def robust_data_processor(input_file, output_file):
    """健壮的数据处理函数"""
    try:
        with open(input_file, "r") as infile, \
             open(output_file, "w") as outfile:
            for line_num, line in enumerate(infile, 1):
                try:
                    processed = complex_processing(line)
                    outfile.write(processed)
                except ProcessingError as e:
                    print(f"第{line_num}行处理失败：{e}")
                    outfile.write(f"# ERROR: {e}\n")
    except FileNotFoundError:
        print("输入文件不存在")
        raise
    except IOError as e:
        print(f"IO 错误：{e}")
        raise
    finally:
        print("数据处理流程结束")

通过合理选择和组合 with 与 try 语句，你可以编写出既安全又优雅的 Python 代码，有效管理资源并妥善处理异常，构建出更加健壮的应用程序。