Python вывести окно ошибки

Последнее обновление: 24.09.2022

Окна сообщений

Tkinter имеет ряд встроенных окон для разных ситуаций, в частности, окна сообщений, функционал которых заключен в модуле tkinter.messagebox.
Для отображения сообщений этот модуль предоставляет следующие функции:

• showinfo(): предназначена для отображения некоторой информации

• showerror(): предназначена для отображения ошибок

• showwarrning(): предназначена для отображения предупреждений

Все эти функции принимают три параметра:

showinfo(title, message, **options)
showerror(title, message, **options)
showwarrning(title, message, **options)

• title: заголовок окна

• message: отображаемое сообщение

• options: настройки окна

В реальности различие между этими типами сообщений заключается лишь в изображении, которое отображается рядом с текстом сообщения:

from tkinter import *
from tkinter import ttk
from tkinter.messagebox import showerror, showwarning, showinfo

root = Tk()
root.title("METANIT.COM")
root.geometry("250x200")

def open_info(): 
    showinfo(title="Информация", message="Информационное сообщение")

def open_warning(): 
    showwarning(title="Предупреждение", message="Сообщение о предупреждении")

def open_error(): 
    showerror(title="Ошибка", message="Сообщение об ошибке")

info_button = ttk.Button(text="Информация", command=open_info)
info_button.pack(anchor="center", expand=1)

warning_button = ttk.Button(text="Предупреждение", command=open_warning)
warning_button.pack(anchor="center", expand=1)

error_button = ttk.Button(text="Ошибка", command=open_error)
error_button.pack(anchor="center", expand=1)

root.mainloop()

Здесь по нажатию на каждую из трех кнопок отображается соответствующее сообщение:

Окна подтверждения операции

Модуль tkinter.messagebox также предоставляет ряд функций для подтверждения операции, где пользователю предлагается
нажать на одну из двух кнопок:

• askyesno()

• askokcancel()

• askretrycancel()

Все эти функции принимают те же три параметра title, message и options. Отличие между ними только в том, что кнопки имеют разный текст. В случае нажатия на кнопку подтверждения, функция возвращает значение True, иначе возвращается False

from tkinter import *
from tkinter import ttk
from tkinter.messagebox import showinfo, askyesno

root = Tk()
root.title("METANIT.COM")
root.geometry("250x200")

def click(): 
    result = askyesno(title="Подтвержение операции", message="Подтвердить операцию?")
    if result: showinfo("Результат", "Операция подтверждена")
    else: showinfo("Результат", "Операция отменена")

ttk.Button(text="Click", command=click).pack(anchor="center", expand=1)

root.mainloop()

В данном случае по нажатию на кнопку вызывается функция askyesno(), которая отображает диалоговое окно с двумя кнопками «Да» и «Нет».
В зависимости от того, на какую кнопку нажмет пользователь, функция возвратит True или False. Получив результат функции, мы можем проверить его и выполнить те или иные действия.

Особняком стоит функция askquestion — она также отображает две кнопки для подтверждения или отмены действия (кнопки «Yes»(Да) и «No»(Нет)),
но в зависимости от нажатой кнопки возвращает строку: «yes» или «no».

Также отдельно стоит функция askyesnocancel() — она отображает три кнопки: Yes (возвращает True), No (возвращает False) и Cancel
(возвращает None):

from tkinter import *
from tkinter import ttk
from tkinter.messagebox import showinfo, askyesnocancel

root = Tk()
root.title("METANIT.COM")
root.geometry("250x200")

def click(): 
    result =  askyesnocancel(title="Подтвержение операции", message="Подтвердить операцию?")
    if result==None: showinfo("Результат", "Операция приостановлена")
    elif result: showinfo("Результат", "Операция подтверждена")
    else : showinfo("Результат", "Операция отменена")

ttk.Button(text="Click", command=click).pack(anchor="center", expand=1)

root.mainloop()

В этом случае диалоговое окно предоставит выбор из трех альтернатив

Настройка окон

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

• detail: дополнительный текст, который отображается под основным сообщением

• icon: иконка, которая отображается рядом с сообщением. Должна представлять одно из втроенных изображений: info, error, question или warning

• default: кнопка по умолчанию. Должна представлять одно из встроенных значений: abort, retry, ignore, ok, cancel, no, yes

from tkinter import *
from tkinter import ttk
from tkinter.messagebox import OK, INFO, showinfo 

root = Tk()
root.title("METANIT.COM")
root.geometry("250x200")

def click(): 
    showinfo(title="METANIT.COM", message="Добро пожаловать на сайт METANIT.COM", 
            detail="Hello World!", icon=INFO, default=OK)

ttk.Button(text="Click", command=click).pack(anchor="center", expand=1)

root.mainloop()

При нажатии на кнопку отобразится следующее окно:

Скачайте код уроков с GitLab: https://gitlab.com/PythonRu/tkinter-uroki

Окна уведомлений

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

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

При запуске этого примера стоит обратить внимание на то, что каждое окно воспроизводит соответствующий платформе звук и показывает перевод метки в зависимости от языка системы:

Эти диалоговые окна открываются с помощью функций showinfo, showwarning и showerror из модуля tkinter.messagebox:

import tkinter as tk

