Ошибка обратная трассировка python

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

Содержание статьи

• Traceback — Что это такое и почему оно появляется?
• Как правильно читать трассировку?
• Обзор трассировка Python
• Подробный обзор трассировки в Python
• Обзор основных Traceback исключений в Python
• AttributeError
• ImportError
• IndexError
• KeyError
• NameError
• SyntaxError
• TypeError
• ValueError
• Логирование ошибок из Traceback
• Вывод

Понимание того, какую информацию предоставляет traceback Python является основополагающим критерием того, как стать лучшим Python программистом.

К концу данной статьи вы сможете:

• Понимать, что несет за собой traceback
• Различать основные виды traceback
• Успешно вести журнал traceback, при этом исправить ошибку

Python Traceback — Как правильно читать трассировку?

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

Traceback называют по разному, иногда они упоминаются как трассировка стэка, обратная трассировка, и так далее. В Python используется определение “трассировка”.

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

Здесь say_hello() вызывается с параметром man. Однако, в say_hello() это имя переменной не используется. Это связано с тем, что оно написано по другому: wrong_variable в вызове print().

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

Когда вы запускаете эту программу, вы получите следующую трассировку:

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

В traceback выше, ошибкой является NameError, она означает, что есть отсылка к какому-то имени (переменной, функции, класса), которое не было определено. В данном случае, ссылаются на имя wrong_variable.

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

Python Traceback — Как правильно понять в чем ошибка?

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

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

В Python лучше всего читать трассировку снизу вверх.

1. Синее поле: последняя строка из traceback — это строка уведомления об ошибке. Синий фрагмент содержит название возникшей ошибки.
2. Зеленое поле: после названия ошибки идет описание ошибки. Это описание обычно содержит полезную информацию для понимания причины возникновения ошибки.
3. Желтое поле: чуть выше в трассировке содержатся различные вызовы функций. Снизу вверх — от самых последних, до самых первых. Эти вызовы представлены двухстрочными вводами для каждого вызова. Первая строка каждого вызова содержит такую информацию, как название файла, номер строки и название модуля. Все они указывают на то, где может быть найден код.
4. Красное подчеркивание: вторая строка этих вызовов содержит непосредственный код, который был выполнен с ошибкой.

Есть ряд отличий между выдачей трассировок, когда вы запускает код в командной строке, и между запуском кода в REPL. Ниже вы можете видеть тот же код из предыдущего раздела, запущенного в REPL и итоговой выдачей трассировки:

Обратите внимание на то, что на месте названия файла вы увидите <stdin>. Это логично, так как вы выполнили код через стандартный ввод. Кроме этого, выполненные строки кода не отображаются в traceback.

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

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

Traceback в Python на примерах кода

Изучение отдельно взятой трассировки поможет вам лучше понять и увидеть, какая информация в ней вам дана и как её применить.

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

Мы запустили ниже предоставленный код в качестве примера и покажем какую информацию мы получили от трассировки.

Сохраняем данный код в файле greetings.py

Функция who_to_greet() принимает значение person и либо возвращает данное значение если оно не пустое, либо запрашивает  значение от пользовательского ввода через input().

Далее, greet() берет имя для приветствия из someone, необязательное значение из greeting и вызывает print(). Также с переданным значением из someone вызывается who_to_greet().

Наконец, greet_many() выполнит итерацию по списку людей и вызовет greet(). Если при вызове greet() возникает ошибка, то выводится резервное приветствие print('hi, ' + person).

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

Если вы добавите вызов функции greet() в конце нашего кода (которого сохранили в файл greetings.py) и дадите аргумент который он не ожидает (например, greet('Chad', greting='Хай')), то вы получите следующую трассировку:

Еще раз, в случае с трассировкой Python, лучше анализировать снизу вверх. Начиная с последней строки трассировки, вы увидите, что ошибкой является TypeError. Сообщения, которые следуют за типом ошибки, дают вам полезную информацию. Трассировка сообщает, что greet() вызван с аргументом, который не ожидался. Неизвестное название аргумента предоставляется в том числе, в нашем случае это greting.

Поднимаясь выше, вы можете видеть строку, которая привела к исключению. В данном случае, это вызов greet(), который мы добавили в конце greetings.py.

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

С другим файлом и другим вводом, вы можете увидеть, что трассировка явно указывает вам на правильное направление, чтобы найти проблему. Следуя этой информации, мы удаляем злополучный вызов greet() в конце greetings.py, и добавляем следующий файл под названием example.py в папку:

Здесь вы настраиваете еще один файл Python, который импортирует ваш предыдущий модуль greetings.py, и используете его greet(). Вот что произойдете, если вы запустите example.py:

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

Идя выше, вы увидите строку кода, которая выполняется. Затем файл и номер строки кода. На этот раз мы получаем имя функции, которая была выполнена — greet().

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

Иногда, после появления ошибки, другой кусок кода берет эту ошибку и также её выдает. В таких случаях, Python выдает все трассировки ошибки в том порядке, в котором они были получены, и все по тому же принципу, заканчивая на самой последней трассировке.

Так как это может сбивать с толку, рассмотрим пример. Добавим вызов greet_many() в конце greetings.py:

Это должно привести к выводу приветствия всем трем людям. Однако, если вы запустите этот код, вы увидите несколько трассировок в выдаче:

Обратите внимание на выделенную строку, начинающуюся с “During handling in the output above”. Между всеми трассировками, вы ее увидите.

Это достаточно ясное уведомление: Пока ваш код пытался обработать предыдущую ошибку, возникла новая.

Обратите внимание: функция отображения предыдущих трассировок была добавлена в Python 3. В Python 2 вы можете получать только трассировку последней ошибки.

Вы могли видеть предыдущую ошибку, когда вызывали greet() с целым числом. Так как мы добавили 1 в список людей для приветствия, мы можем ожидать тот же результат. Однако, функция greet_many() оборачивает вызов greet() и пытается в блоке try и except. На случай, если greet() приведет к ошибке, greet_many() захочет вывести приветствие по-умолчанию.

Соответствующая часть greetings.py повторяется здесь:

Когда greet() приводит к TypeError из-за неправильного ввода числа, greet_many() обрабатывает эту ошибку и пытается вывести простое приветствие. Здесь код приводит к другой, аналогичной ошибке. Он все еще пытается добавить строку и целое число.

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

Обзор основных Traceback исключений в Python 3

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

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

Ошибка AttributeError object has no attribute [Решено]

AttributeError возникает тогда, когда вы пытаетесь получить доступ к атрибуту объекта, который не содержит определенного атрибута. Документация Python определяет, когда эта ошибка возникнет:

Возникает при вызове несуществующего атрибута или присвоение значения несуществующему атрибуту.

Пример ошибки AttributeError:

Строка уведомления об ошибке для AttributeError говорит вам, что определенный тип объекта, в данном случае int, не имеет доступа к атрибуту, в нашем случае an_attribute. Увидев AttributeError в строке уведомления об ошибке, вы можете быстро определить, к какому атрибуту вы пытались получить доступ, и куда перейти, чтобы это исправить.

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

В примере выше, вы можете ожидать, что a_list будет типом списка, который содержит метод .append(). Когда вы получаете ошибку AttributeError, и видите, что она возникла при попытке вызова .append(), это говорит о том, что вы, возможно, не работаете с типом объекта, который ожидаете.

Часто это происходит тогда, когда вы ожидаете, что объект вернется из вызова функции или метода и будет принадлежать к определенному типу, но вы получаете тип объекта None. В данном случае, строка уведомления об ошибке будет выглядеть так:

AttributeError: ‘NoneType’ object has no attribute ‘append’

Python Ошибка ImportError: No module named [Решено]

ImportError возникает, когда что-то идет не так с оператором import. Вы получите эту ошибку, или ее подкласс ModuleNotFoundError, если модуль, который вы хотите импортировать, не может быть найден, или если вы пытаетесь импортировать что-то, чего не существует во взятом модуле. Документация Python определяет, когда возникает эта ошибка:

Ошибка появляется, когда в операторе импорта возникают проблемы при попытке загрузить модуль. Также вызывается, при конструкции импорта from list в from ... import имеет имя, которое невозможно найти.

Вот пример появления ImportError и ModuleNotFoundError:

В примере выше, вы можете видеть, что попытка импорта модуля asdf, который не существует, приводит к ModuleNotFoundError. При попытке импорта того, что не существует (в нашем случае — asdf) из модуля, который существует (в нашем случае — collections), приводит к ImportError. Строки сообщения об ошибке трассировок указывают на то, какая вещь не может быть импортирована, в обоих случаях это asdf.

Ошибка IndexError: list index out of range [Решено]

IndexError возникает тогда, когда вы пытаетесь вернуть индекс из последовательности, такой как список или кортеж, и при этом индекс не может быть найден в последовательности. Документация Python определяет, где эта ошибка появляется:

Возникает, когда индекс последовательности находится вне диапазона.

Вот пример, который приводит к IndexError:

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

Иными словами, в списке a_list нет значения с ключом 3. Есть только значение с ключами 0 и 1, это a и b соответственно.

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

Возникает ошибка KeyError в Python 3 [Решено]

Как и в случае с IndexError, KeyError возникает, когда вы пытаетесь получить доступ к ключу, который отсутствует в отображении, как правило, это dict. Вы можете рассматривать его как IndexError, но для словарей. Из документации:

Возникает, когда ключ словаря не найден в наборе существующих ключей.

Вот пример появления ошибки KeyError:

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

Ошибка NameError: name is not defined в Python [Решено]

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

Документация Python дает понять, когда возникает эта ошибка NameError:

Возникает, когда локальное или глобальное название не было найдено.

В коде ниже, greet() берет параметр person. Но в самой функции, этот параметр был назван с ошибкой, persn:

Строка уведомления об ошибке трассировки NameError указывает вам на название, которое мы ищем. В примере выше, это названная с ошибкой переменная или параметр функции, которые были ей переданы.

NameError также возникнет, если берется параметр, который мы назвали неправильно:

Здесь все выглядит так, будто вы сделали все правильно. Последняя строка, которая была выполнена, и на которую ссылается трассировка выглядит хорошо.

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

Ошибка SyntaxError: invalid syntax в Python [Решено]

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

Ниже, проблема заключается в отсутствии двоеточия, которое должно находиться в конце строки определения функции. В REPL Python, эта ошибка синтаксиса возникает сразу после нажатия Enter:

Строка уведомления об ошибке SyntaxError говорит вам только, что есть проблема с синтаксисом вашего кода. Просмотр строк выше укажет вам на строку с проблемой. Каретка ^ обычно указывает на проблемное место. В нашем случае, это отсутствие двоеточия в операторе def нашей функции.

Стоит отметить, что в случае с трассировками SyntaxError, привычная первая строка Tracebak (самый последний вызов) отсутствует. Это происходит из-за того, что SyntaxError возникает, когда Python пытается парсить ваш код, но строки фактически не выполняются.

Ошибка TypeError в Python 3 [Решено]

TypeError возникает, когда ваш код пытается сделать что-либо с объектом, который не может этого выполнить, например, попытка добавить строку в целое число, или вызвать len() для объекта, в котором не определена длина.

Ошибка возникает, когда операция или функция применяется к объекту неподходящего типа.

Рассмотрим несколько примеров того, когда возникает TypeError:

Указанные выше примеры возникновения TypeError приводят к строке уведомления об ошибке с разными сообщениями. Каждое из них весьма точно информирует вас о том, что пошло не так.

В первых двух примерах мы пытаемся внести строки и целые числа вместе. Однако, они немного отличаются:

• В первом примере мы пытаемся добавить str к int.
• Во втором примере мы пытаемся добавить int к str.

Уведомления об ошибке указывают на эти различия.

Последний пример пытается вызвать len() для int. Сообщение об ошибке говорит нам, что мы не можем сделать это с int.

Возникла ошибка ValueError в Python 3 [Решено]

ValueError возникает тогда, когда значение объекта не является корректным. Мы можем рассматривать это как IndexError, которая возникает из-за того, что значение индекса находится вне рамок последовательности, только ValueError является более обобщенным случаем.

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

Вот два примера возникновения ошибки ValueError:

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

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

Логирование ошибок из Traceback в Python 3

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

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

Файл urlcaller.py:

Этот код работает исправно. Когда вы запускаете этот скрипт, задавая ему URL в качестве аргумента командной строки, он откроет данный URL, и затем выведет HTTP статус кода и содержимое страницы (content) из response. Это работает даже в случае, если ответом является статус ошибки HTTP:

Однако, иногда данный URL не существует (ошибка 404 — страница не найдена), или сервер не работает. В таких случаях, этот скрипт приводит к ошибке ConnectionError и выводит трассировку:

Трассировка Python в данном случае может быть очень длинной, и включать в себя множество других ошибок, которые в итоге приводят к ошибке ConnectionError. Если вы перейдете к трассировке последних ошибок, вы заметите, что все проблемы в коде начались на пятой строке файла urlcaller.py.

Если вы обернёте неправильную строку в блоке try и except, вы сможете найти нужную ошибку, которая позволит вашему скрипту работать с большим числом вводов:

Файл urlcaller.py:

Код выше использует предложение else с блоком except.

Теперь, когда вы запускаете скрипт на URL, который приводит к ошибке ConnectionError, вы получите -1 в статусе кода и содержимое ошибки подключения:

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

Обратите внимание: Для более лучшего представления о системе логирования в Python вы можете ознакомиться с данным руководством тут: Логирование в Python

Вы можете вести журнал трассировки в скрипте, импортировав пакет logging, получить logger, вызвать .exception() для этого логгера в куске except блока try и except. Конечный скрипт будет выглядеть примерно так:

Теперь, когда вы запускаете скрипт с проблемным URL, он будет выводить исключенные -1 и ConnectionError, но также будет вести журнал трассировки:

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

Подведем итоги данного обучающего материала

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

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

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

• Текст является переводом статьи: Understanding the Python Traceback
• Изображение из шапки статьи принадлежит сайту © Real Python

Перевод статьи Chad Hansen : Understanding the Python Traceback

Содержание

