Отладка в IDLE — найдите и исправьте ошибки Python‑кода

Исключения

Даже если синтаксис в инструкции или само выражение верны, они все равно могут вызывать ошибки при исполнении. Исключения Python — это ошибки, обнаруживаемые при исполнении, но не являющиеся критическими. Скоро вы узнаете, как справляться с ними в программах Python. Объект исключения создается при вызове исключения Python. Если скрипт не обрабатывает исключение явно, программа будет остановлена принудительно.

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

a
b
a b

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

Оставшаяся часть строки с ошибкой предлагает подробности о причине ошибки на основе ее типа.

Теперь рассмотрим встроенные исключения Python.

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

()
:
val ((«input number: «))
tmp val
(tmp)
e:
( (e))
()

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

start input number: 0 Error! stop

()
val ((“ number: “))
tmp val
(tmp)
()

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

Traceback (most recent call last):

tmp = 10 / val

ZeroDivisionError: division by zero

Обратите внимание, надпись stop уже не печатается в конце вывода программы.

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

  • Вначале выполняется код, находящийся между операторами try и except.
  • Если в ходе его выполнения исключения не произошло, то код в блоке except пропускается, а код в блоке try выполняется весь до конца.
  • Если исключение происходит, то выполнение в рамках блока try прерывается и выполняется код в блоке except. При этом для оператора except можно указать, какие исключения можно обрабатывать в нем. При возникновении исключения, ищется именно тот блок except, который может обработать данное исключение.
  • Если среди except блоков нет подходящего для обработки исключения, то оно передается наружу из блока try. В случае, если обработчик исключения так и не будет найден, то исключение будет необработанным (unhandled exception) и программа аварийно остановится.

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

Если бы мы в нашей программе хотели обрабатывать только ValueError и ZeroDivisionError, то программа выглядела бы так.

()
:
val ((«input number: «))
tmp val
(tmp)
(, ):
()
()

Или так, если хотим обрабатывать ValueError, ZeroDivisionError по отдельность, и, при этом, сохранить работоспособность при возникновении исключений отличных от вышеперечисленных.

()
:
val ((«input number: «))
tmp val
(tmp)
:
()
:
()
:
()
()

Существует возможность передать подробную информацию о произошедшем исключении в код внутри блока except.

rint()
:
val ((«input number: «))
tmp val
(tmp)
ve:
(.format(ve))
zde:
(.format(zde))
ex:
(.format(ex))
()

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

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

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

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

Есть два важных момента касательно утверждений в Python, о которых нужно помнить.

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

Ошибки памяти чаще всего связаны с оперативной памятью компьютера и относятся к структуре данных под названием “Куча” (heap). Если есть крупные объекты (или) ссылки на подобные, то с большой долей вероятности возникнет ошибка OutofMemory. Она может появиться по нескольким причинам:

  • Использование 32-битной архитектуры Python (максимальный объем выделенной памяти невысокий, между 2 и 4 ГБ);
  • Загрузка файла большого размера;
  • Запуск модели машинного обучения/глубокого обучения и много другое;

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

Но поскольку Python использует архитектуру управления памятью из языка C (функция malloc()), не факт, что все процессы восстановятся — в некоторых случаях MemoryError приведет к остановке. Следовательно, обрабатывать такие ошибки не рекомендуется, и это не считается хорошей практикой.

Использование исключений

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

Начнем с обработки.

Данный код приведет к исключению ZeroDivisionError. Чтобы этого не случилось, воспользуемся конструкцией try..except, например, так:

Если исполнить этот код, то на консоль будет выведена строка «integer division or modulo by zero». Казалось бы, что толком ничего это нам не дало, ошибка все также есть. Однако в блок except можно поместить обработку.

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

Перед тем как идти дальше, рассмотрим ещё одну возможность.

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

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

«File is empty»

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

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

Вызов исключений

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

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

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

Чтобы бросить исключение необходимо воспользоваться raise

где IOError это класс исключения.

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

Собственные исключения

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

В минимальном исполнении необходимо наследоваться от какого-нибудь класса в иерархии исключений. Например так:

Тогда можно бросить своё исключение:

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

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

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

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

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

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

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

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты.

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

Рассмотрим на примере.

a
b
c a b

File «», line 3
c = a b
^
SyntaxError: invalid syntax

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

