Traceback most recent call last что значит ошибка

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

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Getting the Most Out of a Python Traceback

Python prints a traceback when an exception is raised in your code. The traceback output can be a bit overwhelming if you’re seeing it for the first time or you don’t know what it’s telling you. But the Python traceback has a wealth of information that can help you diagnose and fix the reason for the exception being raised in your code. Understanding what information a Python traceback provides is vital to becoming a better Python programmer.

By the end of this tutorial, you’ll be able to:

• Make sense of the next traceback you see
• Recognize some of the more common tracebacks
• Log a traceback successfully while still handling the exception

# 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 <module>
    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 "<stdin>", line 1, in <module>
  File "<stdin>", 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 <module>
    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 <module>
    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 <module>
    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 "<stdin>", line 1, in <module>
AttributeError: 'int' object has no attribute 'an_attribute'

>>> 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'

>>> 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'

>>> 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_dict['b']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'b'

>>> 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

>>> 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

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

>>> 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()

>>> 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)

# 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 <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',))

# 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('<urllib3.connection.HTTPConnection object at 0x7faf9d671860>: 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

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Getting the Most Out of a Python Traceback

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

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

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

Итак, приступим.

Понимание Traceback на языке программирования Python

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

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

Пример:

 
# File name: pytrace.py 
# defining a custom function 
def welcome( name ): 
    # printing some message 
    print( "Hello, " + nam ) # using 'nam' instead of 'name' 
    print( "Welcome to the Python program!") 
# calling the function 
welcome( "James" ) 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 10, in  
    welcome( "James" ) 
  File "D:Pythonpytrace.py", line 6, in welcome 
    print( "Hello, " + nam ) # using 'nam' instead of 'name' 
NameError: name 'nam' is not defined 

Объяснение:

В приведенном выше фрагменте кода мы определили настраиваемую функцию с именем welcome, которая принимает параметр как «name». Однако при печати некоторых сообщений внутри функции мы неправильно написали параметр «name», заменив его на «nam». В результате Python распечатал сообщение трассировки, когда исключение возникло при вызове функции.

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

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

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

Чтение трассировки в Python

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

Трассировка Python делится на несколько разделов. Каждый раздел имеет свою важность. Давайте рассмотрим следующую трассировку, показанную ниже:

 
Traceback (most recent call last):  
  File "D:Pythonpytrace.py", line 10, in <module>   
    welcome( "James" )  
  File "D:Pythonpytrace.py", line 6, in welcome  
    print( "Hello, " + nam ) # using 'nam' instead of 'name'  
NameError: name 'nam' is not defined   

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

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

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

REPL:

 
>>> def welcome( name ): 
...     print( "Hello, " + nam )                                 
...     print( "Welcome to the Python program!")  
...  
>>> welcome( "James" ) 
Traceback(most recent call last): 
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in welcome 
NameError: name 'nam' is not defined 

Как мы можем наблюдать в приведенном выше фрагменте кода REPL, сообщение трассировки возвращает “” вместо имени (имен) файла, потому что мы ввели код через стандартный ввод. Более того, выполняемые строки кода не отображаются в сообщении трассировки.

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

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

Понимание некоторых распространенных трассировок в Python

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

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

AttributeError

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

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

Давайте рассмотрим следующий пример, в котором возникло исключение AttributeError.

Пример:

 
# defining a variable 
my_int = 10 
print(my_int.an_attribute) 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 2, in <module>
    print(my_int.an_attribute) 
AttributeError: 'int' object has no attribute 'an_attribute' 

Объяснение:

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

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

Давайте рассмотрим еще один пример для лучшего понимания:

 
# defining a list 
my_list =( 10, 20 ) 
# using the 'append()' method in the list 
my_list.append( 30 ) 
# printing the final list 
print( my_list ) 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 5, in  
    my_list.append( 30 ) 
AttributeError: 'tuple' object has no attribute 'append' 

Объяснение:

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

Как правило, это происходит, когда мы ищем объект, который должен быть возвращен из вызова метода или функции, как определенный тип, но в конечном итоге мы остаемся с объектом типа None. В приведенном выше сценарии в строке сообщения об ошибке будет отображаться AttributeError: объект «NoneType» не имеет атрибута «append».

ImportError

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

