Ошибка питон 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 (трассировка) — это отчет, который содержит вызовы выполненных функций в вашем коде в определенный момент.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

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

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

def say_hello(man):

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

say_hello(‘Иван’)

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

Обратите внимание: в данной статье подразумевается, что вы уже имеете представление об ошибках Python. Если это вам не знакомо, или вы хотите освежить память, можете ознакомиться с нашей статьей: Обработка ошибок в 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. Однако, скорее всего в реальном случае вы будете иметь дело с более сложным кодом.

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

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

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

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

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

Есть ряд отличий между выдачей трассировок, когда вы запускает код в командной строке, и между запуском кода в 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>. Это логично, так как вы выполнили код через стандартный ввод. Кроме этого, выполненные строки кода не отображаются в traceback.

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

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

Traceback в 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(). Если при вызове greet() возникает ошибка, то выводится резервное приветствие print('hi, ' + person).

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

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

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

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

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

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

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

from greetings import greet

greet(1)

Здесь вы настраиваете еще один файл Python, который импортирует ваш предыдущий модуль 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, но на этот раз уведомление об ошибки не очень помогает. Оно говорит о том, что где-то в коде ожидается работа со строкой, но было дано целое число.

Идя выше, вы увидите строку кода, которая выполняется. Затем файл и номер строки кода. На этот раз мы получаем имя функции, которая была выполнена — 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 in the output above”. Между всеми трассировками, вы ее увидите.

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

Обратите внимание: функция отображения предыдущих трассировок была добавлена в 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() обрабатывает эту ошибку и пытается вывести простое приветствие. Здесь код приводит к другой, аналогичной ошибке. Он все еще пытается добавить строку и целое число.

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

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

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

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

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

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

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

Пример ошибки 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 будет типом списка, который содержит метод .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:

>>> 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) из модуля, который существует (в нашем случае — collections), приводит к ImportError. Строки сообщения об ошибке трассировок указывают на то, какая вещь не может быть импортирована, в обоих случаях это asdf.

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

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

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

Вот пример, который приводит к 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 не дает вам полную информацию. Вы можете видеть, что у вас есть отсылка к последовательности, которая не доступна и то, какой тип последовательности рассматривается, в данном случае это список.

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

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

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

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

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

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

>>> a_dict = [‘a’: 1, ‘w’: ‘2’]

>>> a_dict[‘b’]

Traceback (most recent call last):

File «<stdin>», line 1, in <module>

KeyError: ‘b’

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

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

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

Документация Python дает понять, когда возникает эта ошибка 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

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

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

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

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

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

>>> def greet(person)

File «<stdin>», line 1

def greet(person)

SyntaxError: invalid syntax

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

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

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

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 в Python 3 [Решено]

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 в данных примерах говорит нам в точности, в чем заключается проблема со значениями:

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

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

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

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

Файл urlcaller.py:

import sys

import requests

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

print(response.status_code, response.content)

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

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

200 b»

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

500 b»

Однако, иногда данный URL не существует (ошибка 404 — страница не найдена), или сервер не работает. В таких случаях, этот скрипт приводит к ошибке 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. Если вы перейдете к трассировке последних ошибок, вы заметите, что все проблемы в коде начались на пятой строке файла urlcaller.py.

Если вы обернёте неправильную строку в блоке 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 с блоком except.

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

$ python urlcaller.py http://thisurlprobablydoesntexist.com

—1 Connection Error

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

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

Вы можете вести журнал трассировки в скрипте, импортировав пакет logging, получить logger, вызвать .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 и ConnectionError, но также будет вести журнал трассировки:

$ python urlcaller.py http://thisurlprobablydoesntexist.com

...

File «/path/to/requests/adapters.py», line 516, in send

raise ConnectionError(e, request=request)

—1 Connection Error

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

$ python urlcaller.py http://thisurlprobablydoesntexist.com 2> my—logs.log

—1 Connection Error

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

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

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

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

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

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

E-mail: vasile.buldumac@ati.utm.md