• Что такое Traceback в Python?
• Как читать Traceback?
  • Обзор Traceback
  • Пример чтения трассировки
• Каковы некоторые общие трассировки в Python?
  • AttributeError
  • ImportError
  • IndexError
  • KeyError
  • NameError
  • SyntaxError
  • TypeError
  • ValueError
• Как логировать трассировку?
• Заключение

Python отображает трассировку (traceback) при возникновении исключения в вашем коде. Содержимое трассировки может быть немного запутанным, если вы видите ее впервые или не знаете, что в она означает. Но трассировка содержит множество информации, которая может помочь вам диагностировать и устранить причину возникновения исключения.

К концу этой статьи вы сможете:

• Лучше разбираться с содержимом трассировки (traceback)
• Сразу узнавать некоторые из наиболее распространенных шаблонов в трассировке
• Узнаете как правильно логировать трассировку, в то же время обрабатывая исключение

Трассировка (Traceback) — это отчет, содержащий вызовы функций, сделанные в вашем коде в определенный момент. Трассировка известна под многими именами, включая stack trace (трассировку стека), stack traceback (трассировку стека), backtrace (обратную трассировку) и, возможно, другие. В Python используется термин traceback.

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

# example.py
def greet(someone):
    print('Hello, ' + someon)

greet('Chad')

Здесь вызывается функция greet() с параметром someone. Однако в greet() это имя переменной не используется. Вместо этого было ошибочно указано переменная someon в вызове print().

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

Когда вы запустите эту программу, вы получите следующий traceback:

$ python example.py
Traceback (most recent call last):
  File "/path/to/example.py", line 4, in <module>
    greet('Chad')
  File "/path/to/example.py", line 2, in greet
    print('Hello, ' + someon)
NameError: name 'someon' is not defined

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

В приведенной выше traceback исключением был NameError, что означает, что имеется ссылка на какое-то имя (переменная, функция, класс), которое не было определено. В нашем примере использовано имя — someon.

В последней строке в этом случае достаточно информации, чтобы помочь вам решить проблему. Поиск кода по имени someon, который является орфографической ошибкой, укажет вам правильное направление. Однако часто ваш код намного сложнее.

Как читать Traceback?

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

Обзор Traceback

Есть несколько разделов в каждой трассировки, которые по своему важны. Диаграмма ниже выделяет эти части:

В Python лучше читать трассировку снизу вверх:

1. Синяя рамка: Последняя строка трассировки является строкой сообщения об ошибке. Она содержит имя исключения, которое было вызвано.
2. Зеленая рамка: После имени исключения появляется сообщение об ошибке. Это сообщение обычно содержит полезную информацию для понимания причины возникновения исключения.
3. Желтая рамка: Далее по трассировке следуют различные вызовы функций, перемещающиеся снизу вверх. Эти вызовы представлены двухстрочными записями для каждого вызова. Первая строка каждого вызова содержит информацию, такую как имя файла, номер строки и имя модуля, это указывает, где можно найти код.
4. Красная рамка: Вторая строка для этих вызовов содержит фактический код, который был выполнен.

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

>>> def greet(someone):
...   print('Hello, ' + someon)
... 
>>> greet('Chad')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in greet
NameError: name 'someon' is not defined

Обратите внимание, что вместо имен файлов вы получаете <stdin>. Это имеет смысл, поскольку вы вводили код с помощью стандартного ввода. Кроме того, выполненные строки кода не отображаются в трассировке.

Примечание. Если вы привыкли видеть трассировки стека в других языках программирования, вы заметите существенное различие в том, как выглядит трассировка в Python. Большинство других языков печатают исключение сверху, а затем идут сверху вниз, самые последние вызовы — наименее недавние.

Пример чтения трассировки

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

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

# greetings.py
def who_to_greet(person):
    return person if person else input('Greet who? ')

def greet(someone, greeting='Hello'):
    print(greeting + ', ' + who_to_greet(someone))

def greet_many(people):
    for person in people:
        try:
            greet(person)
        except Exception:
            print('hi, ' + person)

Здесь who_to_greet() принимает значение person и либо возвращает его, либо запрашивает возвращаемое значение.

Затем greet() принимает имя, которое нужно приветствовать, someone, и необязательное значение greeting и вызывает print(). who_to_greet() также вызывается с переданным значением someone.

Наконец, greet_many() будет перебирать список people и вызывать greet(). Если при вызове greet() возникает исключение, то выводится простое резервное приветствие.

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

Если вы добавите вызов greet() в конец файла greetings.py и укажете аргумент ключевого слова, которого он не ожидает (например, greet(‘Chad’, greting = ‘Yo’)), то вы получите следующую ошибку:

Traceback (most recent call last):
  File "/path/to/greetings.py", line 19, in <module>
    greet('Chad', greting='Yo')
TypeError: greet() got an unexpected keyword argument 'greting'

Еще раз, с трассировкой Python, лучше работать в обратном направлении, двигаясь вверх по выводу. Начиная с последней строки трассировки, вы можете видеть, что исключением является TypeError. Сообщения, которые следуют за типом исключения, все что после двоеточия, дают вам важную информацию. Оно говорит вам, что greet() был вызван с аргументом ключевого слова, которого он не ожидал. Вам также дано неизвестное имя аргумента: greting.

Двигаясь вверх, вы можете увидеть строку, которая привела к исключению. В данном случае это вызов greet(), который мы добавили в конец greetings.py.

В следующей строке вы увидите путь к файлу, в котором существует код, номер строки этого файла, в котором можно найти код, и модуль, в котором он находится. В этом случае, поскольку наш код не использует какие-либо другие модули Python мы просто видим <module> здесь, что означает, что это исполняемый файл.

С другим файлом и другим вводом вы можете увидеть, что трассировка действительно указывает вам правильное направление, чтобы найти проблему. Если вы следуете дальше, удалите глючный вызов greet() из нижней части greetings.py и добавьте новый файл example.py со следующим содержимым:

# example.py
from greetings import greet

greet(1)

В этом файле вы импортируете ваш предыдущий модуль, greetings.py, и использует из него greet(). Вот что произойдет, если вы запустите example.py:

$ python example.py
Traceback (most recent call last):
  File "/path/to/example.py", line 3, in <module>
    greet(1)
  File "/path/to/greetings.py", line 5, in greet
    print(greeting + ', ' + who_to_greet(someone))
TypeError: must be str, not int

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

Двигаясь вверх, вы видите строку кода, которая была выполнена. Затем файл и номер строки кода. Однако на этот раз вместо <module> мы получаем имя функции, которая выполнялась, greet().

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

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

Так как это может немного сбить с толку, рассмотрим пример. Добавьте вызов greet_many() в конец greetings.py:

# greetings.py
...
greet_many(['Chad', 'Dan', 1])

Это должно привести к выводу приветствия всем трем людям. Однако, если вы запустите этот код, вы увидите пример вывода нескольких трассировок:

$ python greetings.py
Hello, Chad
Hello, Dan
Traceback (most recent call last):
  File "greetings.py", line 10, in greet_many
    greet(person)
  File "greetings.py", line 5, in greet
    print(greeting + ', ' + who_to_greet(someone))
