Использование блока try-except в Python

Обработка ошибок — важнейшая часть программирования. В процессе выполнения программы могут возникнуть различные ошибки, которые могут прерывать её работу. Чтобы избежать внезапного завершения программы и обеспечить адекватную реакцию на ошибки, в Python используется конструкция try-except. В этой лекции мы разберем, что такое исключения, как и зачем их обрабатывать, и приведем множество интересных примеров.

Зачем нужна обработка исключений?

Каждая программа может столкнуться с ошибками во время выполнения. Например:

• Неправильный ввод данных
• Ошибки при работе с файлами (например, файл не найден)
• Сетевые сбои (например, потеря соединения)
• Арифметические ошибки (например, деление на ноль)

Если такие ошибки не обрабатывать, программа завершится аварийно. Это не только неудобно для пользователей, но и может привести к потере данных или к сбоям в работе системы. Обработка исключений позволяет:

1. Перехватить ошибки и предотвратить завершение программы.
2. Предоставить пользователю понятные сообщения об ошибках.
3. Продолжить выполнение программы после обработки ошибки.

Базовое использование try-except

Конструкция try-except используется для обработки ошибок, которые могут возникнуть в блоке кода. Вот простой пример:

try:
    number = int(input("Введите число: "))
    print(f"Вы ввели: {number}")
except ValueError:
    print("Ошибка: нужно ввести число!")

Здесь, если пользователь введет что-то, что не является числом, сработает блок except, который выведет сообщение об ошибке.

Структура блока try-except

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

try:
    # код, который может вызвать исключение
except <Тип_исключения>:
    # код, который выполняется, если произошло исключение

Обработка нескольких типов исключений

Часто нужно обрабатывать разные типы ошибок. Например:

def divide_numbers():
    try:
        x = int(input("Введите числитель: "))
        y = int(input("Введите знаменатель: "))
        result = x / y
        print(f"Результат деления: {result}")
    except ValueError:
        print("Ошибка: введено не число!")
    except ZeroDivisionError:
        print("Ошибка: деление на ноль невозможно!")

Здесь мы обрабатываем два типа ошибок:

• ValueError, если пользователь ввел некорректные данные.
• ZeroDivisionError, если попытка деления на ноль.

Блок else: когда исключений нет

Блок else выполняется, если в блоке try не произошло исключений:

def get_user_age():
    try:
        age = int(input("Введите ваш возраст: "))
    except ValueError:
        print("Ошибка: нужно ввести целое число!")
    else:
        print(f"Ваш возраст: {age}")

Здесь код внутри else выполнится только если не было ошибки при преобразовании строки в число.

Блок finally: гарантированное выполнение

Блок finally используется для кода, который должен быть выполнен в любом случае — произошла ошибка или нет. Это полезно для освобождения ресурсов, например, закрытия файлов:

def read_file(file_name):
    try:
        file = open(file_name, 'r')
        data = file.read()
        print("Содержимое файла:")
        print(data)
    except FileNotFoundError:
        print(f"Ошибка: файл {file_name} не найден.")
    finally:
        print("Закрытие файла.")
        file.close()

Интересные примеры с использованием функций

Теперь давайте рассмотрим несколько более сложных примеров, где блоки try-except используются для обработки ошибок в функциях.

Пример 1: Проверка на четность с обработкой ошибок

Напишем функцию, которая проверяет, является ли число четным, и обработаем несколько ошибок:

def is_even():
    try:
        number = int(input("Введите число: "))
        if number % 2 == 0:
            print(f"{number} — четное число.")
        else:
            print(f"{number} — нечетное число.")
    except ValueError:
        print("Ошибка: нужно ввести целое число!")
    except Exception as e:
        print(f"Произошла непредвиденная ошибка: {e}")

В этом примере мы обрабатываем не только ошибку ValueError, но и любые другие ошибки с помощью общего except Exception.

Пример 2: Деление с обработкой нескольких исключений