Это исключение возникает всякий раз, когда оператору import трудно загрузить библиотеку или модуль. Более того, он вызывается всякий раз, когда “from list” в from … import содержит имя, которое не может быть обнаружено.

Давайте рассмотрим пример, демонстрирующий, как возникают ImportError и ModuleNotFoundError.

Пример:

 
# importing a library or module 
import xyz 
from collections import xyz 

Выход:

# Output for the first line 
Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 2, in  
    import xyz 
ModuleNotFoundError: No module named 'xyz' 
# Output for the second line 
Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 3, in  
    from collections import xyz 
ImportError: cannot import name 'xyz' from 'collections'(D:Python39libcollections__init__.py) 

Объяснение:

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

IndexError

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

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

Давайте рассмотрим следующий пример, демонстрирующий, как возникает исключение IndexError.

Пример:

 
# defining a list 
my_list = [ "Apple", "Peaches", "Mango", "Banana" ] 
# printing the element of the list 
print( my_list[ 4 ] ) 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 5, in  
    print( my_list[ 4 ] ) 
IndexError: list index out of range 

Объяснение:

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

KeyError

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

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

 
# defining a dictionary 
mydict = {'Mike' : 40, 'James' : 25, 'Drake' : 32, 'Jenny' : 28} 
# accessing a key out of the dictionary 
print( mydict['Sam'] ) 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 5, in  
    print( mydict['Sam'] ) 
KeyError: 'Sam' 

Объяснение:

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

NameError

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

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

 
# defining a function 
def myself( name ): 
    print("My name is", nam) 
# Calling the function 
myself( "Robin" ) 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 6, in  
    myself( "Robin" ) 
  File "D:Pythonpytrace.py", line 3, in myself 
    print("My name is", nam) 
NameError: name 'nam' is not defined 

Объяснение:

В приведенном выше примере мы определили функцию myself(), которая принимает аргумент name. Однако мы неправильно написали имя с nam в следующей строке при печати некоторых операторов. Затем мы вызвали функцию. В результате программа вызвала исключение NameError, поскольку имя «nam» не определено в программе.

SyntaxError

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

Давайте рассмотрим пример, иллюстрирующий, как возникает исключение SyntaxError.

 
# defining a function 
def myself( name ) 
    print("My name is", nam) 
# Calling the function 
myself( "Robin" ) 

Выход:

File "D:Pythonpytrace.py", line 2 
    def myself( name ) 
                      ^ 
SyntaxError: invalid syntax 

Объяснение:

В приведенном выше синтаксисе мы определили функцию myself(), но забыли поставить двоеточие «:» после определения функции. В результате, когда мы выполнили функцию, программа вызвала исключение SyntaxError, сообщив о проблеме с синтаксисом программы. Знак ^(каретка) под строкой кода указывает на местонахождение проблемы.

Более того, мы можем заметить, что в сообщении трассировки SyntaxError не отображается обычная первая строка с надписью «Traceback (most recent call last):». Это связано с тем, что исключение SyntaxError возникает, когда Python пытается проанализировать строку кода, а строки кода не обрабатываются буквально.

TypeError

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

Давайте рассмотрим следующий пример, демонстрирующий, как возникает исключение TypeError.

 
# defining some variables 
myint = 10 
mystr = '10' 
# performing addition on objects of different types 
myadd = myint + mystr 
# printing the result 
print("Result:", myadd) 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 4, in  
    myadd = myint + mystr 
TypeError: unsupported operand type(s) for +: 'int' and 'str' 

Объяснение:

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

Точно так же это исключение возникает, когда мы использовали функцию len() для типа данных int.

Давайте рассмотрим следующий пример, иллюстрирующий то же самое.

Пример:

 
# defining the variable 
myint = 10 
# finding length of the object of type 'int'  
print("Length:", len(myint)) 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 5, in  
    print("Length:", len(myint)) 
TypeError: object of type 'int' has no len() 

Объяснение:

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

ValueError

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

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

Рассмотрим пример, основанный на исключении ValueError.

 
# defining the variables 
var1, var2, var3 = [10, 20, 30, 40] 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 2, in  
    var1, var2, var3 = [10, 20, 30, 40] 
ValueError: too many values to unpack(expected 3) 

Объяснение:

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

Рассмотрим еще один пример, основанный на исключении ValueError.