import tkinter.messagebox as mb

class App(tk.Tk):

    def __init__(self):

        super().__init__()

        btn_info = tk.Button(self, text="Информационное окно",

                             command=self.show_info)

        btn_warn = tk.Button(self, text="Окно с предупреждением",

                             command=self.show_warning)

        btn_error = tk.Button(self, text="Окно с ошибкой",

                              command=self.show_error)


        opts = {'padx': 40, 'pady': 5, 'expand': True, 'fill': tk.BOTH}

        btn_info.pack(**opts)

        btn_warn.pack(**opts)

        btn_error.pack(**opts)


    def show_info(self):

        msg = "Ваши настройки сохранены"

        mb.showinfo("Информация", msg)


    def show_warning(self):

        msg = "Временные файлы удалены не правильно"

        mb.showwarning("Предупреждение", msg)


    def show_error(self):

        msg = "Приложение обнаружило неизвестную ошибку"

        mb.showerror("Ошибка", msg)

if __name__ == "__main__":

    app = App()

    app.mainloop()



  


                       
  

Как работают окна с уведомлениями

В первую очередь нужно импортировать модуль tkinter.messagebox, задав для него алиас mb. В Python2 этот модуль назывался tkMessageBox, поэтому такой синтаксис позволит изолировать проблемы совместимости.

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

• showinfo — операция была завершена успешно,
• showwarning — операция была завершена, но что-то пошло не так, как планировалось,
• showerror — операция не была завершена из-за ошибки.

Все три функции получают две строки в качестве входящих аргументов: заголовок и сообщение.

Сообщение может быть выведено на нескольких строках с помощью символа новой строки n.

Окна выбора ответа

Другие типы диалоговых окон в Tkinter используются для запроса подтверждения от пользователя. Это нужно, например, при сохранении файла или перезаписывании существующего.

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

В этой программе рассмотрим остальные диалоговые функции из модуля tkinter.messagebox. Каждая кнопка включает метки с описанием типа окна, которое откроется при нажатии:

У них есть кое-какие отличия, поэтому стоит попробовать каждое из окон, чтобы разобраться в них.

Как и в прошлом примере сначала нужно импортировать tkinter.messagebox с помощью синтаксиса import … as и вызывать каждую из функций вместе с title и message:

import tkinter as tk

import tkinter.messagebox as mb

class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.create_button(mb.askyesno, "Спросить Да/Нет",

                           "Вернет True или False")

        self.create_button(mb.askquestion, "Задать вопрос ",

                           "Вернет 'yes' или 'no'")

        self.create_button(mb.askokcancel, "Спросить Ок/Отмена",

                           "Вернет True или False")

        self.create_button(mb.askretrycancel, "Спросить Повтор/Отмена",

                           "Вернет True или False")

        self.create_button(mb.askyesnocancel, "Спросить Да/Нет/Отмена",

                           "Вернет True, False или None")


    def create_button(self, dialog, title, message):

        command = lambda: print(dialog(title, message))

        btn = tk.Button(self, text=title, command=command)

        btn.pack(padx=40, pady=5, expand=True, fill=tk.BOTH)

if __name__ == "__main__":

    app = App()

    app.mainloop()



  


                       
  

Как работают вопросительные окна

Чтобы избежать повторений при создании экземпляра кнопки и функции обратного вызова определим метод create_button, который будет переиспользоваться для каждой кнопки с диалогами. Команды всего лишь выводят результат функции dialog, переданной в качестве параметра, что позволит видеть значение, которое она возвращает в зависимости от нажатой пользователем кнопки.

Выбор файлов и папок

Диалоговые окна для выбора файлов позволяют выбирать один или несколько файлов из файловой системы. В Tkinter эти функции объявлены в модуле tkinter.filedialog, который также включает окна для выбора папок. Он также позволяет настраивать поведение нового окна: например, фильтрация по расширению или выбор папки по умолчанию.

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

Вторая — «Выбор папки». Она будет открывать похожее диалоговое окно для выбора папки.

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

Первая кнопка будет вызывать функцию askopenfilename, а вторая — askdirectory:

import tkinter as tk

import tkinter.filedialog as fd

class App(tk.Tk):

    def __init__(self):

        super().__init__()

        btn_file = tk.Button(self, text="Выбрать файл",

                             command=self.choose_file)

        btn_dir = tk.Button(self, text="Выбрать папку",

                             command=self.choose_directory)

        btn_file.pack(padx=60, pady=10)

        btn_dir.pack(padx=60, pady=10)


    def choose_file(self):

        filetypes = (("Текстовый файл", "*.txt"),

                     ("Изображение", "*.jpg *.gif *.png"),

                     ("Любой", "*"))

        filename = fd.askopenfilename(title="Открыть файл", initialdir="/",

                                      filetypes=filetypes)

        if filename:

            print(filename)


    def choose_directory(self):

        directory = fd.askdirectory(title="Открыть папку", initialdir="/")

        if directory:

            print(directory)

if __name__ == "__main__":

    app = App()

    app.mainloop()

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

Как работают окна выбора файлов и папок

Создадим первое диалоговое окно с помощью функции askopenfilename, которая возвращает строку с полным путем к файлу. Она принимает следующие опциональные аргументы:

• title — название для диалогового окна.
• initialdir — начальная папка.
• filetypes — последовательность из двух строк. Первая — метка с типом файла в читаемом формате, а вторая — шаблон для поиска совпадения с названием файла.
• multiple — булево значение для определения того, может ли пользователь выбирать несколько файлов.
• defaultextension — расширение, добавляемое к файлу, если оно не было указано явно.

В этом примере задаем корневую папку в качестве начальной, а также название. В кортеже типов файлов есть следующие три варианта: текстовые файлы, сохраненные с расширением .txt, изображения с .jpg, .gif и .png, а также подстановочный знак («*») для всех файлов.

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

        filetypes = (("Текстовый файл", "*.txt"),

                     ("Изображение", "*.jpg *.gif *.png"),

                     ("Любой", "*"))

        filename = fd.askopenfilename(title="Открыть файл", initialdir="/",

                                      filetypes=filetypes)

Функция askdirectory также принимает параметры title и initialdir, а также булев параметр mustexist для определения того, должны ли пользователи выбирать существующую папку:

directory = fd.askdirectory(title="Открыть папку", initialdir="/")

Модуль tkinter.filedialog включает вариации этих функций, которые позволяют прямо получать объекты файлов.

Например, askopenfile возвращает объект файла, который соответствует выбранному вместо того чтобы вызывать open с путем возвращающим askopenfilename. Но при этом все еще придется проверять, не было ли окно отклонено перед вызовом файловых методов:

import tkinter.filedialog as fd


filetypes = (("Текстовый файл", "*.txt"),)

my_file = fd.askopenfile(title="Открыть файл", filetypes=filetypes)

if my_file:

    print(my_file.readlines())

    my_file.close()

Сохранение данных в файл

Помимо выбора существующих файлов и папок также есть возможность создавать новые, используя диалоговые окна Tkinter. Они позволят сохранять данные, сгенерированные приложением, позволяя пользователям выбирать название и местоположение нового файла.

Будем использовать диалоговое окно «Сохранить файл» для записи содержимого виджета Text в текстовый файл:

Для открытия такого диалогового окна используется функция asksavefile из модуля tkinter.filedialog. Она создает объект файла с режимом записи ('w') или None, если окно было закрыто:

import tkinter as tk

import tkinter.filedialog as fd

class App(tk.Tk):

    def __init__(self):

        super().__init__()

        self.text = tk.Text(self, height=10, width=50)

        self.btn_save = tk.Button(self, text="Сохранить", command=self.save_file)


        self.text.pack()

        self.btn_save.pack(pady=10, ipadx=5)



  


                       
  





    def save_file(self):

        contents = self.text.get(1.0, tk.END)

        new_file = fd.asksaveasfile(title="Сохранить файл", defaultextension=".txt",

                                    filetypes=(("Текстовый файл", "*.txt"),))

        if new_file:

            new_file.write(contents)

            new_file.close()

if __name__ == "__main__":

    app = App()

    app.mainloop()

Как работает сохранение фалов

Функция asksavefile принимает те же опциональные параметры, что и askopenfile, но также позволяет добавить расширение файла по умолчанию с помощью параметра defaultextension.

Чтобы пользователи случайно не перезаписывали существующие файлы, это окно автоматически предупреждает, если они пытаются сохранить новый файл с тем же названием, что и у существующего.

С помощью объекта файла можно записать содержимое виджета Text. Нужно лишь не забывать закрывать файл для освобождения ресурсов, которые использовал объект:

contents = self.text.get(1.0, tk.END)

new_file.write(contents)

new_file.close()

Благодаря последней программе стало понятно, что askopenfile возвращает объект файла, а не его название. Также есть функция asksaveasfilename, которая возвращает путь к выбранному файлу. Ее можно использовать для изменения пути или выполнения валидации перед открытием файла для записи.

Все мы тратим немало времени на отладку, копаясь в логах или читая трейсбеки (traceback, отчёты о трассировке стека). Любое из этих дел может оказаться сложным и длительным. Этот материал посвящён тому, как сделать трассировку стека и работу с исключениями как можно более простыми и эффективными.

На пути к этой цели мы узнаем о том, как реализовывать и использовать собственные перехватчики исключений (exception hook), которые позволяют убрать из трейсбеков весь «информационный шум». Мы поговорим о том, как улучшить читабельность отчётов о трассировке стека, как выводить в них лишь то, что нужно для решения проблем с Python-кодом и с возникающими в процессе его работы исключениями. Кроме того, мы посмотрим на несколько потрясающих Python-библиотек, в которых имеются готовые к использованию, хорошо сделанные перехватчики исключений. Их можно использовать без необходимости написания собственного кода перехватчиков.

Перехватчики исключений

Всякий раз, когда возникает исключение, которое не обрабатывается в блоке try/except, вызывается функция, назначенная sys.excepthook. Эта функция, называемая перехватчиком исключения, применяется для вывода любых полезных сведений о происшествии в стандартный поток вывода. Для этого она пользуется тремя получаемыми ей аргументами — type (класс исключения), value (экземпляр исключения) и traceback (объект трассировки).Разберём минимальный пример, демонстрирующий работу этого механизма:

import sys