Давайте создадим функцию для деления двух чисел, которая обрабатывает возможные ошибки:

def safe_division():
    try:
        num1 = float(input("Введите делимое: "))
        num2 = float(input("Введите делитель: "))
        result = num1 / num2
    except ZeroDivisionError:
        print("Ошибка: деление на ноль невозможно!")
    except ValueError:
        print("Ошибка: введено некорректное значение!")
    else:
        print(f"Результат деления: {result}")

Здесь обрабатываются ошибки деления на ноль и неправильного ввода (если пользователь вводит что-то, что не является числом).

Пример 3: Работа с файлами и обработка нескольких ошибок

Допустим, нам нужно написать функцию, которая будет считывать данные из файла, обрабатывая возможные ошибки:

def read_file_content(file_name):
    try:
        with open(file_name, 'r') as file:
            content = file.read()
        print("Содержимое файла:")
        print(content)
    except FileNotFoundError:
        print(f"Ошибка: файл {file_name} не найден.")
    except PermissionError:
        print(f"Ошибка: у вас нет прав на чтение файла {file_name}.")
    except IOError as e:
        print(f"Ошибка ввода-вывода: {e}")

Здесь мы обрабатываем несколько ошибок: файл может не существовать, могут отсутствовать права на его чтение или может произойти ошибка при чтении.
 

Пример 4: Обработка сетевых ошибок

Предположим, что вы пишете код, который делает сетевые запросы. Важно обработать ошибки, которые могут возникнуть при работе с сетью:

import requests

def fetch_data_from_url(url):
    try:
        response = requests.get(url)
        response.raise_for_status()  # Вызывает исключение при ошибке HTTP
        return response.text
    except requests.exceptions.HTTPError as http_err:
        print(f"HTTP ошибка: {http_err}")
    except requests.exceptions.ConnectionError:
        print("Ошибка соединения: не удалось подключиться к серверу.")
    except requests.exceptions.Timeout:
        print("Ошибка: запрос превысил время ожидания.")
    except requests.exceptions.RequestException as req_err:
        print(f"Произошла ошибка при запросе: {req_err}")

Этот пример показывает, как обрабатывать различные ошибки, которые могут возникнуть при отправке HTTP-запроса.

Пример 5: Использование вложенных try-except

Иногда может быть полезно использовать вложенные конструкции try-except. Например:

def complex_operation():
    try:
        num1 = int(input("Введите первое число: "))
        num2 = int(input("Введите второе число: "))
        try:
            result = num1 / num2
        except ZeroDivisionError:
            print("Ошибка: деление на ноль невозможно.")
        else:
            print(f"Результат деления: {result}")
    except ValueError:
        print("Ошибка: нужно ввести числа!")

Здесь первый блок try-except проверяет правильность ввода, а второй — пытается выполнить деление, обрабатывая деление на ноль.

Пример с функцией и возвратом результата

Иногда обработка ошибок необходима для правильного возврата результата из функции. Например, давайте создадим функцию, которая возвращает результат деления или None в случае ошибки:

def divide_numbers(num1, num2):
    try:
        return num1 / num2
    except ZeroDivisionError:
        print("Ошибка: деление на ноль.")
        return None
    except TypeError:
        print("Ошибка: оба аргумента должны быть числами.")
        return None

Здесь функция пытается выполнить деление, но если возникает ошибка (например, деление на ноль или передача некорректного типа данных), она возвращает None.

Вот таблица с сжатым содержанием лекции:

Конструкция try-except — это мощный инструмент для обработки ошибок в Python. Она позволяет делать программы более устойчивыми и защищенными от сбоев. Важно всегда предусматривать возможные ошибки и обрабатывать их корректно. При этом:

• Используйте конкретные типы исключений, когда это возможно.
• Помните, что блок else выполняется только при отсутствии исключений.
• Блок finally можно использовать для очистки ресурсов (например, закрытия файлов или завершения соединений).

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