В чем разница между контекстным менеджером и try/finally в Python?

В чем разница между контекстным менеджером и try/finally в Python?

Контекстный менеджер (context manager) — это более элегантный и безопасный способ управления ресурсами по сравнению с try/finally. Оба подхода решают одну задачу: гарантировать выполнение кода при завершении блока (например, закрытие файла), но контекстный менеджер делает это лучше.

Пример: работа с файлом

❌ Без контекстного менеджера (try/finally)

# Старый способ
f = open('data.txt', 'r')
try:
    content = f.read()
    print(content)
finally:
    f.close()  # ОБЯЗАТЕЛЬНО закрыть, даже при ошибке

# Проблемы:
# 1. Многословно
# 2. Легко забыть finally
# 3. Если несколько ресурсов — вложенные try/finally

✅ С контекстным менеджером (with)

# Современный способ
with open('data.txt', 'r') as f:
    content = f.read()
    print(content)
# f автоматически закроется, даже при ошибке!

# Преимущества:
# 1. Лаконично
# 2. Безопасно по умолчанию
# 3. Четкое выделение области использования ресурса

Что происходит в try/finally?

f = None
try:
    f = open('data.txt')
    content = f.read()
    print(content)
finally:
    if f is not None:
        f.close()

# Проблема: что если open() падает?
# Тогда f = None и в finally вернется успешно
# Но это не главное — главное, что НУЖНО помнить про finally

Что происходит в with?

# with вызывает специальные методы:
# 1. __enter__() — входит в контекст
# 2. __exit__() — выходит из контекста (выполняется ВСЕГДА)

with open('data.txt') as f:
    content = f.read()

# Эквивалентно:
# f = open('data.txt')
# f.__enter__()
# try:
#     content = f.read()
# finally:
#     f.__exit__()

Создание собственного контекстного менеджера

Способ 1: Класс с enter и exit

class DatabaseConnection:
    def __init__(self, host, port):
        self.host = host
        self.port = port
        self.connection = None
    
    def __enter__(self):
        """Выполняется при входе в блок with"""
        print(f"Подключаемся к {self.host}:{self.port}")
        self.connection = f"Connection to {self.host}"
        return self.connection  # Это будет значением переменной в with
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        """Выполняется при выходе из блока with"""
        print(f"Закрываем соединение")
        self.connection = None
        
        # exc_type, exc_val, exc_tb — информация об исключении (если было)
        # Если вернуть True — исключение будет подавлено
        # Если вернуть False — исключение будет пробросано дальше
        if exc_type is not None:
            print(f"Ошибка: {exc_type.__name__}: {exc_val}")
        return False  # Не подавляем исключение

# Использование
with DatabaseConnection('localhost', 5432) as conn:
    print(f"Работаю с {conn}")
    # Если здесь ошибка — __exit__ все равно выполнится

print("Готово")

Вывод:

Подключаемся к localhost:5432
Работаю с Connection to localhost
Закрываем соединение
Готово

Способ 2: Декоратор @contextmanager

from contextlib import contextmanager

@contextmanager
def database_connection(host, port):
    """Контекстный менеджер через функцию-генератор"""
    print(f"Подключаемся к {host}:{port}")
    connection = f"Connection to {host}"
    
    try:
        yield connection  # Код ПЕРЕД yield = __enter__
    finally:
        print(f"Закрываем соединение")  # Код ПОСЛЕ yield = __exit__

# Использование (точно так же)
with database_connection('localhost', 5432) as conn:
    print(f"Работаю с {conn}")

Вывод одинаковый!

Сравнение: try/finally vs with

❌ Несколько ресурсов с try/finally

# Грязно и сложно
file1 = open('file1.txt')
try:
    file2 = open('file2.txt')
    try:
        file3 = open('file3.txt')
        try:
            # Работаем с тремя файлами
            content1 = file1.read()
            content2 = file2.read()
            content3 = file3.read()
        finally:
            file3.close()
    finally:
        file2.close()
finally:
    file1.close()

✅ Несколько ресурсов с with

# Чистенько!
with open('file1.txt') as f1, \
     open('file2.txt') as f2, \
     open('file3.txt') as f3:
    content1 = f1.read()
    content2 = f2.read()
    content3 = f3.read()

По сути – то же самое, но на одну строку вместо 12!

Обработка исключений в контекстном менеджере

class SafeFile:
    def __init__(self, filename, mode='r'):
        self.filename = filename
        self.mode = mode
        self.file = None
    
    def __enter__(self):
        try:
            self.file = open(self.filename, self.mode)
            return self.file
        except FileNotFoundError:
            print(f"Файл {self.filename} не найден")
            # Можно создать файл, вернуть None и т.д.
            return None
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.file:
            self.file.close()
        
        # Обработка исключений
        if exc_type is ValueError:
            print(f"Ошибка парсинга: {exc_val}")
            return True  # Подавляем исключение
        
        if exc_type is not None:
            print(f"Ошибка: {exc_type.__name__}")
            return False  # Пробрасываем дальше
        
        return False

# Использование
with SafeFile('data.txt') as f:
    if f:
        data = f.read()
    else:
        data = "default"

Практический пример: Database Transaction

from contextlib import contextmanager
from sqlalchemy import create_engine, Session

engine = create_engine('postgresql://user:pass@localhost/db')

@contextmanager
def database_transaction():
    """Контекстный менеджер для транзакций БД"""
    session = Session(engine)
    try:
        yield session
        session.commit()  # Фиксируем изменения
    except Exception as e:
        session.rollback()  # Откатываем при ошибке
        raise e
    finally:
        session.close()  # Закрываем соединение

# Использование
with database_transaction() as session:
    user = User(name="John", email="john@example.com")
    session.add(user)
    # session.commit() выполнится автоматически при успехе
    # session.rollback() выполнится при ошибке

Встроенные контекстные менеджеры

# 1. Файлы
with open('file.txt') as f:
    content = f.read()

# 2. Блокировки (threading)
import threading
lock = threading.Lock()
with lock:
    # Критическая секция
    pass

# 3. Таймауты (contextlib)
import contextlib
import time

@contextlib.contextmanager
def timer(name):
    start = time.time()
    try:
        yield
    finally:
        elapsed = time.time() - start
        print(f"{name}: {elapsed:.2f}s")

with timer("Computation"):
    sum(range(1000000))
# Вывод: Computation: 0.05s

Правила использования

# ✅ ПРАВИЛЬНО
with open('file.txt') as f:
    content = f.read()

# ✅ ПРАВИЛЬНО
from contextlib import contextmanager

@contextmanager
def my_context():
    print("Setup")
    try:
        yield
    finally:
        print("Cleanup")

with my_context():
    print("Work")

# ❌ НЕПРАВИЛЬНО
with open('file.txt') as f:  # Если не знаешь, что делать
    pass  # Нужен try/finally для явности

Заключение

Контекстный менеджер (with) ЛУЧШЕ try/finally потому что:

1. Безопаснее — не забудешь освободить ресурс
2. Лаконичнее — меньше кода
3. Понятнее — область использования ресурса четко видна
4. Гибче — можно обрабатывать исключения в exit
5. Современнее — это стандарт Python

Используй with для:

• Файлов
• Соединений с БД
• Блокировок
• Транзакций
• Любых ресурсов, которые нужно освободить

try/finally используй только когда:

• with невозможен
• Нужна специальная обработка исключений
• Не хочешь писать контекстный менеджер (но не делай так!)