def exception_hook(exc_type, exc_value, tb):
    print('Traceback:')
    filename = tb.tb_frame.f_code.co_filename
    name = tb.tb_frame.f_code.co_name
    line_no = tb.tb_lineno
    print(f"File {filename} line {line_no}, in {name}")
    # Класс и экземпляр исключения
    print(f"{exc_type.name}, Message: {exc_value}")
sys.excepthook = exception_hook

Тут мы применяем вышеупомянутые аргументы для того чтобы вывести основные данные трассировки, имеющие отношение к исключению. А именно, объект трассировки (tb) используется для работы со сведениями о трассировке кадров стека. Там содержатся данные, описывающие место возникновения исключения — имя файла (f_code.co_filename), имя функции/модуля (f_code.co_name) и номер строки (tb_lineno).

Кроме того, мы выводим и сведения о самом исключении, пользуясь переменными exc_type и exc_value.

Теперь мы можем вызвать функцию, которая вызывает некое исключение. При наличии такого перехватчика мы увидим сообщение, показанное в нижней части следующего фрагмента кода:

def do_stuff():
    # ... сделать что-то такое, что вызывает исключение
    raise ValueError("Some error message")
do_stuff()
Traceback:
File /home/some/path/exception_hooks.py line 22, in <module>
ValueError, Message: Some error message

Здесь имеются лишь некоторые сведения об исключении. Для того чтобы увидеть всю информацию, необходимую для отладки кода, а так же — чтобы получить полное представление о том, где и почему произошло исключение, нам нужно поглубже «зарыться» в объект трассировки:

def exception_hook(exc_type, exc_value, tb):
    local_vars = {}
    while tb:
        filename = tb.tb_frame.f_code.co_filename
        name = tb.tb_frame.f_code.co_name
        line_no = tb.tb_lineno
        print(f"File {filename} line {line_no}, in {name}")
        local_vars = tb.tb_frame.f_locals
        tb = tb.tb_next
    print(f"Local variables in top frame: {local_vars}")
...
File /home/some/path/exception_hooks.py line 41, in <module>
File /home/some/path/exception_hooks.py line 7, in do_stuff
Local variables in top frame: {'some_var': 'data'}

Как видите, объект трассировки (tb), на самом деле, представляет собой связный список произошедших исключений — стектрейс. Этот факт позволяет нам пройтись по данному списку с помощью tb_next и вывести сведения о каждом кадре стека. Более того — можно, воспользовавшись атрибутом tb_frame.f_locals, вывести в консоль локальные переменные. Это способно оказать нам помощь при отладке кода.

Просмотр содержимого объекта трассировки, как мы уже видели, имеет смысл, но получаемые данные плохо организованы, их, по мере роста масштабов задачи, всё сложнее и сложнее воспринимать. Поэтому лучше будет воспользоваться модулем traceback, в котором имеется множество вспомогательных функций, нацеленных на извлечение информации об исключениях.

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

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

Когда происходит перехват исключения, вывод данных о нём в stdout — это далеко не всё, что можно с ним сделать. В частности, ещё можно автоматически вывести данные об исключении в файл:

LOG_FILE_PATH = "./some.log"
FILE = open(LOG_FILE_PATH, mode="w")
def exception_hook(exc_type, exc_value, tb):
    FILE.write("*** Exception: ***n")
    traceback.print_exc(file=FILE)
    FILE.write("n*** Traceback: ***n")
    traceback.print_tb(tb, file=FILE)
    
*** Exception: ***
NoneType: None
# 
*** Traceback: ***
  File "/home/some/path/exception_hooks.py", line 82, in <module>
    do_stuff()
  File "/home/some/path/exception_hooks.py", line 7, in do_stuff
    raise ValueError("Some error message")

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

Сообщения о неперехваченных исключениях, по умолчанию, выводятся в stderr, стандартный поток ошибок. А это может быть нежелательным в том случае, если имеется система логирования исключений, и нужно, чтобы эта система обрабатывала бы то, что выводится в стандартный поток ошибок. Для того чтобы система логирования работала бы именно так — можно воспользоваться следующим перехватчиком:

import logging
logging.basicConfig(
    level=logging.CRITICAL,
    format='[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
    datefmt='%H:%M:%S',
    stream=sys.stdout
)
def exception_hook(exc_type, exc_value, exc_traceback):
    logging.critical("Uncaught exception:", exc_info=(exc_type, exc_value, exc_traceback))
[17:28:33] {/home/some/path/exception_hooks.py:117} CRITICAL - Uncaught exception:
Traceback (most recent call last):
  File "/home/some/path/exception_hooks.py", line 122, in <module>
    do_stuff()
  File "/home/some/path/exception_hooks.py", line 7, in do_stuff
    raise ValueError("Some error message")
ValueError: Some error message

Когда пытаешься улучшить то, что выводится в консоль, первое, что приходит в голову — оформление текста путём цветового выделения самого важного:

# pip install colorama
from colorama import init, Fore
init(autoreset=True)  # Сбросить цвета после каждой операции вывода данных
def exception_hook(exc_type, exc_value, tb):
    local_vars = {}
    while tb:
        filename = tb.tb_frame.f_code.co_filename
        name = tb.tb_frame.f_code.co_name
        line_no = tb.tb_lineno
        # Снабдить строку сведениями о нужном цвете (например - цветом с кодом RED)
        print(f"{Fore.RED}File {filename} line {line_no}, in {name}")
        local_vars = tb.tb_frame.f_locals
        tb = tb.tb_next
    print(f"{Fore.GREEN}Local variables in top frame: {local_vars}")

Конечно, для улучшения внешнего вида того, что выводится в консоль, можно сделать ещё много всего. Например, можно выводить для каждого кадра локальные переменные, или даже искать переменные, к которым были обращения из строки, в которой произошло исключение. Неудивительно то, что уже созданы перехватчики исключений, реализующие подобные сценарии. Поэтому, если вам это нужно, вместо того, чтобы пытаться создать нечто подобное полностью самостоятельно, я рекомендую взглянуть на следующий код, который способен вдохновить вас на собственные разработки:

• Вывод локальных переменных из каждого кадра

• Вывод дополнительных сведений о кадре (о переменных, к которым осуществляются обращения из кадра)

И наконец — мне хотелось бы вас предостеречь. Всякий раз, когда вы решаете установить перехватчик исключений, учитывайте то, что применяемые вами библиотеки могут устанавливать собственные перехватчики. Удостоверьтесь в том, что вы эти перехватчики не переопределили. В подобных случаях можно поступить иначе — воспользоваться конструкцией try/except и, в блоке except, вывести необходимые сведения, например — с помощью sys.exc_info().

Существующие перехватчики, достойные внимания

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

Начну с моего любимого инструмента — с Rich:

# https://rich.readthedocs.io/en/latest/traceback.html
pip install rich
python -m rich.traceback
from rich.traceback import install
install(show_locals=True)
do_stuff()  # Вызывает ValueError

Воспользоваться этим инструментом очень просто — всё сводится к установке соответствующей библиотеки, к её импорту в проект и к вызову функции install, которая подключает перехватчик исключений. Если вам интересно просто посмотреть на то, что выводит Rich, не занимаясь при этом написанием Python-кода, можете прибегнуть к команде python -m rich.traceback.

Ещё один популярный инструмент такого рода — это библиотека better_exceptions. Она тоже очень приятно оформляет выводимые данные, но, в отличие от Rich, для её настройки нужно приложить немного больше усилий:

# https://github.com/Qix-/better-exceptions
pip install better_exceptions
export BETTER_EXCEPTIONS=1
import better_exceptions
better_exceptions.MAX_LENGTH = None
Проверьте, установлена ли переменная TERM в значение xterm, если это не так - настройте следующую переменную,
Смотрите это сообщение о проблеме: https://github.com/Qix-/better-exceptions/issues/8
better_exceptions.SUPPORTS_COLOR = True
better_exceptions.hook()
do_stuff()  # Вызывает ValueError

Помимо установки библиотеки better-exceptions с помощью pip, нам, чтобы её включить, нужно ещё установить переменную окружения BETTER_EXCEPTIONS=1. После этого библиотеку надо настроить с помощью вышеприведённого Python-кода. Самое важное в нём — это вызов функции hook, которая устанавливает перехватчик исключений. Кроме того, в нём мы устанавливаем SUPPORTS_COLOR в значение True. Необходимость выполнения этой настройки зависит от используемого терминала. В частности, она нужна в том случае, если в TERM записано значение, отличающееся от xterm.

Следующим номером нашей программы будет библиотека pretty_errors. Из тех инструментов, о которых я рассказываю, этот, определённо, отличается самой простой настройкой. Для того чтобы им воспользоваться, его достаточно импортировать в проект:

# https://github.com/onelivesleft/PrettyErrors/
pip install pretty_errors
import pretty_errors
если вас устраивают стандартные настройки - можно обойтись без configure
pretty_errors.configure(
    filename_display    = pretty_errors.FILENAME_EXTENDED,
    line_number_first   = True,
    display_link        = True,
    line_color          = pretty_errors.RED + '> ' + pretty_errors.default_config.line_color,
    code_color          = '  ' + pretty_errors.default_config.line_color,
    truncate_code       = True,
    display_locals      = True
)
do_stuff()

В предыдущем фрагменте кода, помимо обязательной конструкции import, показаны настройки библиотеки, без которых можно обойтись. Это — лишь малая часть тех настроек, которые поддерживает библиотека. Полный список конфигурационных опций pretty_errors можно найти здесь.

Наша следующая библиотека выводит трейсбеки в таком стиле, который окажется знакомым любому, кто пользуется Jupyter Notebook. Речь идёт об IPython-модуле ultratb. Он позволяет выводить сообщения об ошибках и трейсбеки, которые хорошо выглядят и легко читаются:

# https://ipython.readthedocs.io/en/stable/api/generated/IPython.core.ultratb.html
pip install ipython
import IPython.core.ultratb
Ещё - ColorTB, FormattedTB, ListTB, SyntaxTB
sys.excepthook = IPython.core.ultratb.VerboseTB(color_scheme='Linux')  # Другие цветовые схемы: NoColor, LightBG, Neutral
do_stuff()

И вот — ещё одна библиотека, stackprinter, последняя в моём списке, но далеко не последняя по своим возможностям. Она выдаёт чёткие сведения о проблемах, содержащие всю необходимую отладочную информацию. Для того чтобы ей воспользоваться — достаточно установить перехватчик исключений:

# https://github.com/cknd/stackprinter
pip install stackprinter
import stackprinter
stackprinter.set_excepthook(style='darkbg2')
do_stuff()

Итоги

Из этого материала вы узнали о том, как создавать собственные перехватчики исключений. Но я, на самом деле, не порекомендовал бы этим заниматься. Реализация подобного перехватчика может оказаться интересной программистской задачкой, но целесообразность подобной разработки, вероятно, находится под вопросом. Лучше подобрать что-то из существующих библиотек, рассмотренных выше.

А вот что я бы точно порекомендовал — так это выбрать одну из этих библиотек и установить её во всех проектах, над которыми вы работаете. Сделать это стоит для совершенствования отладки кода и ради единообразия используемых инструментов. Чем интенсивнее вы используете один из вышеописанных перехватчиков исключений — тем больше вы привыкаете к выдаваемым им данным, и, как следствие, тем больше пользы можете из них извлечь.

Учитывая вышесказанное — советую вам подумать о том, чтобы убрать собственные перехватчики исключений из продакшн-сборок. Дело в том, что особенности оформления выходных данных могут скрыть от нас некоторые сведения об ошибках, которые, в определённых ситуациях, могут оказаться крайне важными. Скажем, в некоторых из вышеприведённых примеров отсутствуют пути к файлам. Это способствует улучшению читабельности вывода при локальной отладке, но может усложнить жизнь программисту при отладке кода, выполняющегося на удалённой системе.

О, а приходите к нам работать? 😏

Содержание:развернуть

• Как устроен механизм исключений
• Как обрабатывать исключения в Python (try except)

• As — сохраняет ошибку в переменную

• Finally — выполняется всегда

• Else — выполняется когда исключение не было вызвано

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

• Несколько типов исключений в одном блоке except

• Raise — самостоятельный вызов исключений

• Как пропустить ошибку

• Исключения в lambda функциях
• 20 типов встроенных исключений в Python
• Как создать свой тип Exception

Программа, написанная на языке Python, останавливается сразу как обнаружит ошибку. Ошибки могут быть (как минимум) двух типов:

• Синтаксические ошибки — возникают, когда написанное выражение не соответствует правилам языка (например, написана лишняя скобка);
• Исключения — возникают во время выполнения программы (например, при делении на ноль).

Синтаксические ошибки исправить просто (если вы используете IDE, он их подсветит). А вот с исключениями всё немного сложнее — не всегда при написании программы можно сказать возникнет или нет в данном месте исключение. Чтобы приложение продолжило работу при возникновении проблем, такие ошибки нужно перехватывать и обрабатывать с помощью блока try/except.

Как устроен механизм исключений

В Python есть встроенные исключения, которые появляются после того как приложение находит ошибку. В этом случае текущий процесс временно приостанавливается и передает ошибку на уровень вверх до тех пор, пока она не будет обработано. Если ошибка не будет обработана, программа прекратит свою работу (а в консоли мы увидим Traceback с подробным описанием ошибки).

💁‍♂️ Пример: напишем скрипт, в котором функция ожидает число, а мы передаём сроку (это вызовет исключение «TypeError»):

def b(value):
print("-> b")
print(value + 1) # ошибка тут

> -> a
> -> b
> Traceback (most recent call last):
> File "test.py", line 11, in <module>
> a("10")
> File "test.py", line 8, in a
> b(value)
> File "test.py", line 3, in b
> print(value + 1)
> TypeError: can only concatenate str (not "int") to str

В данном примере мы запускаем файл «test.py» (через консоль). Вызывается функция «a«, внутри которой вызывается функция «b«. Все работает хорошо до сточки print(value + 1). Тут интерпретатор понимает, что нельзя конкатенировать строку с числом, останавливает выполнение программы и вызывает исключение «TypeError».

Далее ошибка передается по цепочке в обратном направлении: «b» → «a» → «test.py«. Так как в данном примере мы не позаботились обработать эту ошибку, вся информация по ошибке отобразится в консоли в виде Traceback.

Traceback (трассировка) — это отчёт, содержащий вызовы функций, выполненные в определенный момент. Трассировка помогает узнать, что пошло не так и в каком месте это произошло.

Traceback лучше читать снизу вверх ↑

В нашем примере Traceback содержится следующую информацию (читаем снизу вверх):

1. TypeError — тип ошибки (означает, что операция не может быть выполнена с переменной этого типа);
2. can only concatenate str (not "int") to str — подробное описание ошибки (конкатенировать можно только строку со строкой);
3. Стек вызова функций (1-я линия — место, 2-я линия — код). В нашем примере видно, что в файле «test.py» на 11-й линии был вызов функции «a» со строковым аргументом «10». Далее был вызов функции «b». print(value + 1) это последнее, что было выполнено — тут и произошла ошибка.
4. most recent call last — означает, что самый последний вызов будет отображаться последним в стеке (в нашем примере последним выполнился print(value + 1)).

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

Как обрабатывать исключения в Python (try except)

В Python исключения обрабатываются с помощью блоков try/except. Для этого операция, которая может вызвать исключение, помещается внутрь блока try. А код, который должен быть выполнен при возникновении ошибки, находится внутри except.

Например, вот как можно обработать ошибку деления на ноль:

try:
a = 7 / 0
except:
print('Ошибка! Деление на 0')

Здесь в блоке try находится код a = 7 / 0 — при попытке его выполнить возникнет исключение и выполнится код в блоке except (то есть будет выведено сообщение «Ошибка! Деление на 0»). После этого программа продолжит свое выполнение.

💭 PEP 8 рекомендует, по возможности, указывать конкретный тип исключения после ключевого слова except (чтобы перехватывать и обрабатывать конкретные исключения):

try:
a = 7 / 0
except ZeroDivisionError:
print('Ошибка! Деление на 0')

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

try:
a = 7 / 0
except Exception:
print('Любая ошибка!')

As — сохраняет ошибку в переменную

Перехваченная ошибка представляет собой объект класса, унаследованного от «BaseException». С помощью ключевого слова as можно записать этот объект в переменную, чтобы обратиться к нему внутри блока except:

try:
file = open('ok123.txt', 'r')
except FileNotFoundError as e:
print(e)

> [Errno 2] No such file or directory: 'ok123.txt'

В примере выше мы обращаемся к объекту класса «FileNotFoundError» (при выводе на экран через print отобразится строка с полным описанием ошибки).

У каждого объекта есть поля, к которым можно обращаться (например если нужно логировать ошибку в собственном формате):

import datetime

> 20-11-2021 18:42:01 [FileNotFoundError]: No such file or directory, filename: ok123.txt

Finally — выполняется всегда

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

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

В следующем примере откроем файл и обратимся к несуществующей строке:

file = open('ok.txt', 'r')

> файл закрыт!
> Traceback (most recent call last):
> File "test.py", line 5, in <module>
> print(lines[5])
> IndexError: list index out of range

Даже после исключения «IndexError», сработал код в секции finally, который закрыл файл.

p.s. данный пример создан для демонстрации, в реальном проекте для работы с файлами лучше использовать менеджер контекста with.

Также можно использовать одновременно три блока try/except/finally. В этом случае:

• в try — код, который может вызвать исключения;
• в except — код, который должен выполниться при возникновении исключения;
• в finally — код, который должен выполниться в любом случае.

def sum(a, b):
res = 0

> a = 1, b = 2, res = 3

Else — выполняется когда исключение не было вызвано

Иногда нужно выполнить определенные действия, когда код внутри блока try не вызвал исключения. Для этого используется блок else.

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

b = int(input('b = '))
c = int(input('c = '))
try:
a = b / c
except ZeroDivisionError:
print('Ошибка! Деление на 0')
else:
print(f"a = {a}")

> b = 10
> c = 1
> a = 10.0

В этом случае, если пользователь присвоит переменной «с» ноль, то появится исключение и будет выведено сообщение «‘Ошибка! Деление на 0′», а код внутри блока else выполняться не будет. Если ошибки не будет, то на экране появятся результаты деления.

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

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

1. Ошибка преобразования введенных значений к типу float («ValueError»);
2. Деление на ноль («ZeroDivisionError»).

В Python, чтобы по-разному обрабатывать разные типы ошибок, создают несколько блоков except:

try:
b = float(input('b = '))
c = float(input('c = '))
a = b / c
except ZeroDivisionError:
print('Ошибка! Деление на 0')
except ValueError:
print('Число введено неверно')
else:
print(f"a = {a}")

> b = 10
> c = питон
> Число введено неверно

Теперь для разных типов ошибок есть свой обработчик.

Несколько типов исключений в одном блоке except

Можно также обрабатывать в одном блоке except сразу несколько исключений. Для этого они записываются в круглых скобках, через запятую сразу после ключевого слова except. Чтобы обработать сообщения «ZeroDivisionError» и «ValueError» в одном блоке записываем их следующим образом:

try:
b = float(input('b = '))
c = float(input('c = '))
a = b / c
except (ZeroDivisionError, ValueError) as er:
print(er)
else:
print('a = ', a)

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

Raise — самостоятельный вызов исключений

Исключения можно генерировать самостоятельно — для этого нужно запустить оператор raise.

min = 100
if min > 10:
raise Exception('min must be less than 10')

> Traceback (most recent call last):
> File "test.py", line 3, in <module>
> raise Exception('min value must be less than 10')
> Exception: min must be less than 10

Перехватываются такие сообщения точно так же, как и остальные:

min = 100

> Моя ошибка

Кроме того, ошибку можно обработать в блоке except и пробросить дальше (вверх по стеку) с помощью raise:

min = 100

> Моя ошибка
> Traceback (most recent call last):
> File "test.py", line 5, in <module>
> raise Exception('min must be less than 10')
> Exception: min must be less than 10

Как пропустить ошибку

Иногда ошибку обрабатывать не нужно. В этом случае ее можно пропустить с помощью pass:

try:
a = 7 / 0
except ZeroDivisionError:
pass

Исключения в lambda функциях

Обрабатывать исключения внутри lambda функций нельзя (так как lambda записывается в виде одного выражения). В этом случае нужно использовать именованную функцию.

20 типов встроенных исключений в Python

Иерархия классов для встроенных исключений в Python выглядит так:

BaseException
SystemExit
KeyboardInterrupt
GeneratorExit
Exception
ArithmeticError
AssertionError
...
...
...
ValueError
Warning

Все исключения в Python наследуются от базового BaseException:

• SystemExit — системное исключение, вызываемое функцией sys.exit() во время выхода из приложения;
• KeyboardInterrupt — возникает при завершении программы пользователем (чаще всего при нажатии клавиш Ctrl+C);
• GeneratorExit — вызывается методом close объекта generator;
• Exception — исключения, которые можно и нужно обрабатывать (предыдущие были системными и их трогать не рекомендуется).

От Exception наследуются:

1 StopIteration — вызывается функцией next в том случае если в итераторе закончились элементы;

2 ArithmeticError — ошибки, возникающие при вычислении, бывают следующие типы:

• FloatingPointError — ошибки при выполнении вычислений с плавающей точкой (встречаются редко);
• OverflowError — результат вычислений большой для текущего представления (не появляется при операциях с целыми числами, но может появиться в некоторых других случаях);
• ZeroDivisionError — возникает при попытке деления на ноль.

3 AssertionError — выражение, используемое в функции assert неверно;

4 AttributeError — у объекта отсутствует нужный атрибут;

5 BufferError — операция, для выполнения которой требуется буфер, не выполнена;

6 EOFError — ошибка чтения из файла;

7 ImportError — ошибка импортирования модуля;

8 LookupError — неверный индекс, делится на два типа:

• IndexError — индекс выходит за пределы диапазона элементов;
• KeyError — индекс отсутствует (для словарей, множеств и подобных объектов);

9 MemoryError — память переполнена;

10 NameError — отсутствует переменная с данным именем;

11 OSError — исключения, генерируемые операционной системой:

• ChildProcessError — ошибки, связанные с выполнением дочернего процесса;
• ConnectionError — исключения связанные с подключениями (BrokenPipeError, ConnectionResetError, ConnectionRefusedError, ConnectionAbortedError);
• FileExistsError — возникает при попытке создания уже существующего файла или директории;
• FileNotFoundError — генерируется при попытке обращения к несуществующему файлу;
• InterruptedError — возникает в том случае если системный вызов был прерван внешним сигналом;
• IsADirectoryError — программа обращается к файлу, а это директория;
• NotADirectoryError — приложение обращается к директории, а это файл;
• PermissionError — прав доступа недостаточно для выполнения операции;
• ProcessLookupError — процесс, к которому обращается приложение не запущен или отсутствует;
• TimeoutError — время ожидания истекло;

12 ReferenceError — попытка доступа к объекту с помощью слабой ссылки, когда объект не существует;

13 RuntimeError — генерируется в случае, когда исключение не может быть классифицировано или не подпадает под любую другую категорию;

14 NotImplementedError — абстрактные методы класса нуждаются в переопределении;

15 SyntaxError — ошибка синтаксиса;

16 SystemError — сигнализирует о внутренне ошибке;

17 TypeError — операция не может быть выполнена с переменной этого типа;

18 ValueError — возникает когда в функцию передается объект правильного типа, но имеющий некорректное значение;

19 UnicodeError — исключение связанное с кодирование текста в unicode, бывает трех видов:

• UnicodeEncodeError — ошибка кодирования;
• UnicodeDecodeError — ошибка декодирования;
• UnicodeTranslateError — ошибка перевода unicode.

20 Warning — предупреждение, некритическая ошибка.

💭 Посмотреть всю цепочку наследования конкретного типа исключения можно с помощью модуля inspect:

import inspect

> (<class 'TimeoutError'>, <class 'OSError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)

📄 Подробное описание всех классов встроенных исключений в Python смотрите в официальной документации.

Как создать свой тип Exception

В Python можно создавать свои исключения. При этом есть одно обязательное условие: они должны быть потомками класса Exception:

class MyError(Exception):
def __init__(self, text):
self.txt = text

> Моя ошибка

С помощью try/except контролируются и обрабатываются ошибки в приложении. Это особенно актуально для критически важных частей программы, где любые «падения» недопустимы (или могут привести к негативным последствиям). Например, если программа работает как «демон», падение приведет к полной остановке её работы. Или, например, при временном сбое соединения с базой данных, программа также прервёт своё выполнение (хотя можно было отловить ошибку и попробовать соединиться в БД заново).

Вместе с try/except можно использовать дополнительные блоки. Если использовать все блоки описанные в статье, то код будет выглядеть так:

try:
# попробуем что-то сделать
except (ZeroDivisionError, ValueError) as e:
# обрабатываем исключения типа ZeroDivisionError или ValueError
except Exception as e:
# исключение не ZeroDivisionError и не ValueError
# поэтому обрабатываем исключение общего типа (унаследованное от Exception)
# сюда не сходят исключения типа GeneratorExit, KeyboardInterrupt, SystemExit
else:
# этот блок выполняется, если нет исключений
# если в этом блоке сделать return, он не будет вызван, пока не выполнился блок finally
finally:
# этот блок выполняется всегда, даже если нет исключений else будет проигнорирован
# если в этом блоке сделать return, то return в блоке

Подробнее о работе с исключениями в Python можно ознакомиться в официальной документации.