Образование
Universitatea Tehnică a Moldovei (utm.md)

2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Источник

Содержание

Заголовок
- Чтение Traceback 1
- Чтение Traceback 2
Некоторые ошибки с примерами кода
- Ошибки в синтаксисе
- Ошибки в логике
Контест №1

Заголовок

Создайте файл solution.py со следующим кодом:

for coord in vector:
    print(coord)

Наш код подразумевает печать содержимого переменной vector.

Запустим написанный скрипт, получим следующий вывод:

$ python3 solution.py
Traceback (most recent call last):
  File "solution.py", line 1, in <module>
    for coord in vector:
NameError: name 'vector' is not defined

Сообщение означает, что при исполнении кода возникла ошибка.
При этом Python сообщает нам кое-что ещё.
Разберём это сообщение детально.

Чтение Traceback 1

Исходное сообщение нужно мысленно разделить на две части.
Первая часть это traceback-сообщение:

Traceback (most recent call last):
  File "solution.py", line 1, in <module>
    for coord in vector:

Вторая часть — сообщение о возникшей ошибке:

NameError: name 'vector' is not defined

Разберём первую часть.
Traceback в грубом переводе означает «отследить назад».
Traceback показывает последовательность/стэк вызовов, которая, в конечном итоге, вызвала ошибку.

Первая строка:

Traceback (most recent call last):

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

Вторая и третья строки:

File "solution.py", line 1, in <module>
  for coord in vector:

показывают информацию о вызове (в нашем случае он один).
Во-первых, здесь есть информация о файле, в котором произошёл вызов («solution.py»), затем указан номер строки, где этот вызов происходит («line 1»), в конце стоит информация о том, откуда произошёл вызов («<module>»).
В нашем случае вызов происходит непосредственно из модуля, т.е. не из функции.
Наконец, вывод содержит не только номер строки, но и саму строку «for coord in vector:».

Заключительная строка сообщения:

NameError: name 'vector' is not defined

содержит вид (тип) ошибки («NameError»), и после двоеточия содержит подсказку.
В данном случае она означает, что имя «vector» не определено.

В самом деле, если взглянуть снова на код, то можно убедиться, что мы нигде не объявили переменную «vector».

Подведём итоги.
При попытке запуска мы получили следующий вывод

$ python3 solution.py
Traceback (most recent call last):
  File "solution.py", line 1, in <module>
    for coord in vector:
NameError: name 'vector' is not defined

Он говорит нам о возникновении ошибки.
Эта ошибка обнаружилась интерпретатором в первой строке файла «solution.py».
Сама ошибка является ошибкой имени и указывает на необъявленное имя — «vector».

Чтение Traceback 2

Оберните код из solution.py в функцию:

def print_vector(vector):
    for coord in vector:
        print(coord)

print_vector(5)

Запустим наш код

$ python3 solution.py
Traceback (most recent call last):
  File "solution.py", line 5, in <module>
    print_vector(5)
  File "solution.py", line 2, in print_vector
    for coord in vector:
TypeError: 'int' object is not iterable

На этот раз сообщение об ошибке сложнее, однако структура у него та же.

Часть со стеком вызовов увеличилась:

Traceback (most recent call last):
  File "solution.py", line 5, in <module>
    print_vector(5)
  File "solution.py", line 2, in print_vector
    for coord in vector:

Поскольку «most recent call last», читать будем её сверху вниз.

Вызовов на этот раз два.
Первый вызов:

File "solution.py", line 5, in <module>
  print_vector(5)

Произошел в пятой строке.
Судя по строчке кода, это вызов написанной нами функции print_vector(5) с аргументом 5.

Следом за ней второй вызов:

File "solution.py", line 2, in print_vector
  for coord in vector:

Этот вызов происходит внутри функции print_vector, содержащейся в файле «solution.py».
Вызов находится в строке 2.

Сама же ошибка имеет вид:

TypeError: 'int' object is not iterable