Name is not defined в Python [Решено]

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

Читать также:  Как устранить ошибку при запуске программ

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

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

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

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

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

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

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

«Голое» исключение

Есть еще один способ поймать ошибку:

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

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

Есть вопросы по Python?На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!Telegram Чат & КаналВступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

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

Это самый стандартный способ выявить несколько исключений. Сначала мы попробовали открыть доступ к несуществующему ключу, которого нет в нашем словаре. При помощи try/except мы проверили код на наличие ошибки KeyError, которая находится во втором операторе except. Обратите внимание на то, что в конце кода у нас появилась «голое» исключение. Обычно, это не рекомендуется, но вы, возможно, будете сталкиваться с этим время от времени, так что лучше быть проинформированным об этом. Кстати, также обратите внимание на то, что вам не нужно использовать целый блок кода для обработки нескольких исключений. Обычно, целый блок используется для выявления одного единственного исключения. Изучим второй способ выявления нескольких исключений:

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

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

Пользовательские исключения (User-defined Exceptions) в Python

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

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

():

:
val ((«input positive number: «))
val :
NegValException(«Neg val: » (val))
(val )
NegValException e:
(e)

Invalid syntax в Python [Решено]

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

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

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

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

List index out of range [Решено]

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

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

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

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

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

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

Попробуйте except или else

Оператор try/except также имеет пункт else. Он работает только в том случае, если в вашем коде нет ни единой ошибки. Давайте потратим немного времени и взглянем на парочку примеров:

Мы видим словарь, состоящий из трех элементов, и в операторе try/except мы открываем доступ к существующему ключу. Это работает, так что ошибка KeyError не возникает. Так как ошибки нет, else работает, и надпись“No error occurred!” появляется на экране. Теперь добавим оператор finally:

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

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

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

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

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

Отладка кода

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

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

Отладка в IDLE — найдите и исправьте ошибки Python‑кода

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

Отладка в IDLE — найдите и исправьте ошибки Python‑кода

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

Используйте окно управления отладкой

Примечание. Если в строке меню отсутствует меню «Debug», убедитесь, что интерактивное окно находится в фокусе, щелкнув его.

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

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

Читать также:  Анализ типичных ошибок, допускаемых при использовании 1С

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

Окно отладки будет выглядеть так:

Обратите внимание, что панель стека в верхней части окна содержит следующее сообщение:

Это говорит о том, что строка 1 (которая содержит код for i in range(1, 4):) вот-вот будет запущена, но еще не началась. Часть сообщения ‘__main__’.() относится к тому факту, что вы в данный момент находитесь в основном разделе программы, а не находитесь, например, в определении функции до того, как будет достигнут основной блок кода.

Под панелью Stack находится панель Locals, в которой перечислены некоторые странно выглядящие вещи, такие как __annotations__, __builtins__, __doc__ и т.д. Это внутренние системные переменные, которые пока можно игнорировать. Во время выполнения программы вы увидите переменные, объявленные в коде, отображаемом в этом окне, чтобы вы могли отслеживать их значение.

В верхнем левом углу окна отладки расположены пять кнопок: Go, Step, Over, Out и Quit. Эти кнопки управляют тем, как отладчик перемещается по вашему коду.

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

Кнопка Step

Идите вперед и нажмите Step в верхнем левом углу окна отладки. Окно отладки немного изменится и будет выглядеть так:

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

На этом этапе выполняется строка 1 вашего кода, а отладчик остановился непосредственно перед выполнением строки 2.

Второе изменение, которое следует отметить, — это новая переменная i, которой на панели Locals присвоено значение 1. Это потому, что цикл for в первой строке кода создал переменную i и присвоил ей значение 1.

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

Точки останова и кнопка перехода

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

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

Чтобы установить точку останова, на строке кода в окне редактора, на которой вы хотите сделать паузу, щелкните правой кнопкой мыши и выберите «Set Breakpoint». IDLE выделяет линию желтым цветом, чтобы указать, что ваша точка останова установлена. Чтобы удалить точку останова, щелкните правой кнопкой мыши строку с точкой останова и выберите «Clear Breakpoint».

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

Установите точку останова в строке кода с помощью оператора print(). Окно редактора теперь должно выглядеть так:

Сохраните и запустите файл. Как и раньше, панель стека в окне отладки указывает, что отладчик запущен и ожидает выполнения строки 1. Щелкните Go и посмотрите, что происходит в окне отладки:

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

Если вы посмотрите на панель «Locals», то увидите, что обе переменные i и j имеют значения 1 и 2 соответственно. Нажав Go, вы указали отладчику, что он должен выполнять ваш код непрерывно, пока он не достигнет точки останова или конца программы. Снова нажмите Go. Окно отладки теперь выглядит так:

Вы видите, что изменилось? То же сообщение, что и раньше, отображается на панели стека, указывая, что отладчик ожидает повторного выполнения строки 3. Однако значения переменных i и j теперь равны 2 и 4. Интерактивное окно также отображает результат выполнения строки с помощью print() в первый раз в цикле.

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

Нажмите Go в третий раз. Теперь i и j имеют значения 3 и 6. Как вы думаете, что произойдет, если вы нажмете Go еще раз? Поскольку цикл for повторяется только три раза, когда вы снова нажмете Go, программа завершит работу.

Снова и снова

Кнопка Over работает как комбинация Step и Go — перепрыгиваем через функцию или цикл. Другими словами, если вы не собираетесь по-операторно отслеживать и отлаживать функцию, то можете запустить код без необходимости заходить в неё. Кнопка Over переводит вас прямо к результату выполнения этой функции.

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

Далее вы увидите код с ошибками и узнаете, как исправить это с помощью IDLE.

Виды ошибок

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

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

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

Ошибки интерпретатора

Ошибки интерпретатора можно условно разделить на две категории:

  • синтаксические ошибки
  • семантические ошибки, которые чаще называют исключениями.

Синтаксические ошибки (SyntaxError) — это нарушение синтаксиса и пунктуации языка. Во время запуска интерпретатор Python не понимает, как прочесть ошибочное выражение, и вызывает ошибку SyntaxError. Пропустили двоеточие — интерпретатор укажет на место, где оно ожидается.

Отладка в IDLE — найдите и исправьте ошибки Python‑кода

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

Отладка в IDLE — найдите и исправьте ошибки Python‑кода

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

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

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

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

Отладка в IDLE — найдите и исправьте ошибки Python‑кода

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

Однако в случае, если значения не совпадают, возникает AssertionError. Рассмотрим подробнее вывод на вкладке OUTPUT в случае падения тестов:

Отладка в IDLE — найдите и исправьте ошибки Python‑кода

  • со знаком — указывается ожидаемый результат
  • со знаком + указывается результат работы тестируемой функции
  • со знаком ? указывается результат сравнения: знаком + указаны участки, которые встречаются только в результате работы функции, знаком — указаны места, которые есть только в ожидаемом результате

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

Встроенные исключения

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

  • Try: он запускает блок кода, в котором ожидается ошибка.
  • Except: здесь определяется тип исключения, который ожидается в блоке try (встроенный или созданный).
  • Else: если исключений нет, тогда исполняется этот блок (его можно воспринимать как средство для запуска кода в том случае, если ожидается, что часть кода приведет к исключению).
  • Finally: вне зависимости от того, будет ли исключение или нет, этот блок кода исполняется всегда.

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

Ошибка прерывания с клавиатуры (KeyboardInterrupt)

Исключение KeyboardInterrupt вызывается при попытке остановить программу с помощью сочетания Ctrl + C или Ctrl + Z в командной строке или ядре в Jupyter Notebook. Иногда это происходит неумышленно и подобная обработка поможет избежать подобных ситуаций.

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

inp
‘Нажмите Ctrl+C и прервите Kernel:’
KeyboardInterrupt

‘Исключений не произошло’

Анализ вашего кода

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

Читать также:  Существует шесть способов исправить проблему отсутствия программ или программ в Windows 11

Теперь нам нужен какой-нибудь код для анализа. Вот часть кода, которая содержит четыре ошибки. Сохраните её в файле под названием crummy_code.py:

Можете увидеть ошибки не запуская код? Давайте посмотрим, может ли pylint найти их!

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

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

  • С – конвенция (convention)
  • R – рефакторинг (refactor)
  • W – предупреждение (warning)
  • E – ошибка (error)