TypeError: must be str, not int

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "greetings.py", line 14, in <module>
    greet_many(['Chad', 'Dan', 1])
  File "greetings.py", line 12, in greet_many
    print('hi, ' + person)
TypeError: must be str, not int

Обратите внимание на выделенную строку, During handling… в данных выше. Это означает что, пока ваш код пытался обработать предыдущее исключение, возникло другое исключение.

Примечание. Функция отображения обратных трассировок предыдущих исключений была добавлена в Python 3. В Python 2 вы получите только трассировку последнего исключения.

Вы видели предыдущее исключение раньше, когда вызывали greet() с целым числом. Поскольку мы добавили 1 к списку приветствующих людей, мы можем ожидать того же результата. Однако функция greet_many() упаковывает вызов greet() в блок try и except. На случай, если greet() вызывает исключение, тогда greet_many() будет выводить приветствие по умолчанию.

Еще раз повторим соответствующую часть greetings.py:

def greet_many(people):
    for person in people:
        try:
            greet(person)
        except Exception:
            print('hi, ' + person)

Поэтому, когда greet() приводит к TypeError из-за неправильного целочисленного ввода, greet_many() обрабатывает это исключение и пытается вывести простое приветствие. Здесь код заканчивается в результате другого, похожего, исключения. Он все еще пытается добавить строку и целое число.

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

Каковы некоторые общие трассировки в Python?

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

Далее рассмотрим некоторые распространенные исключения, с которыми вы можете столкнуться.

AttributeError

AttributeError вызывается, когда вы пытаетесь получить доступ к атрибуту объекта, для которого этот атрибут не определен.

Возникает при сбое ссылки на атрибут или при операции присвоения. (Источник)

Вот пример возникновения AttributeError:

>>> an_int = 1
>>> an_int.an_attribute
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'an_attribute'

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

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

>>> a_list = (1, 2)
>>> a_list.append(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'

В приведенном выше примере вы можете ожидать, что a_list будет иметь тип list, у которого есть метод с именем .append(). Когда вы получаете исключение AttributeError и видите, что оно было сгенерировано, когда вы попытались вызвать .append(), это говорит о том, что вы, вероятно, не имеете дело с ожидаемым типом объекта.

Часто это происходит, когда вы ожидаете, что объект будет возвращен из вызова функции или метода определенного типа, а в результате вы получаете объект типа None. В этом случае строка сообщения об ошибке будет иметь следующий вид: AttributeError: ‘NoneType’ object has no attribute ‘append’.

ImportError

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

Возникает, когда в операторе импорта возникают проблемы при попытке загрузить модуль. Также вызывается, когда в операторе from … import использовано имя модуля, которое невозможно найти. (Источник)

Вот пример возникновения ImportError и ModuleNotFoundError:

>>> import asdf
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'asdf'
>>> from collections import asdf
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: cannot import name 'asdf'

В приведенном выше примере вы можете увидеть, что попытка импортировать несуществующий модуль asdf приводит к ModuleNotFoundError. При попытке импортировать что-то, что не существует, asdf, из модуля, который существует приводит к ImportError. Строки сообщений об ошибках в нижней части трассировки показывают, какой объект неполучается импортировать. В нашем примере asdf .

IndexError

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

Возникает, когда текущий индекс последовательности находится вне используемого диапазона. (Источник)

Вот пример, который вызывает IndexError:

>>> a_list = ['a', 'b']
>>> a_list[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

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

KeyError

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

Возникает, когда ключ набора (словарь) не найден в наборе существующих ключей. (Источник)

Вот пример возникновения KeyError:

>>> a_dict['b']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'b'

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

Для более глубокого понимания KeyError, взгляните на Python KeyError Exceptions and How to Handle Them..

NameError

Ошибка NameError возникает, когда вы ссылаетесь на переменную, модуль, класс, функцию или другое имя, которое не было определено в вашем коде.

Возникает, когда локальное или глобальное имя не найдено. (Источник)

В приведенном ниже коде greet() принимает параметр person. Но в самой функции этот параметр был ошибочно указан как persn:

>>> def greet(person):
...     print(f'Hello, {persn}')
>>> greet('World')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in greet
NameError: name 'persn' is not defined

Строка сообщения об ошибке трассировки NameError дает вам имя, которое отсутствует. В приведенном выше примере это переменная или параметр с ошибкой.

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

>>> def greet(persn):
...     print(f'Hello, {person}')
>>> greet('World')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in greet
NameError: name 'person' is not defined

SyntaxError

Ошибка SyntaxError возникает, когда в вашем коде неверный синтаксис Python.

Возникает, когда синтаксический анализатор обнаруживает синтаксическую ошибку. (Источник)

Ниже проблема заключается в отсутствующем двоеточии, которое должно находиться в конце строки определения функции. В Python REPL эта синтаксическая ошибка возникает сразу после нажатия Enter:

>>> def greet(person)
  File "<stdin>", line 1
    def greet(person)
                    ^
SyntaxError: invalid syntax

Строка сообщения об ошибке SyntaxError только говорит вам, что была проблема с синтаксисом в коде. Изучение строк выше дает вам строку с проблемой и обычно ^ (каретку), указывающую на проблемное место. Здесь двоеточие отсутствует в операторе def функции.

Кроме того, при трассировке SyntaxError обычная трассировка последней строки отсутствует. Это связано с тем, что ошибка SyntaxError возникает, когда Python пытается проанализировать ваш код, а строки фактически не выполняются.

TypeError

Ошибка TypeError возникает, когда ваш код пытается что-то сделать с объектом, который не может этого сделать, например, пытается добавить строку к целому числу или вызывать len() для объекта, длина которого не определена.

Возникает, когда операция или функция применяется к объекту неподходящего типа. (Источник)

Ниже приведено несколько примеров возникновения TypeError:

>>> 1 + '1'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> '1' + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: must be str, not int
>>> len(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'int' has no len()

Все вышеприведенные примеры вызова TypeError приводят к строке сообщения об ошибке с разными сообщениями. Каждый из них довольно хорошо информирует о том, что не так.

Первые два примера пытаются добавить строки и целые числа вместе. Тем не менее, они немного отличаются:

• Первый пытается добавить str к int.
• Второй пытается добавить int к str.

Строки сообщений об ошибках отражают эти различия.

Последний пример пытается вызвать len() для int. Строка сообщения об ошибке говорит вам, что вы не можете сделать это для int.

ValueError

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

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

Вот два примера создания ValueError:

>>> a, b, c = [1, 2]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 3, got 2)
>>> a, b = [1, 2, 3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

Строка сообщения об ошибке ValueError в этих примерах говорит вам, в чем именно заключается проблема со значениями:

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

Как логировать трассировку?

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

Вот более реальный пример кода, который должен скрыть некоторые трассировки Python. В этом примере используется библиотека requests. Вы можете узнать больше о ней в Python’s Requests Library (Guide):

# urlcaller.py
import sys
import requests

response = requests.get(sys.argv[1])

print(response.status_code, response.content)

Этот код хорошо работает. Когда вы запустите этот скрипт, задав ему URL-адрес в качестве аргумента командной строки, он вызовет URL-адрес, а затем отобразит код состояния HTTP и содержимое ответа. Это даже работает, если ответ был статус ошибки HTTP:

$ python urlcaller.py https://httpbin.org/status/200
200 b''
$ python urlcaller.py https://httpbin.org/status/500
500 b''

Однако иногда URL-адрес, который выдается для извлечения сценарием, не существует или хост-сервер будет не работать. В этих случаях этот сценарий теперь вызовет необработанное исключение ConnectionError и отобразит трассировку:

$ python urlcaller.py http://thisurlprobablydoesntexist.com
...
During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "urlcaller.py", line 5, in <module>
    response = requests.get(sys.argv[1])
  File "/path/to/requests/api.py", line 75, in get
    return request('get', url, params=params, **kwargs)
  File "/path/to/requests/api.py", line 60, in request
    return session.request(method=method, url=url, **kwargs)
  File "/path/to/requests/sessions.py", line 533, in request
    resp = self.send(prep, **send_kwargs)
  File "/path/to/requests/sessions.py", line 646, in send
    r = adapter.send(request, **kwargs)
  File "/path/to/requests/adapters.py", line 516, in send
    raise ConnectionError(e, request=request)
requests.exceptions.ConnectionError: HTTPConnectionPool(host='thisurlprobablydoesntexist.com', port=80): Max retries exceeded with url: / (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7faf9d671860>: Failed to establish a new connection: [Errno -2] Name or service not known',))

Трассировка Python здесь может быть очень длинной со многими другими исключениями, которые в конечном итоге приводят к тому, что ConnectionError вызывается самими запросами. Если вы переместитесь вверх по трассировке окончательных исключений, вы увидите, что проблема началась в нашем коде со строки 5 urlcaller.py.

Теперь если вы оберните строку 5 в блок try и except, то перехват соответствующего исключения позволит вашему сценарию продолжить работу:

# urlcaller.py
...
try
    response = requests.get(sys.argv[1])
except requests.exceptions.ConnectionError:
    print(-1, 'Connection Error')
else:
    print(response.status_code, response.content)

Приведенный выше код использует оператор else с блоком try и except. Если вы не знакомы с этой функцией Python, ознакомьтесь с разделом else Python Exceptions: An Introduction.

Теперь, когда вы запустите сценарий с URL-адресом, который приведет к возникновению ошибки ConnectionError, вы получите вывод -1 для кода состояния и строку Connection Error:

$ python urlcaller.py http://thisurlprobablydoesntexist.com
-1 Connection Error

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

Примечание: Чтобы узнать больше о системе журналирования Python, ознакомьтесь со статьей Логирование в Python (Logging in Python).

Вы можете зарегистрировать трассировку в сценарии, импортировав пакет logging, получив регистратор и вызвав .exception() для этого регистратора в блоке except блока try/except. Ваш финальный скрипт должен выглядеть примерно так:

# urlcaller.py
import logging
import sys
import requests

logger = logging.getLogger(__name__)

try:
    response = requests.get(sys.argv[1])
except requests.exceptions.ConnectionError as e:
    logger.exception()
    print(-1, 'Connection Error')
else:
    print(response.status_code, response.content)

Теперь, когда вы запустите сценарий для проблемного URL, он выведет ожидаемое -1 и Connection Error, но также запишет трассировку в лог:

$ python urlcaller.py http://thisurlprobablydoesntexist.com
...
  File "/path/to/requests/adapters.py", line 516, in send
    raise ConnectionError(e, request=request)
requests.exceptions.ConnectionError: HTTPConnectionPool(host='thisurlprobablydoesntexist.com', port=80): Max retries exceeded with url: / (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7faf9d671860>: Failed to establish a new connection: [Errno -2] Name or service not known',))
-1 Connection Error

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

$ python urlcaller.py http://thisurlprobablydoesntexist.com 2> my-logs.log
-1 Connection Error

Заключение

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

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

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

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

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

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

Обратная трассировка в Python

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

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

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

Давайте рассмотрим простой пример.

Приведенный ниже фрагмент кода создает функцию, которая складывает два числа и умножает сумму на первое число. Затем он вызывает функцию с аргументами 5 и 4. Однако 4 передается как строка, так что на самом деле это не число.

def add_and_multiply(x, y):
    return (x + y) * x

add_and_multiply(5, "4")

Когда этот код выполняется, Python вызывает следующее исключение:

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

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

Обратная трассировка также показывает имена модулей и файлов, что очень полезно при работе со сценариями, которые импортируют модули из других файлов или скриптов. Способ отображения имен файлов и модулей немного меняется в зависимости от вашей рабочей среды (например, терминала или ОТВЕТА).

Например, когда я сохраняю приведенный выше фрагмент кода как «sample_script.py» и пытаюсь запустить его в терминале, я получаю следующую трассировку:

Traceback (most recent call last):
  File "/Users/sonery/sample_script.py", line 6, in <module>
    add_and_multiply(5, "6")
  File "/Users/sonery/sample_script.py", line 2, in add_and_multiply
    print((x + y) * x)
TypeError: unsupported operand type(s) for +: 'int' and 'str'

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

Распространенные типы обратной трассировки

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

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

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

Давайте рассмотрим некоторые из часто встречающихся типов ошибок в сообщениях обратной трассировки.

TypeError

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

AttributeError

В Python все является объектом с таким типом, как целое число, строка, список, кортеж, словарь и так далее. Типы определяются с помощью классов, которые также имеют атрибуты, используемые для взаимодействия с объектами класса.

Классы могут иметь атрибуты данных и процедурные атрибуты (т.е. методы):

• Атрибуты данных: что необходимо для создания экземпляра класса
• Методы (т.е. процедурные атрибуты): Как мы взаимодействуем с экземплярами класса.

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

Вот пример:

mylist = [1, 2, 3, 4, 5]

mylist.add(10)

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-25-4ad0ec665b52>", line 3, in <module>
    mylist.add(10)
AttributeError: 'list' object has no attribute 'add'

Поскольку класс list не имеет атрибута с именем “add”, мы получаем трассировку, показывающую ошибку атрибута.

ImportError и ModuleNotFoundError

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

Чтобы использовать такие библиотеки, а также встроенные библиотеки Python (например, ОС, запросы), нам необходимо их импортировать. Если при их импорте возникает проблема, возникает исключение importerror или module not found error.

Например, в следующем фрагменте кода мы пытаемся импортировать класс логистической регрессии из Scikit-learn.

from sklearn import LogisticRegression

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-22-b74afc1ba453>", line 1, in <module>
    from sklearn import LogisticRegression
ImportError: cannot import name 'LogisticRegression' from 'sklearn' (/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/sklearn/__init__.py)

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

from sklearn.linear_model import LogisticRegression

Исключение ошибки модуля не найдено возникает, если модуль недоступен в рабочей среде.

import openpyxl

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-23-f5ea1cbb6934>", line 1, in <module>
    import openpyxl
  File "/Applications/PyCharm CE.app/Contents/plugins/python-ce/helpers/pydev/_pydev_bundle/pydev_import_hook.py", line 21, in do_import
    module = self._system_import(name, *args, **kwargs)
ModuleNotFoundError: No module named 'openpyxl'

IndexError

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

names = ["John", "Jane", "Max", "Emily"]

# Get the third item
names[2]

# output
"Max"

Если индекс выходит за пределы допустимого диапазона, возникает исключение ошибки индекса.

names = ["John", "Jane", "Max", "Emily"]

# Get the sixth item
names[5]

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-30-3033b2837dcd>", line 3, in <module>
    names[5]
IndexError: list index out of range

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

Давайте рассмотрим другой пример, используя фрейм данных Pandas.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randint(10, size=(5, 2)), columns=["A", "B"])

df

# output
   A  B
0  1  6
1  6  3
2  8  8
3  3  5
4  5  6

Переменная df представляет собой DataFrame с 5 строками и 2 столбцами. Следующая строка кода пытается получить значение в третьем столбце первой строки.

df.iloc[0, 3]

# output

Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<file>", line 1, in <module>
    df.iloc[0, 3]
  File "<file>", line 960, in __getitem__
    return self.obj._get_value(*key, takeable=self._takeable)
  File "<file>", line 3612, in _get_value
    series = self._ixs(col, axis=1)
  File "<file>", line 3439, in _ixs
    label = self.columns[i]
  File "<file>", line 5039, in __getitem__
    return getitem(key)
IndexError: index 3 is out of bounds for axis 0 with size 2

Как мы видим в последней строке трассировки, это сообщение об ошибке говорит само за себя.

NameError

Исключение ошибки имени возникает, когда мы ссылаемся на переменную, которая не определена в нашем коде.

Вот пример:

members = ["John", "Jane", "Max", "Emily"]

member[0]

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-35-9fcefb83a26f>", line 3, in <module>
    name[5]
NameError: name 'member' is not defined

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

ValueError

Исключение ошибки значения возникает, когда мы пытаемся присвоить неправильное значение переменной. Вспомните наш DataFrame с 5 строками и 2 столбцами.

import pandas as pd
import numpy as np

df = pd.DataFrame(np.random.randint(10, size=(5, 2)), columns=["A", "B"])

df

# output
   A  B
0  1  6
1  6  3
2  8  8
3  3  5
4  5  6

Допустим, мы хотим добавить новый столбец в этот DataFrame.

df["C"] = [1, 2, 3, 4]

# output
Traceback (most recent call last):
  File "<file>", line 3378, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<file>", line 1, in <module>
    df["C"] = [1, 2, 3, 4]
  File "<file>", line 3655, in __setitem__
    self._set_item(key, value)
  File "<file>", line 3832, in _set_item
    value = self._sanitize_column(value)
  File "<file>", line 4535, in _sanitize_column
    com.require_length_match(value, self.index)
  File "<file>", line 557, in require_length_match
    raise ValueError(
ValueError: Length of values (4) does not match length of index (5)

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

Заключительные мысли

Сообщения об ошибках очень полезны при отладке кода или его правильном выполнении в первый раз. К счастью, трассировка Python имеет четкие и поясняющие сообщения об ошибках.

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

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

К концу этого урока вы сможете:

# example.py
def greet(someone):
    print('Hello, ' + someon)

greet('Chad')

$ python example.py
Traceback (most recent call last):
  File "/path/to/example.py", line 4, in 
    greet('Chad')
  File "/path/to/example.py", line 2, in greet
    print('Hello, ' + someon)
NameError: name 'someon' is not defined

>>> def greet(someone):
...   print('Hello, ' + someon)
...
>>> greet('Chad')
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 2, in greet
NameError: name 'someon' is not defined

# greetings.py
def who_to_greet(person):
    return person if person else input('Greet who? ')

def greet(someone, greeting='Hello'):
    print(greeting + ', ' + who_to_greet(someone))

def greet_many(people):
    for person in people:
        try:
            greet(person)
        except Exception:
            print('hi, ' + person)

$ python example.py
Traceback (most recent call last):
  File "/path/to/greetings.py", line 19, in 
    greet('Chad', greting='Yo')
TypeError: greet() got an unexpected keyword argument 'greting'

# example.py
from greetings import greet

greet(1)

$ python example.py
Traceback (most recent call last):
  File "/path/to/example.py", line 3, in 
    greet(1)
  File "/path/to/greetings.py", line 5, in greet
    print(greeting + ', ' + who_to_greet(someone))
TypeError: must be str, not int

# greetings.py
...
greet_many(['Chad', 'Dan', 1])

$ python greetings.py
Hello, Chad
Hello, Dan
Traceback (most recent call last):
  File "greetings.py", line 10, in greet_many
    greet(person)
  File "greetings.py", line 5, in greet
    print(greeting + ', ' + who_to_greet(someone))
TypeError: must be str, not int

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "greetings.py", line 14, in 
    greet_many(['Chad', 'Dan', 1])
  File "greetings.py", line 12, in greet_many
    print('hi, ' + person)
TypeError: must be str, not int

def greet_many(people):
    for person in people:
        try:
            greet(person)
        except Exception:
            print('hi, ' + person)

>>> an_int = 1
>>> an_int.an_attribute
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'int' object has no attribute 'an_attribute'

>>> a_list = (1, 2)
>>> a_list.append(3)
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'tuple' object has no attribute 'append'

>>> import asdf
Traceback (most recent call last):
  File "", line 1, in 
ModuleNotFoundError: No module named 'asdf'
>>> from collections import asdf
Traceback (most recent call last):
  File "", line 1, in 
ImportError: cannot import name 'asdf'

>>> a_list = ['a', 'b']
>>> a_list[3]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: list index out of range

>>> a_dict['b']
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'b'

>>> def greet(person):
...     print(f'Hello, {persn}')
>>> greet('World')
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 2, in greet
NameError: name 'persn' is not defined

>>> def greet(persn):
...     print(f'Hello, {person}')
>>> greet('World')
Traceback (most recent call last):
  File "", line 1, in 
  File "", line 2, in greet
NameError: name 'person' is not defined

>>> def greet(person)
  File "", line 1
    def greet(person)
                    ^
SyntaxError: invalid syntax

>>> 1 + '1'
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> '1' + 1
Traceback (most recent call last):
  File "", line 1, in 
TypeError: must be str, not int
>>> len(1)
Traceback (most recent call last):
  File "", line 1, in 
TypeError: object of type 'int' has no len()

>>> a, b, c = [1, 2]
Traceback (most recent call last):
  File "", line 1, in 
ValueError: not enough values to unpack (expected 3, got 2)
>>> a, b = [1, 2, 3]
Traceback (most recent call last):
  File "", line 1, in 
ValueError: too many values to unpack (expected 2)

# urlcaller.py
import sys
import requests

response = requests.get(sys.argv[1])

print(response.status_code, response.content)

$ python urlcaller.py https://httpbin.org/status/200
200 b''
$ python urlcaller.py https://httpbin.org/status/500
500 b''

$ python urlcaller.py http://thisurlprobablydoesntexist.com
...
During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "urlcaller.py", line 5, in 
    response = requests.get(sys.argv[1])
  File "/path/to/requests/api.py", line 75, in get
    return request('get', url, params=params, **kwargs)
  File "/path/to/requests/api.py", line 60, in request
    return session.request(method=method, url=url, **kwargs)
  File "/path/to/requests/sessions.py", line 533, in request
    resp = self.send(prep, **send_kwargs)
  File "/path/to/requests/sessions.py", line 646, in send
    r = adapter.send(request, **kwargs)
  File "/path/to/requests/adapters.py", line 516, in send
    raise ConnectionError(e, request=request)
requests.exceptions.ConnectionError: HTTPConnectionPool(host='thisurlprobablydoesntexist.com', port=80): Max retries exceeded with url: / (Caused by NewConnectionError(': Failed to establish a new connection: [Errno -2] Name or service not known',))

# urlcaller.py
...
try:
    response = requests.get(sys.argv[1])
except requests.exceptions.ConnectionError:
    print(-1, 'Connection Error')
else:
    print(response.status_code, response.content)

$ python urlcaller.py http://thisurlprobablydoesntexist.com
-1 Connection Error

# urlcaller.py
import logging
import sys
import requests

logger = logging.getLogger(__name__)

try:
    response = requests.get(sys.argv[1])
except requests.exceptions.ConnectionError as e:
    logger.exception()
    print(-1, 'Connection Error')
else:
    print(response.status_code, response.content)

$ python urlcaller.py http://thisurlprobablydoesntexist.com
...
  File "/path/to/requests/adapters.py", line 516, in send
    raise ConnectionError(e, request=request)
requests.exceptions.ConnectionError: HTTPConnectionPool(host='thisurlprobablydoesntexist.com', port=80): Max retries exceeded with url: / (Caused by NewConnectionError(': Failed to establish a new connection: [Errno -2] Name or service not known',))
-1 Connection Error

$ python urlcaller.py http://thisurlprobablydoesntexist.com 2> my-logs.log
-1 Connection Error

Новинка в версии 3.5.

StackSummary представляют стек вызовов, готовый к форматированию.

class traceback.StackSummary

StackSummary из генератора фреймов (например, возвращаемый walk_stack() или walk_tb() ).

Если задано ограничение , из frame_gen берется только это количество кадров . Если lookup_lines имеет значение False , возвращенные объекты FrameSummary еще не прочитают свои строки, что удешевляет стоимость создания StackSummary (что может быть ценным, если на самом деле он может не форматироваться). Если для capture_locals установлено значение True , локальные переменные в каждом FrameSummary захватываются как представления объектов.

classmethod from_list(a_list)

StackSummary из предоставленного списка объектов FrameSummary или списка кортежей в старом стиле. Каждый кортеж должен состоять из 4-х элементов с именем файла, номером строки, именем и строкой.

format()

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

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

Изменено в версии 3.6:Длинные последовательности повторяющихся кадров теперь сокращены.

format_frame_summary(frame_summary)

Возвращает строку для печати одного из кадров, участвующих в стеке. Этот метод вызывается для каждого объекта FrameSummary , который должен быть напечатан с помощью StackSummary.format() . Если он возвращает None , кадр исключается из вывода.

Новинка в версии 3.11.

import sys, traceback

def run_user_code(envdir):
    source = input(">>> ")
    try:
        exec(source, envdir)
    except Exception:
        print("Exception in user code:")
        print("-"*60)
        traceback.print_exc(file=sys.stdout)
        print("-"*60)

envdir = {}
while True:
    run_user_code(envdir)

import sys, traceback

def lumberjack():
    bright_side_of_life()

def bright_side_of_life():
    return tuple()[0]

try:
    lumberjack()
except IndexError:
    exc_type, exc_value, exc_traceback = sys.exc_info()
    print("*** print_tb:")
    traceback.print_tb(exc_traceback, limit=1, file=sys.stdout)
    print("*** print_exception:")
    traceback.print_exception(exc_value, limit=2, file=sys.stdout)
    print("*** print_exc:")
    traceback.print_exc(limit=2, file=sys.stdout)
    print("*** format_exc, first and last line:")
    formatted_lines = traceback.format_exc().splitlines()
    print(formatted_lines[0])
    print(formatted_lines[-1])
    print("*** format_exception:")
    print(repr(traceback.format_exception(exc_value)))
    print("*** extract_tb:")
    print(repr(traceback.extract_tb(exc_traceback)))
    print("*** format_tb:")
    print(repr(traceback.format_tb(exc_traceback)))
    print("*** tb_lineno:", exc_traceback.tb_lineno)

*** print_tb:
  File "<doctest...>", line 10, in <module>
    lumberjack()
*** print_exception:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_life()
IndexError: tuple index out of range
*** print_exc:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_life()
IndexError: tuple index out of range
*** format_exc, first and last line:
Traceback (most recent call last):
IndexError: tuple index out of range
*** format_exception:
['Traceback (most recent call last):n',
 '  File "<doctest default[0]>", line 10, in <module>n    lumberjack()n',
 '  File "<doctest default[0]>", line 4, in lumberjackn    bright_side_of_life()n',
 '  File "<doctest default[0]>", line 7, in bright_side_of_lifen    return tuple()[0]n           ~~~~~~~^^^n',
 'IndexError: tuple index out of rangen']
*** extract_tb:
[<FrameSummary file <doctest...>, line 10 in <module>>,
 <FrameSummary file <doctest...>, line 4 in lumberjack>,
 <FrameSummary file <doctest...>, line 7 in bright_side_of_life>]
*** format_tb:
['  File "<doctest default[0]>", line 10, in <module>n    lumberjack()n',
 '  File "<doctest default[0]>", line 4, in lumberjackn    bright_side_of_life()n',
 '  File "<doctest default[0]>", line 7, in bright_side_of_lifen    return tuple()[0]n           ~~~~~~~^^^n']
*** tb_lineno: 10

>>> import traceback
>>> def another_function():
...     lumberstack()
...
>>> def lumberstack():
...     traceback.print_stack()
...     print(repr(traceback.extract_stack()))
...     print(repr(traceback.format_stack()))
...
>>> another_function()
  File "<doctest>", line 10, in <module>
    another_function()
  File "<doctest>", line 3, in another_function
    lumberstack()
  File "<doctest>", line 6, in lumberstack
    traceback.print_stack()
[('<doctest>', 10, '<module>', 'another_function()'),
 ('<doctest>', 3, 'another_function', 'lumberstack()'),
 ('<doctest>', 7, 'lumberstack', 'print(repr(traceback.extract_stack()))')]
['  File "<doctest>", line 10, in <module>n    another_function()n',
 '  File "<doctest>", line 3, in another_functionn    lumberstack()n',
 '  File "<doctest>", line 8, in lumberstackn    print(repr(traceback.format_stack()))n']

>>> import traceback
>>> traceback.format_list([('spam.py', 3, '<module>', 'spam.eggs()'),
...                        ('eggs.py', 42, 'eggs', 'return "bacon"')])
['  File "spam.py", line 3, in <module>n    spam.eggs()n',
 '  File "eggs.py", line 42, in eggsn    return "bacon"n']
>>> an_error = IndexError('tuple index out of range')
>>> traceback.format_exception_only(type(an_error), an_error)
['IndexError: tuple index out of rangen']

Python

3.11

• trace-Отследить или проследить выполнение оператора Python

• traceback-Печать или получение трассировки стека

• tracemalloc — Trace memory allocations

• API

Трассировка (traceback) – это вывод Python. Он немного пугает начинающих разработчиков, но каждый профессионал сталкивается с проблемами в процессе исполнения кода. И трассировка помогает их эффективно разрешить. Traceback, в принципе, – хорошо, поскольку позволяет пользователю исправить причину, по которой возникла проблема при создании приложения. 

Понятие трассировки и зачем она нужна?

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

Под трассировкой подразумевается отчет о том, какие вызовы выполненных функций в данный момент времени. 

Вообще, встречаются разные вариации этого слова. Можно встретить названия «трассировка стека», обратная трассировка», и так далее. Но мы для простоты понимания будем использовать слово «трассировка» или английское слово «traceback», которое означает то же самое. 

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

def say_hello(man):

    print('Привет, ' + wrong_variable)

 

say_hello('Иван')

Здесь say_hello() вызывается с параметром man. Тем не менее, в say_hello() данное имя переменной не используется. Причиной тому служит то, что оно написано по-другому: wrong_variable в вызове print().

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

После запуска этого приложения будет получена следующая трассировка. 

Traceback (most recent call last):

  File "/home/test.py", line 4, in <module>

    say_hello('Иван')

  File "/home/test.py", line 2, in say_hello

    print('Привет, ' + wrong_variable)

NameError: name 'wrong_variable' is not defined

 

Process finished with exit code 1

Это выдача, в которой есть большое количество данных, необходимых для анализа причин той ошибки, которая возникла. В последней строчке traceback мы понимаем тип исключения. В том числе, предоставляются дополнительные релевантные сведения. 

Прошлые строчки из traceback говорят, какой конкретно код вызвал это исключение.

В traceback, бывшем ранее, исключение NameError. Она говорит о том, что есть отсылка к определенному имени, не определенного до того момента, как исполнялся этот код. В нашем случае ссылка осуществляется на wrong_variable.

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

Как понять причины ошибки?

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

Структура трассировки: особенности

Каждая трассировка имеет универсальные черты. Но все секции вывода являются важными. В этом изображении описаны несколько из них.

Рекомендация: знакомиться с трассировкой рекомендуется в последовательности снизу вверх.

1. Поле синего цвета. Последняя строчка из трассировки – уведомление об исключении, появившемся в процессе исполнения программы. Конкретно в этом поле указывается ее название.
2. Зеленое поле. В него включено описание ошибки. Это описание, как правило, включает полезные сведения для понимания, по какой причине эта ошибка возникла. 
3. Поле желтого цвета. Немного ранее в трассировке хранятся сведения о тех функциях, которые вызывались в программе. Они идут по направлению к верху – от самых поздних до тех, которые были раньше всего. Такие вызовы являют собой двухстрочные вводы для всех вызовов. Причем первая строчка всех вызовов включает такие данные, как имя того файла, в котором появилась ошибка, номер строки, название модуля. Каждая из этих деталей позволяет понять, в каком конкретно месте может быть найден код.
4. Красное подчеркивание. Вторая строка данных вызовов включает непосредственно тот код, при выполнении которого было вызвано исключение.

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

Python 3.7.4 (default, Jul 16 2019, 07:12:58) 

[GCC 9.1.0] on linux

Type "help", "copyright", "credits" or "license" for more information.

>>> 

>>> 

>>> def say_hello(man):

...     print('Привет, ' + wrong_variable)

... 

>>> say_hello('Иван')

 

 

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

  File "<stdin>", line 2, in say_hello

NameError: name 'wrong_variable' is not defined

Учтите то, что на месте имени файла обнаружите <stdin>. В этом нет ничего странного, так как вы выполнили код через стандартный ввод. Также в трассировке не показываются выполненные строки.

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

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

Примеры кода с выводом трассировки

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

Код, который мы покажем ниже, применяется в примерах для иллюстрации данных, которые предоставляются в трассировке.

Мы выполнили код, который ниже, в роли примера. Покажем, какие сведения нам помогла получить трассировка.

Давайте сохраним этот код в файле greetings.py. 

def who_to_greet(person):

    return person if person else input('Кого приветствовать? ')

 

def greet(someone, greeting='Здравствуйте'):

    print(greeting + ', ' + who_to_greet(someone))

 

def greet_many(people):

    for person in people:

        try:

            greet(person)

        except Exception:

            print('Привет, ' + person)

Функция who_to_greet() принимает значение person и либо возвращает это значение в случае, если оно содержит хоть какие-то значения, либо просит пользователя ввести значение с помощью input().

Затем, greet() применяет имя для приветствия из someone, необязательное значение из greeting и вызывает print(). Также со значением, которое берется из someone вызывается функция who_to_greet().

И, в результате, greet_many() осуществляет итерацию по списку людей и выполняет greet(). Если при вызове этой функции случается ошибка, то тогда на вывод идет резервное приветствие print(‘hi, ‘ + person).

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

Если выполните greet() в конце кода (который был сохранен в файле greetings.py) и дадите аргумент, которого в данной программе не может быть, то трассировка получится следующей. 

$ python greetings.py




Traceback (most recent call last):

  File "/home/greetings.py", line 19, in <module>

    greet('Chad', greting='Yo')

TypeError: greet() got an unexpected keyword argument 'greting'

Такой вывод переводится, что функция greet получила ключевой аргумент ‘greting’, который для  интерпретатора оказался неожиданным.

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

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

Видим, что анализировать ошибки в Python не так и трудно, не так ли?

Обзор основных исключений

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

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

AttributeError object has no attribute

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

Вот пример кода, вследствие выполнения какого программа сообщила о наличии проблемы. 

>>> an_int = 1

>>> an_int.an_attribute

 

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

AttributeError: 'int' object has no attribute 'an_attribute'

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

ImportError: No module named

Если вы задействуете оператор import, и в процессе этого возникают сложности, появляется ошибка ImportError. Сюда же может быть включенным подкласс ошибки ModuleNotFoundError. Она появляется в случае, если модуль, импортируемый в данной ситуации, не получается найти или если разработчик пытается импортировать то, что в этом модуле отсутствует. 

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

IndexError: list index out of range

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

Вот пример кода, приводящего к возникновению данного исключения. 

>>> a_list = ['a', 'b']

>>> a_list[3]

 

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

IndexError: list index out of range

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

Проще говоря, в списке a_list значение с ключом 3 отсутствует. Есть лишь значение с ключами 0 и 1. Им соответствуют буквы a и b.

KeyError

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

Проще говоря, эта ошибка является аналогом IndexError, только для словарей. 

Вот пример кода, который демонстрирует это исключение. 

>>> a_dict = ['a': 1, 'w': '2']

>>> a_dict['b']

 

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

KeyError: 'b'

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

SyntaxError

Еще один пример важного исключения, которое появляется, если в синтаксисе возникла определенная ошибка.  

>>> def greet(person)

  File "<stdin>", line 1

    def greet(person)

                    ^

SyntaxError: invalid syntax

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