Для чего нужно исключение в Python?

Для чего нужны исключения в Python

Исключения — это механизм обработки ошибок, который позволяет контролировать поток программы при возникновении проблем. Это один из ключевых концептов Python.

Определение

Исключение (Exception) — это объект, который представляет ошибку или необычное событие, произошедшее во время выполнения программы.

Зачем нужны исключения?

1. Обработка ошибок без прерывания программы

Без исключений программа просто падала бы при первой ошибке:

# БЕЗ обработки исключений
def divide(a, b):
    return a / b

result = divide(10, 0)  # ZeroDivisionError!
# Программа упала, ничего не можно сделать

# С обработкой исключений
def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("Ошибка: деление на ноль!")
        return None

result = divide(10, 0)  # Программа продолжает работать
print("Продолжаю работу")

2. Контроль потока выполнения

Исключения позволяют выбирать разные пути выполнения в зависимости от ошибок:

def process_user_data(user_id):
    try:
        user = fetch_user(user_id)  # Может быть ошибка сети
        data = parse_json(user)      # Может быть ошибка парсинга
        save_to_db(data)             # Может быть ошибка БД
        return {"status": "success"}
    except ConnectionError:
        return {"status": "error", "message": "Network error"}
    except JSONDecodeError:
        return {"status": "error", "message": "Invalid JSON"}
    except DatabaseError:
        return {"status": "error", "message": "Database error"}

3. Информирование о проблемах

Исключения предоставляют информацию о том, что пошло не так:

try:
    with open("config.json") as f:
        config = json.load(f)
except FileNotFoundError:
    print("Файл конфигурации не найден")
except JSONDecodeError as e:
    print(f"Ошибка в JSON: {e}")
    print(f"Строка {e.lineno}, колонка {e.colno}")

Типы исключений

Встроенные исключения

# ZeroDivisionError
result = 10 / 0  # ZeroDivisionError: division by zero

# ValueError
int("abc")  # ValueError: invalid literal for int()

# KeyError
my_dict = {}
my_dict["key"]  # KeyError: 'key'

# IndexError
my_list = [1, 2, 3]
my_list[10]  # IndexError: list index out of range

# TypeError
"string" + 5  # TypeError: can only concatenate str

# AttributeError
my_string = "hello"
my_string.undefined_method()  # AttributeError: 'str' object has no attribute

# FileNotFoundError
open("nonexistent.txt")  # FileNotFoundError: [Errno 2] No such file or directory

# ConnectionError
requests.get("http://invalid-url")  # ConnectionError

Иерархия исключений

# Все исключения наследуются от BaseException

BaseException
├── Exception  # Обычные ошибки
│   ├── ValueError
│   ├── TypeError  
│   ├── KeyError
│   ├── IndexError
│   ├── ZeroDivisionError
│   ├── FileNotFoundError
│   ├── ConnectionError
│   └── ... (множество других)
├── KeyboardInterrupt  # Ctrl+C
└── SystemExit        # sys.exit()

# Ловить Exception = ловить все исключения (кроме системных)

try-except блок

Базовая структура

try:
    # Код, который может вызвать исключение
    result = 10 / 0
except ZeroDivisionError:
    # Код, который выполнится, если возникло исключение
    print("Деление на ноль!")

Несколько except блоков

try:
    data = json.load(open("file.json"))
    result = data["value"] / 0
except FileNotFoundError:
    print("Файл не найден")
except JSONDecodeError:
    print("Неверный JSON")
except (ZeroDivisionError, KeyError) as e:
    print(f"Произошла ошибка: {e}")
except Exception as e:
    print(f"Неизвестная ошибка: {e}")

finally блок

try:
    file = open("data.txt")
    data = file.read()
except FileNotFoundError:
    print("Файл не найден")
finally:
    # Выполнится в любом случае
    file.close()  # Освобождаем ресурсы

# Лучший способ: with
with open("data.txt") as file:
    data = file.read()  # Автоматически закроется

else блок

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Ошибка!")
else:
    # Выполнится, если НЕ было исключения
    print(f"Результат: {result}")  # Результат: 5

Создание собственных исключений

Зачем нужны свои исключения?

# Встроенных исключений иногда недостаточно
# Нужны специфичные для твоего приложения

# Плохо: использовать встроенные исключения
def withdraw_money(account, amount):
    if amount > account.balance:
        raise ValueError("Insufficient funds")  # Неясно, что случилось

# Хорошо: создать своё исключение
class InsufficientFundsError(Exception):
    """Недостаточно средств на счёте"""
    pass

def withdraw_money(account, amount):
    if amount > account.balance:
        raise InsufficientFundsError(f"Need {amount}, but have {account.balance}")

Иерархия собственных исключений

# Базовое исключение приложения
class AppError(Exception):
    """Базовое исключение приложения"""
    pass

# Специфичные ошибки
class ValidationError(AppError):
    """Ошибка валидации данных"""
    pass

class PaymentError(AppError):
    """Ошибка при обработке платежа"""
    pass

class InsufficientFundsError(PaymentError):
    """Недостаточно средств"""
    pass

class PaymentGatewayError(PaymentError):
    """Ошибка платёжного шлюза"""
    pass

# Использование
try:
    process_payment(...)
except InsufficientFundsError as e:
    return {"error": "Insufficient funds", "details": str(e)}
except PaymentGatewayError as e:
    # Переоправить, это не вина пользователя
    retry_payment(...)
except AppError as e:
    # Любая ошибка приложения
    logger.error(f"App error: {e}")

Практические примеры

Пример 1: Обработка ошибок при работе с API

import requests
from requests.exceptions import ConnectionError, Timeout, HTTPError

def fetch_user_data(user_id):
    try:
        response = requests.get(
            f"https://api.example.com/users/{user_id}",
            timeout=5
        )
        response.raise_for_status()  # Выбросить исключение при 4xx/5xx
        return response.json()
    except ConnectionError:
        print("Ошибка подключения")
        return None
    except Timeout:
        print("Сервер не ответил за 5 секунд")
        return None
    except HTTPError as e:
        print(f"HTTP ошибка {e.response.status_code}")
        return None
    except ValueError:  # JSON decode error
        print("Неверный JSON в ответе")
        return None

Пример 2: Валидация данных

class User:
    def __init__(self, name, email, age):
        self.name = self._validate_name(name)
        self.email = self._validate_email(email)
        self.age = self._validate_age(age)
    
    def _validate_name(self, name):
        if not name or len(name) < 2:
            raise ValidationError("Name must be at least 2 characters")
        return name
    
    def _validate_email(self, email):
        if "@" not in email:
            raise ValidationError("Invalid email format")
        return email
    
    def _validate_age(self, age):
        if not isinstance(age, int) or age < 0 or age > 120:
            raise ValidationError("Age must be between 0 and 120")
        return age

# Использование
try:
    user = User("Jo", "invalid", -5)
except ValidationError as e:
    print(f"Validation failed: {e}")

Пример 3: Context Manager с исключениями

class DatabaseConnection:
    def __init__(self, connection_string):
        self.connection_string = connection_string
        self.conn = None
    
    def __enter__(self):
        try:
            self.conn = self._connect()
            return self.conn
        except ConnectionError:
            raise DatabaseError(f"Failed to connect: {self.connection_string}")
    
    def __exit__(self, exc_type, exc_val, exc_tb):
        if self.conn:
            self.conn.close()
        
        # Если было исключение, логируем его
        if exc_type is not None:
            logger.error(f"Error during DB operation: {exc_val}")
        
        # Не подавляем исключение (return True было бы подавлением)
        return False

# Использование
try:
    with DatabaseConnection("postgresql://...") as conn:
        conn.execute("SELECT * FROM users")
except DatabaseError as e:
    print(f"Database error: {e}")

Пример 4: Логирование при исключении

import logging

logger = logging.getLogger(__name__)

def process_order(order_id):
    try:
        order = get_order(order_id)
        payment = process_payment(order)
        send_confirmation(payment)
        return {"status": "success"}
    except PaymentError as e:
        # Логируем с полным контекстом
        logger.error(
            f"Payment failed for order {order_id}",
            exc_info=True,  # Добавляет стек вызовов
            extra={"order_id": order_id, "error_type": type(e).__name__}
        )
        return {"status": "error", "message": "Payment processing failed"}
    except Exception as e:
        # Неожиданная ошибка
        logger.exception(f"Unexpected error processing order {order_id}")
        return {"status": "error", "message": "Unexpected error"}

Лучшие практики

1. Ловить специфичные исключения, не Exception

# Плохо: ловит ВСЕ исключения
try:
    result = 10 / 0
except Exception:
    print("Something went wrong")  # Может скрыть важные ошибки

# Хорошо: ловим конкретное исключение
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero")

2. Не молчи об ошибках

# Плохо: pass скрывает проблему
try:
    dangerous_operation()
except Exception:
    pass  # Ошибка скрыта, её сложно найти

# Хорошо: логируем или переосвязываем
try:
    dangerous_operation()
except SpecificError as e:
    logger.error(f"Operation failed: {e}")
    raise  # Переосвязываем исключение

3. Не хватай слишком высоко в иерархии

# Плохо
try:
    my_code()
except BaseException:  # Ловит KeyboardInterrupt, SystemExit!
    pass

# Хорошо
try:
    my_code()
except Exception:  # Ловит обычные ошибки, но не системные
    pass

4. Добавляй контекст к исключениям

# Плохо: потеряли контекст
raise ValueError("Invalid data")

# Хорошо: полный контекст
raise ValueError(
    f"Invalid data: expected {expected_format}, got {actual_data}"
) from e  # from e сохраняет оригинальное исключение

Резюме

Исключения в Python нужны для:

1. Обработки ошибок — программа не падает при ошибке
2. Контроля потока — выбираем разные пути при разных ошибках
3. Информирования — предоставляют информацию о проблеме
4. Специализации — создаём свои исключения для специфичных ошибок
5. Отладки — помогают найти и исправить проблемы

Исключения — это нормальная часть Python, а не признак плохого кода. Хороший Python код ожидает и обрабатывает исключения.