Как и в первом примере, сообщение об ошибке содержит её тип и подсказку.
В нашем случае произошла ошибка типа.
В подсказке же указано, что объект типа int не является итерируемым, т.е. таким объектом, который нельзя использовать в цикле for.

Итог:

$ python3 solution.py
Traceback (most recent call last):
  File "solution.py", line 5, in <module>
    print_vector(5)
  File "solution.py", line 2, in print_vector
    for coord in vector:
TypeError: 'int' object is not iterable

В нашем коде возникла ошибка.
Её вызвала последовательность вызовов.
Первый вызов произошел непосредственно из модуля — в строке 5 происходит вызов функции print_vector(5).
Внутри этой функции ошибка возникла в строчке 2, содержащей проход по циклу.
Сообщение об ошибке означает, что итерироваться по объекту типа int нельзя.
В нашем случае мы вызвали функцию print_vector от числа (от 5).

Некоторые ошибки с примерами кода

Ошибки в синтаксисе

Наиболее частая ошибка, которая возникает в программах на Python — SyntaxError: когда какое-то утверждение записано не по правилам языка, например:

$ python3
>>> print "hello"
  File "<stdin>", line 1
    print "hello"
                ^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("hello")?

Тот же тип ошибки возникнет, если забыть поставить двоеточие в цикле:

$ python3
>>> for i in range(5)
  File "<stdin>", line 1
    for i in range(5)
                ^
SyntaxError: invalid syntax

При неправильном использовании пробелов и табуляций в начале строки возникает IndentationError:

$ python3
>>> for i in range(5):
    print(i)
  File "<stdin>", line 2
    print(i)
        ^
IndentationError: expected an indented block

А теперь посмотрим, что будет, если в первой строке цикла воспользоваться пробелами, а во второй — табуляцией:

$ python3
>>> for i in range(5):
        print(i) # здесь пробелы
        print(i**2) # здесь табуляция
    File "<stdin>", line 3
      print(i**2)
                ^
TabError: inconsistent use of tabs and spaces in indentation

NameError возникает при обращении к несуществующей переменной:

$ python3
>>> words = "Hello"
>>> word
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'word' is not defined

Ошибки в логике

Напишем простую программу на деление с остатком и сохраним как sample.py:

n = input()
m = input()
print(n % m)

и запустим её:

$ python3 sample.py
5
3
Traceback (most recent call last):
  File "sample.py", line 3, in <module>
    print(n % m)
TypeError: not all arguments converted during string formatting

Возникла ошибка TypeError, которая сообщает о неподходящем типе данных. Исправим программу:

n = int(input())
m = int(input())
print(n % m)

запустим на неподходящих данных:

$ python3 sample.py
xyz
Traceback (most recent call last):
  File "sample.py", line 1, in <module>
    n = int(input())
ValueError: invalid literal for int() with base 10: 'xyz'

Возникнет ValueError.
Эту ошибку ещё можно воспринимать как использование значения вне области допустимых значений (ОДЗ).

Теперь запустим программу на числовых данных:

$ python3 sample.py
1
0
Traceback (most recent call last):
  File "sample.py", line 3, in <module>
    print(n % m)
ZeroDivisionError: integer division or modulo by zero

При работе с массивами нередко возникает ошибка IndexError. Она возникает при выходе за пределы массива:

$ python3
>>> L1 = [1, 2, 3]
>>> L1[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Что будет, если вызвать бесконечную рекурсию? Опишем её в программе endless.py

def noend():
    print("Hello!")
    noend()
noend()

Через некоторое время после запуска возникнет RecursionError:

Traceback (most recent call last):
  File "endless.py", line 4, in <module>
    noend()
  File "endless.py", line 3, in noend
    noend()
  File "endless.py", line 3, in noend
    noend()
  File "endless.py", line 3, in noend
    noend()
  [Previous line repeated 993 more times]
  File "endless.py", line 2, in noend
    print("Hello!")
RecursionError: maximum recursion depth exceeded while calling a Python object

Источник

Traceback is the message or information or a general report along with some data, provided by Python that helps us know about an error that has occurred in our program. It’s also called raising an exception in technical terms. For any development work, error handling is one of the crucial parts when a program is being written. So, the first step in handling errors is knowing the most frequent errors we will be facing in our code.

Tracebacks provide us with a good amount of information and some messages regarding the error that occurred while running the program. Thus, it’s very important to get a general understanding of the most common errors.

Also read: Tricks for Easier Debugging in Python

Tracebacks are often referred to with certain other names like stack trace, backtrace, or stack traceback. A stack is an abstract concept in all programming languages, which just refers to a place in the system’s memory or the processor’s core where the instructions are being executed one by one. And whenever there is an error while going through the code, tracebacks try to tell us the location as well as the kind of errors it has encountered while executing those instructions.

Some of the most common Tracebacks in Python

Here’s a list of the most common tracebacks that we encounter in Python. We will also try to understand the general meaning of these errors as we move further in this article.

SyntaxError
NameError
IndexError
TypeError
AttributeError
KeyError
ValueError
ModuleNotFound and ImportError

General overview of a Traceback in Python

Before going through the most common types of tracebacks, let’s try to get an overview of the structure of a general stack trace.

# defining a function
def multiply(num1, num2):
    result = num1 * num2
    print(results)

# calling the function
multiply(10, 2)

Output:

Traceback (most recent call last):
  File "d:Pythontraceback.py", line 6, in <module>
    multiply(10, 2)
  File "d:Pythontraceback.py", line 3, in multiply
    print(results)
NameError: name 'results' is not defined. Did you mean: 'result'?

Explanation:

Python is trying to help us out by giving us all the information about an error that has occurred while executing the program. The last line of the output says that it’s supposedly a NameError and even suggesting us a solution. Python is also trying to tell us the line number that might be the source of the error.

We can see that we have a variable name mismatch in our code. Instead of using “result”, as we earlier declared in our code, we have written “results”, which throws an error while executing the program.

So, this is the general structural hierarchy for a Traceback in Python which also implies that Python tracebacks should be read from bottom to top, which is not the case in most other programming languages.

1. SyntaxError

All programming languages have their specific syntax. If we miss out on that syntax, the program will throw an error. The code has to be parsed first only then it will give us the desired output. Thus, we have to make sure of the correct syntax for it to run correctly.

Let’s try to see the SyntaxError exception raised by Python.

# defining a function
def multiply(num1, num2):
    result = num1 * num2
    print "result"

# calling the function
multiply(10, 2)

Output:

File "d:Pythontraceback.py", line 4
    print "result"
    ^^^^^^^^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print(...)?

Explanation:

When we try to run the above code, we see a SyntaxError exception being raised by Python. To print output in Python3.x, we need to wrap it around with a parenthesis. We can see the location of our error too, with the “^” symbol displayed below our error.

2. NameError

While writing any program, we declare variables, functions, and classes and also import modules into it. While making use of these in our program, we need to make sure that the declared things should be referenced correctly. On the contrary, if we make some kind of mistake, Python will throw an error and raise an exception.

Let’s see an example of NameError in Python.

# defining a function
def multiply(num1, num2):
    result = num1 * num2
    print(result)

# calling the function
multipli(10, 2)

Output:

Traceback (most recent call last):
  File "d:Pythontraceback.py", line 8, in <module>
    multipli(10, 2)
NameError: name 'multipli' is not defined. Did you mean: 'multiply'?

Explanation:

Our traceback says that the name “multipli” is not defined and it’s a NameError. We have not defined the variable “multipli”, hence the error occurred.

3. IndexError

Working with indexes is a very common pattern in Python. We have to iterate over various data structures in Python to perform operations on them. Index signifies the sequence of a data structure such as a list or a tuple. Whenever we try to retrieve some kind of index data from a series or sequence which is not present in our data structure, Python throws an error saying that there is an IndexError in our code.

Let’s see an example of it.

# declaring a list
my_list = ["apple", "orange", "banana", "mango"]

# Getting the element at the index 5 from our list
print(my_list[5])

Output:

Traceback (most recent call last):
  File "d:Pythontraceback.py", line 5, in <module>
    print(my_list[5])
IndexError: list index out of range

Explanation:

Our traceback says that we have an IndexError at line 5. It’s evident from our stack trace that our list does not contain any element at index 5, and thus it is out of range.

4. TypeError

Python throws a TypeError when trying to perform an operation or use a function with the wrong type of objects being used together in that operation.

Let’s see an example.

# declaring variables
first_num = 10
second_num = "15"

# Printing the sum
my_sum = first_num + second_num
print(my_sum)

Output:

Traceback (most recent call last):
  File "d:Pythontraceback.py", line 6, in <module>
    my_sum = first_num + second_num
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Explanation:

In our code, we are trying to calculate the sum of two numbers. But Python is raising an exception saying that there is a TypeError for the operand “+” at line number 6. The stack trace is telling us that the addition of an integer and a string is invalid since their types do not match.

5. AttributeError

Whenever we try to access an attribute on an object which is not available on that particular object, Python throws an Attribute Error.

Let’s go through an example.

# declaring a tuple
my_tuple = (1, 2, 3, 4)

# Trying to append an element to our tuple
my_tuple.append(5)

# Print the result
print(my_tuple)

Output:

Traceback (most recent call last):
  File "d:Pythontraceback.py", line 5, in <module>    
    my_tuple.append(5)
AttributeError: 'tuple' object has no attribute 'append'

Explanation:

Python says that there is an AttributeError for the object “tuple” at line 5. Since tuples are immutable data structures and we are trying to use the method “append” on it. Thus, there is an exception raised by Python here. Tuple objects do not have an attribute “append” as we are trying to mutate the same which is not allowed in Python.

6. KeyError

Dictionary is another data structure in Python. We use it all the time in our programs. It is composed of Key: Value pairs and we need to access those keys and values whenever required. But what happens if we try to search for a key in our dictionary which is not present?

Let’s try using a key that is not present and see what Python has to say about that.

# dictionary
my_dict = {"name": "John", "age": 54, "job": "Programmer"}

# Trying to access info from our dictionary object
get_info = my_dict["email"]

# Print the result
print(get_info)

Output:

Traceback (most recent call last):
  File "d:Pythontraceback.py", line 5, in <module>
    get_info = my_dict["email"]
KeyError: 'email'

Explanation:

In the above example, we are trying to access the value for the key “email”. Well, Python searched for the key “email” in our dictionary object and raised an exception with a stack trace. The traceback says, there is a KeyError in our program at line 5. The provided key is nowhere to be found in the specified object, hence the error.

7. ValueError

The ValueError exception is raised by Python, whenever there is an incorrect value in a specified data type. The data type of the provided argument may be correct, but if it’s not an appropriate value, Python will throw an error for it.

Let’s see an example.

import math

# Variable declaration
my_num = -16

# Check the data type
print(f"The data type is: {type(my_num)}") # The data type is: <class 'int'>

# Trying to get the square root of our number
my_sqrt = math.sqrt(my_num)

# Print the result
print(my_sqrt)

Output:

The data type is: <class 'int'>
Traceback (most recent call last):
  File "d:Pythontraceback.py", line 10, in <module>
    my_sqrt = math.sqrt(my_num)
ValueError: math domain error

Explanation:

In the example above, we are trying to get the square root of a number using the in-built math module in Python. We are using the correct data type “int” as an argument to our function, but Python is throwing a traceback with ValueError as an exception.

This is because we can’t get a square root for a negative number, hence, it’s an incorrect value for our argument and Python tells us about the error saying that it’s a ValueError at line 10.

8. ImportError and ModuleNotFoundError

ImportError exception is raised by Python when there is an error in importing a specific module that does not exist. ModuleNotFound comes up as an exception when there is an issue with the specified path for the module which is either invalid or incorrect.

Let’s try to see these errors in action.

ImportError Example:

# Import statement
from math import addition

Output:

Traceback (most recent call last):
  File "d:Pythontraceback.py", line 2, in <module>
    from math import addition
ImportError: cannot import name 'addition' from 'math' (unknown location)

ModuleNotFoundError Example:

Output:

Traceback (most recent call last):
  File "d:Pythontraceback.py", line 1, in <module>
    import addition
ModuleNotFoundError: No module named 'addition'

Explanation:

ModuleNotFoundError is a subclass of ImportError since both of them output similar kinds of errors and can be avoided using try and except blocks in Python.

Summary

In this article, we went through the most common types of errors or tracebacks that we encounter while writing Python code. Making mistakes or introducing a bug in any program that we write is very common for all levels of developers. Python being a very popular, user-friendly, and easy-to-use language has some great built-in tools to help us as much as it can while we develop something. Traceback is a great example of one of those tools and a fundamental concept to understand while learning Python.

Reference

traceback Documentation

Источник

Перевод статьи 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 лучше читать трассировку снизу вверх:

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

Есть несколько различий между выводом трассировки, когда вы выполняете свой код в командной строке и выполняете код в 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 в этих примерах говорит вам, в чем именно заключается проблема со значениями:

В первом примере вы пытаетесь распаковать слишком много значений. Строка сообщения об ошибке даже говорит о том, что вы ожидали распаковать 3 значения, но получили 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.

Была ли вам полезна эта статья?

Источник

The term traceback references to an error message produced by Python code that throws an exception. It gives us traceback details on problems brought on by a specific piece of code.

Stack traces are exceptions that are also thrown by other programming languages like Java, etc. We may troubleshoot these exceptions by looking at the file name, line number, and executed code block details (function, params, or another statement).

Developers has to be aware of issues in order to use traceback, which contains details such as file name, function call, line number, and exception name. Beginners may find traceback difficult to understand at first, but it is a useful learning way of understanding the issue with the reported mistake and fixing it appropriately.

In python, it’s good to go through errors reported from bottom to top.

Let’s understand Traceback (most recent call last): with the following example:

def introduce():
	return "Hello, I'm Test python script"

print(introduces())

Result:

  File "test.py", line 4, in <module>
    print(introduces())
NameError: name 'introduces' is not defined

Explanation: Here introduces() function is not defined in the program. This kind of error generally causes spelling/typing mistakes.

Now let’s understand the traceback error report in detail:

Throw Traceback error message as below:

Line 1: File «test.py», line 5, in

Exception caused at line number 5 of script test.py

Line 2: print(introduces())

Pointing code from where issue generated

Line 3: NameError: name 'introduces' is not defined

Contains traceback Exception name as NameError With error message as name ‘introduces’ is not defined which is self-explanatory.

Note. NameError is reported if python tries to evaluate a variable, function, disc, etc which is not defined but used in the code block. Like in the above program it tries to evaluate introduces function but this function does not exist.

Let’s explore some common exceptions we met during program execution such as:

IndexError: list index out of range
KeyError in the dictionary
Modulenotfounderror (ImportError: No module named requests )
NameError (undefined name error)
TypeError
How to fix Traceback File <string> error?
To brush up on your knowledge on this subject, take the MCQ at the End of this Article.
Feedback: Your input is valuable to us. Please provide feedback on this article.

When we attempt to retrieve items from the list using an index that does not exist, an exception for index out of range is raised.

List index out of range is demonstrated by the code below.

employee = ["John", "Peter", "Alex", "Camren"]
print(employee[4])

Result:

Traceback (most recent call last):
  File "test.py", line 2, in <module>
    print(employee[4])
IndexError: list index out of range

Explanation: IndexError is an exception with the message index out of range . The software attempts to retrieve items from the employee list at index 4, yet the employee list has a length of 4 and an index range of 0 to 3. When trying to run code employee[4], it complains that index 4 does not contain any items.

Traceback (most recent call last): return error report containing line number and error name and relevant error message to identify the problem and apply fix accordingly.

Solution:

To avoid this index out-of-range issue we can check the condition before attempting index value

def getEmployee(index):
	employee = ["John", "Peter", "Alex", "Camren"]
	if(len(employee) <= index):
	 return "Index out of range"
	else:
	  return employee[index]

print(getEmployee(4))

Explanation:

Here we have a function getEmployee that receives index as argument and returns employee name based on a passing index. Condition len(employee) <= index check whether received index greater than or equal to the length of employee list. If the index is larger than the list length then it returns the message Index out of range else returns the employee name.

KeyError is raised when we try to fetch an item usually from a dictionary that doesn’t exist.

Let’s understand with the following example code

def getEmployee(index):
	employee = {"J" : "John", "p" : "Peter", "A" : "Alex", "C" : "Camren"}
	return employee[index]

print(getEmployee("J"))

Result: John

Exaptation: All good. We have values associated with passing key J and return value as John.

What if we call the same function with another key that doesn’t exist. Evaluate for the key K as below

def getEmployee(index):
	employee = {"J" : "John", "p" : "Peter", "A" : "Alex", "C" : "Camren"}
	return employee[index]

print(getEmployee("K"))

Result:

Traceback (most recent call last):
  File "test.py", line 5, in <module>
    print(getEmployee("K"))
  File "test.py", line 3, in getEmployee
    return employee[index]
KeyError: 'K'

Explanation: It raised Traceback (most recent call last): error report as KeyError and notifying us about key ‘K’ with some details about function call and line number.

Solution: We can avoid KeyError issues by applying the required condition before fetching dictionary elements as below

def getEmployee(key):
	employee = {"J" : "John", "P" : "Peter", "A" : "Alex", "C" : "Camren"}
	if key not in an employee:
	  return "Key Doesn't exist!"
	else:
	  return employee[key]

print(getEmployee("K"))

Result: Key Doesn’t exist!

Explanation: Condition key not in employee checks whether a received key exists in a dictionary or not.

If it exists, it returns relevant value to the calling function otherwise it returns a user-defined message Key Doesn’t exist!

ImportError is raised while the python interpreter can’t find the imported package in the python script. There can be multiple reasons behind Modulenotfounderror such as

Spelling/Typing mistake in the imported module name
The included package is not installed
The interpreter can’t find the path of the included module.

The following example program demonstrates Modulenotfounderror

import requests
x = requests.get('https://www.quizcure.com')
print(x.status_code)

Result:

Traceback (most recent call last):
  File "test.py", line 1, in <module>
    import requests
ImportError: No module named requests

Explanation:

Since requests are not installed on my server therefore while using the get function from requests package it complains and throws an exception as ImportError with the error message No module named requests.

Solution:

Install requests package.

pip install requests

NameError (undefined name error) is generally caused due to following common reasons

Misspelled builtIn function name or user-defined function
Human errors typing while defining variable name, module name, class name within the local or global scope.
Accessing variable is out of its scope

Let’s understand with below program

Misspelled builtin function name or user-defined function

employee = ["John", "Peter", "Alex", "Camren"]

def getEmployee(index):
	if(len(employee) <= index):
	 return "Index out of range"
	else:
	  return employee[index]

print(getEmploye(2))

Result: NameError: name 'getEmploye' is not defined

Explanation: As we can see, the calling function in print is getEmploye instead of getEmployee. Therefore it raised a NameError here.

Undefined param name:

Below program demonstrate NameError for undefined variable

Result: NameError: name 'va' is not defined

Explanation; Here we are trying to access variable va that is not defined in the program

Accessing variable is out of its scope:

Let’s understand with a below simple example

def inner():
  x = "inner Function"

print(x)

Result: NameError: name 'x' is not defined

What above code mean:

This inner variable x defined inside the function is only accessible within function scope because it is a local variable for function inner therefore it raises NameError while accessing outside of function scope.

TypeError occurs when trying to execute an inappropriate object type operation. Following are common causes behind TypeError:

Performing non-identical object type operations.
Using string indices to access list elements instead of integers or slices.
Treating non-callable object as callable.

Performing non-identical object type operations.

def sum(num):
    print (num + 5)

sum("test")

Result: TypeError: can only concatenate str (not "int") to str

Explanation:

Created function sum to add received number to integer 5. Therefore function expects a num argument as an integer value.
Passing string value test while calling function sum here which causes TypeError with the self-explanatory message as can only concatenate str.

To fix this issue We need to ensure the same object type operation while adding numbers or concatenating strings.

Therefore following two programs will work fine:

def sum(num):
    print (num + "5")

sum("test")

Result: test5

def sum(num):
    print (num + 5)

sum(10)

Result: 15

Using string indices to access list elements instead of integers or slices

employee = ["John", "Peter", "Alex", "Camren"]

print(employee["1"])

Result: TypeError: list indices must be integers or slices, not str

Explanation:

Define a list of names.
Trying to access a list with string indices «1». We can see the result as it complains and raises TypeError with message list indices must be integers or slices, not str

To fix this issue we need to access a list with integer values.

print(employee[1])

Will print: Peter

Treating the non-callable object as callable

Let’s understand with below example code

txt = "hello"

def demo():
    global txt
    txt = "there"


demo()
print(txt())

Result: TypeError: 'str' object is not callable

Explanation:

Let’s suppose we have a function demo that is modifying global variable txt value within a function block.
Calling demo function to set global param with new value there
Now here we trying to print txt and treat it as callable which complains and raise TypeError with error message as 'str' object is not callable

To fix, just print txt like

print(txt)

Result: there

The most frequent problem caused by utilizing inaccurate Python versions to parse strings is this one. In order to fix the issue, please verify that the Python function being used to read the expression is compatible with the current Python version.

Using the input function to read a string often leads to problems

Python version < 3.x

Use raw_input() rather than input() function to read strings since input function will evaluate any expression supplied to it and will consequently throw an error while raw input won’t.

With Python 3.x

When using Python 3.x, you can use the input function, which is equivalent to raw input in Python 2.x.

Yes, it was beneficial.

Yes, it was helpful, however more information is required.

It wasn’t helpful, so no.

Feedback (optional) Please provide additional details about the selection you chose above so that we can analyze the insightful comments and ideas and take the necessary steps for this topic. Thank you

Send Feedback

What will be the result for the following code?

Options are:

NameError: name ‘me’ is not defined

What is the output for the following code?

def getEmployee(index):
	employee = {"J" : "John" "p" : "Peter", "A" : "Alex", "C" : "Camren"}
	return employee[index]

print(getEmployee("J"))

Options are:

Will execute successfully without any error

Понимание 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 рекомендуется читать сообщение трассировки снизу вверх. Теперь давайте подробно разберемся с приведенной выше трассировкой:

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

Есть некоторые различия между выводом трассировки, когда код выполняется в командной строке, и 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).

Изучаю Python вместе с вами, читаю, собираю и записываю информацию опытных программистов.

Источник

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Заголовок

Чтение Traceback 1

Чтение Traceback 2

Некоторые ошибки с примерами кода

Ошибки в синтаксисе

Ошибки в логике

Some of the most common Tracebacks in Python

General overview of a Traceback in Python

1. SyntaxError

2. NameError

3. IndexError

4. TypeError

5. AttributeError

6. KeyError

7. ValueError

8. ImportError and ModuleNotFoundError

Summary

Reference

Как читать Traceback?

Обзор Traceback

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

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

AttributeError

ImportError

IndexError

KeyError

NameError

SyntaxError

TypeError

ValueError

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

Заключение

Misspelled builtin function name or user-defined function

Undefined param name:

Accessing variable is out of its scope:

Performing non-identical object type operations.

Using string indices to access list elements instead of integers or slices

Treating the non-callable object as callable

You May Like to Read

How to read traceback

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

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

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

AttributeError

ImportError

IndexError

KeyError

NameError

SyntaxError

TypeError

ValueError

`AttributeError`

`ImportError`

`IndexError`

`KeyError`

`NameError`

`SyntaxError`

`TypeError`

`ValueError`