Пример:

 
# defining the variable 
var1, var2, var3, var4 = [10, 20, 30] 

Выход:

Traceback(most recent call last): 
  File "D:Pythonpytrace.py", line 2, in  
    var1, var2, var3, var4 = [10, 20, 30] 
ValueError: not enough values to unpack(expected 4, got 3) 

Объяснение:

В приведенном выше синтаксисе мы попытались распаковать слишком много значений. В результате программа возвращает исключение ValueError, сообщая, что недостаточно значений для распаковки (ожидалось 4, получено 3).

In Python, A traceback is a report containing the function calls made in your code at a specific point i.e when you get an error it is recommended that you should trace it backward(traceback). Whenever the code gets an exception, the traceback will give the information about what went wrong in the code.The Python traceback contains great information that can help you find what is going wrong in the code. These tracebacks can look a little wearisome, but once you break it down to see what it’s trying to show you, they can be very helpful.

Consider following example…

In this example, we are trying to access the 10th element of the list. With only 3 elements present in the list it will give Runtime error. When this program is executed you will get the following traceback.

Traceback (most recent call last):
  File "", line 2, in 
print(mylist[10])
IndexError: list index out of range

This traceback error has all the information about why this runtime error occurred. Last line of the traceback tells you about what type of error occurred along with relevant information. Previous lines of traceback points to the code in which error occurred. In the above example, the last line indicates the index occurred and the previous two lines show the exact location where the exception has occurred. let us now see, How to read traceback..

How to read traceback

Python traceback contains lots of helpful information about what exception is raised. Going through a few tracebacks line by line will give you a better understanding of the information they contain and help you get the most out of them, in this section we will see how to read a particular exception.

In python it is best to read traceback from bottom to top.

• GREEN BOX shows the what type of error occurred .
• BLUE BOX shows the relevant information about error
• ORANGE BOX shows traceback statement for recent calls, below The firstRuntime Error:
  Traceback (most recent call last):
  File “”, line 1, in
  ModuleNotFoundError: No module named ‘asdf’ line of each call contains information like the file name, line number, and module name
• RED underlined part shows exact line where exception occurred.

Some of the common traceback errors are:

• NameError
• IndexError
• KeyError
• TypeError
• valueError
• ImportError /ModuleNotFound

Let’s go through each error one by one:

1. NameError: NameError occurs when you try to reference some variable which hasn’t been defined in the code.

   Example:

   Output:

   Traceback (most recent call last):
     File "gfg.py", line 5, in 
       print(numb)  
   NameError: name 'numb' is not defined
   

2. IndexError: An IndexError is raised when a sequence is referenced which is out of range.

   Example:

   mylist = [1, 2, 3]

   print(mylist[10])

   Output:

   Traceback (most recent call last):
     File "gfg.py", line 5, in 
       print(mylist[10])
   IndexError: list index out of range
   

3. KeyError: Similar to the IndexError, the KeyError is raised when you attempt to access a key that isn’t in the mapping, usually in the case of Python dict. Think of this as the IndexError but for dictionaries.

   Example:

   DICT ={ "a" :25, "b" :65 }

   print(DICT["A"])

   Output:

   Traceback (most recent call last):
     File "gfg.py", line 5, in 
       print(DICT["A"])
   KeyError: 'A'
   

4. TypeError: TypeError is raised when an operation or function is applied to an object of inappropriate type. This exception returns a string giving details about the type mismatch.

   Example:

   Output:

   Traceback (most recent call last):
     File "gfg.py", line 1, in 
       c = 'b'+3
   TypeError: must be str, not int
   

5. ValueError: A ValueError is raised when a built-in operation or function receives an argument that has the right type but an invalid value.

   Example:

   Traceback (most recent call last):
     File "gfg.py", line 1, in 
       print(int('xyz'))
   ValueError: invalid literal for int() with base 10: 'xyz'
   

6. ImportError: The ImportError is raised when something goes wrong with an import statement. You’ll get this exception, or its subclass ModuleNotFoundError, if the module you are trying to import can’t be found or if you try to import something from a module that doesn’t exist in the module.

   Example:

   import module_does_not_exist

   Traceback (most recent call last):
     File "gfg.py", line 1, in 
       import module_does_not_exist
   ModuleNotFoundError: No module named 'module_does_not_exist'