Наш pylint нашел 3 ошибки, 4 проблемы с конвенцией, 2 строки, которые нуждаются в рефакторинге и одно предупреждение. Предупреждение и 3 ошибки – это как раз то, что я искал. Мы попытаемся исправить этот код и устранить ряд проблем. Для начала мы наведем порядок в импортах, и изменить функцию getWeight на get_weight, в связи с тем, что camelCase не используется в названиях методов. Нам также нужно исправить вызов get_weight, чтобы он передавал правильное количество аргументов и исправить его, чтобы “self” выступал в качестве первого аргумента. Взглянем на новый код:

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

Assert с сообщением об ошибки

def divide(x, y):
assert y != 0 , ‘Нельзя делить на 0’
return round(x/y, 2)

z = divide(21,3)
print(z)

a = divide(21,0)
print(a)

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

На третьей сверху строчке написана сама инструкция assert. Именно здесь проверяется, не является ли переменная y равной 0. Если она больше 0, то условие истинно, и код возвращает требуемый результат.

Но если вызвать метод division() со вторым аргументом 0, то условие assert будет ложным.

По этой причине и возникает исключение Assertion Error. Именно оно возвращает ошибку с сообщением «Нельзя делить на 0».

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

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

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

Отладка в IDLE — найдите и исправьте ошибки Python‑кода

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

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

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

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

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

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

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

Если мы обратимся к урокам элементарной математики, то вспомним, что на ноль делить нельзя. В Пайтоне данная операция вызовет ошибку, как мы можем видеть в примере выше. Чтобы поймать ошибку, мы завернем операцию в оператор try/except.

Способы отладки

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

Рассмотрим на конкретном примере. Ниже описана функция, которая считает сумму чисел от числа start до числа finish. Если start равно трем, а finish — пяти, то программа должна вычислить: 3 + 4 + 5.

В этом коде допущена ошибка. Глядя на код функции sum_of_series() замечаем, что основных переменных там две: n и result. Из этого можно сделать такой вывод — нужно посмотреть, какие значения даются переменным на каждой итерации. После этого найти ошибку не составит труда.

В среде Хекслета отладчика нет, поэтому здесь используется другой подход — отладочная печать. Суть такая же, как и в визуальном отладчике. Разница только в том, что для вывода значений переменных используется обычная печать на экран. То, что печатается на экран, отображается во вкладке OUTPUT, на которую автоматически переключается редактор во время проверки. Посмотрим на примере:

‘new iteration !!!!’

# new iteration !!!!
# 3
# 3
# new iteration !!!!
# 4
# 7

Здесь видно, что итераций цикла на одну меньше, чем нужно. Почему-то не выполняется сложение для последнего числа, которое обозначено как finish. И действительно, если посмотреть на определение, то видно, что там используется n < finish вместо n <= finish. Так с помощью отладки удалось найти ошибку — оказывается, был выбран знак < вместо <=.

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

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

Дополнительные материалы

Отладка в IDLE — найдите и исправьте ошибки Python‑кода

Генерация исключений в Python

Для принудительной генерации исключения используется инструкция raise.

Самый простой пример работы с raise может выглядеть так.

:
()
e:
(«Exception exception » (e))

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

Ключевые моменты assert в Python

  • Утверждение (Assertion) — это условие или булево выражение, которое должно быть истинным.
  • Инструкция assert принимает выражение и необязательное сообщение.
  • Инструкция assert используется для проверки типов, значений аргументов и вывода функций.
  • Это также инструмент для отладки, ведь он останавливает программу при появлении ошибки.
  • Утверждения — это внутренняя проверка для программы. Они работают за счет объявления невозможных условий в коде. Если эти условия не проходят, значит имеется баг.

Предыдущий урок: Namedtuple

Исключения в языках программирования

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

Исключения разделяют на синхронные и асинхронные. Синхронные исключения могут возникнуть только в определенных местах программы. Например, если у вас есть код, который открывает файл и считывает из него данные, то исключение типа “ошибка чтения данных” может произойти только в указанном куске кода. Асинхронные исключения могут возникнуть в любой момент работы программы, они, как правило, связаны с какими-либо аппаратными проблемами, либо приходом данных. В качестве примера можно привести сигнал отключения питания.

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

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

В Python выделяют два различных вида ошибок: синтаксические ошибки и исключения.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *