Как найти ошибку в коде python

Таким образом, вы можете отслеживать растущие значения 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.

Устранение некоторых ошибок

Теперь, когда вы освоились с использованием окна Debug Control, давайте взглянем на программу с ошибками.

Следующий код определяет функцию add_underscores() , которая принимает в качестве аргумента одно строковое объектное слово и возвращает новую строку, содержащую копию слова, в которой каждый символ окружен подчеркиванием. Например, add_underscores(«python») должен вернуть _p_y_t_h_o_n_ .

Вот код с ошибками:

Введите этот код в окно редактора, затем сохраните файл и нажмите F5 , чтобы запустить программу. Ожидаемый результат — _h_e_l_l_o_ , но вместо этого все, что вы видите, — это o_ или буква «o», за которой следует одно подчеркивание.

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

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

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

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

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

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

Делай 1. Угадайте, где находится ошибка

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

Обратите внимание, что программа разделена на два отдельных раздела: определение функции (где определено add_underscores() ) и основной блок кода, который определяет переменную фразу со значением hello , а затем выводит результат вызова add_underscores(phrase) .

Посмотрите на основной раздел кода:

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

Первая строка кода внутри функции создает переменную new_word со значением «_» . У вас все в порядке, поэтому вы можете сделать вывод, что проблема где-то в теле цикла for .

Делай 2. Установите точку останова и проверьте код

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

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

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

На этом этапе выполнение кода приостанавливается непосредственно перед входом в цикл for в функции add_underscores() . Обратите внимание, что на панели Locals отображаются две локальные переменные, word и new_word . В настоящее время word имеет значение «hello» , а new_word — значение «_» , как и ожидалось.

Щелкните Step один раз, чтобы войти в цикл for . Окно отладки изменится и новая переменная i со значением 0 отображается на панели Locals:

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

Еще раз нажмите Step . Если вы посмотрите на панель Locals, то увидите, что переменная new_word приняла значение h_ :

Это неправильно. Первоначально new_word имело значение «_» , а на второй итерации цикла for теперь оно должно иметь значение «_h_» . Если вы нажмете Step еще несколько раз, вы увидите, что для new_word устанавливается значение «e_» , затем «l_» и т.д.

Делай 3. Определите ошибку и попытайтесь ее исправить

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

Посмотрите внимательно на строку. Она сообщает Python, что нужно получить следующий символ слова, прикрепить к нему подчеркивание и присвоить эту новую строку переменной new_word . Это именно то поведение, свидетелем которого вы стали, пройдя цикл for !

Для решения проблемы вам нужно указать Python объединить строковое слово [i] + «_» с существующим значением new_word . Нажмите Quit в окне Debug, но пока не закрывайте окно. Откройте окно редактора и измените строку внутри цикла for на следующую:

Делай 4. Повторяйте шаги с 1 по 3, пока ошибка не исчезнет

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

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

You can only toggle the debugger when idle

(Вы можете переключать отладчик только в режиме ожидания)

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

Программа приостанавливается непосредственно перед входом в цикл for в add_underscores() . Несколько раз нажмите Step и посмотрите, что происходит с переменной new_word на каждой итерации. Успех! Все работает как положено!

Ваша первая попытка исправить ошибку сработала, поэтому вам больше не нужно повторять шаги 1–3. Так будет не всегда. Иногда, прежде чем исправлять ошибку, вам придется повторить этот процесс несколько раз.

Альтернативные способы поиска ошибок

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

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

Например, вместо отладки предыдущей программы с помощью окна отладки вы можете добавить следующую строку в конец цикла for в add_underscores() :

В этом случае измененный код будет выглядеть так:

Когда вы запускаете файл, интерактивное окно отображает следующий вывод:

Здесь показано, какие значение имеет new_word на каждой итерации цикла for . Последняя строка, содержащая только один знак подчеркивания, является результатом выполнения print(add_underscore(phrase)) в конце программы.

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

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

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

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

Заключение: отладка Python с помощью IDLE

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

В этом уроке вы узнали:

• Как использовать окно управления отладкой IDLE для проверки значений переменных.
• Как вставить точки останова, чтобы лучше понять, как работает ваш код.
• Как использовать кнопки Step , Go , Over и Out для построчного отслеживания ошибок.

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

1. Угадай, где находится ошибка.
2. Установите точку останова и проверьте код. Определите ошибку и попытайтесь ее исправить.
3. Повторяйте шаги с 1 по 3, пока ошибка не будет исправлена.
4. Отладка — это не только наука, но и искусство.

Единственный способ овладеть отладкой — это много практиковаться с ней! Один из способов попрактиковаться — открыть окно Debug Control и использовать его для пошагового выполнения кода, работая над упражнениями и задачами, которые вы найдете в наших Практикумах.

Значения исключений и ошибок в Python

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

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

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

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

Ошибки могут быть разных видов:

• Синтаксические
• Недостаточно памяти
• Ошибки рекурсии
• Исключения

Разберем их по очереди.

Синтаксические ошибки (SyntaxError)

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

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

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

Недостаточно памяти (OutofMemoryError)

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

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

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

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

Ошибка рекурсии (RecursionError)

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

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

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

Ошибка отступа (IndentationError)

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

Исключения

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

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

Ошибка типа (TypeError)

Ошибка деления на ноль (ZeroDivisionError)

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

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

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

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

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

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

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

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

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

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

Стандартные ошибки (StandardError)

Рассмотрим некоторые базовые ошибки в программировании.

Арифметические ошибки (ArithmeticError)

• Ошибка деления на ноль (Zero Division);
• Ошибка переполнения (OverFlow);
• Ошибка плавающей точки (Floating Point);

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

Деление на ноль (ZeroDivisionError)

Когда делитель (второй аргумент операции деления) или знаменатель равны нулю, тогда результатом будет ошибка деления на ноль.

Переполнение (OverflowError)

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

Ошибка утверждения (AssertionError)

Когда инструкция утверждения не верна, вызывается ошибка утверждения.

Рассмотрим пример. Предположим, есть две переменные: a и b . Их нужно сравнить. Чтобы проверить, равны ли они, необходимо использовать ключевое слово assert , что приведет к вызову исключения Assertion в том случае, если выражение будет ложным.

Ошибка атрибута (AttributeError)

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

Ошибка импорта (ModuleNotFoundError)

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

Ошибка поиска (LookupError)

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

Здесь есть два вида исключений:

• Ошибка индекса ( IndexError );
• Ошибка ключа ( KeyError );

Ошибка ключа

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

Ошибка индекса

Если пытаться получить доступ к индексу (последовательности) списка, которого не существует в этом списке или находится вне его диапазона, будет вызвана ошибка индекса (IndexError: list index out of range python).

Ошибка памяти (MemoryError)

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

Ошибка имени (NameError)

Ошибка имени возникает, когда локальное или глобальное имя не находится.

В следующем примере переменная ans не определена. Результатом будет ошибка NameError .

Ошибка выполнения (Runtime Error)

Ошибка «NotImplementedError»
Ошибка выполнения служит базовым классом для ошибки NotImplemented . Абстрактные методы определенного пользователем класса вызывают это исключение, когда производные методы перезаписывают оригинальный.

Ошибка типа (TypeError)

Ошибка типа вызывается при попытке объединить два несовместимых операнда или объекта.

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

Ошибка значения (ValueError)

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

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

Пользовательские исключения в Python

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

Это можно сделать, создав новый класс, который будет наследовать из класса Exception в Python.

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

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

У использования исключений есть свои побочные эффекты, как, например, то, что программы с блоками try-except работают медленнее, а количество кода возрастает.

Дальше пример, где модуль Python timeit используется для проверки времени исполнения 2 разных инструкций. В stmt1 для обработки ZeroDivisionError используется try-except, а в stmt2 — if . Затем они выполняются 10000 раз с переменной a=0 . Суть в том, чтобы показать разницу во времени исполнения инструкций. Так, stmt1 с обработкой исключений занимает больше времени чем stmt2 , который просто проверяет значение и не делает ничего, если условие не выполнено.

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

Выводы!

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

Обработка исключений — один из основных факторов, который делает код готовым к развертыванию. Это простая концепция, построенная всего на 4 блоках: try выискивает исключения, а except их обрабатывает.

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

Сравнение линтеров для кода на Python и советы по их применению

В первой части статьи, опубликованной на pythonist.ru (с которой мы уже знакомили вас ранее), разбиралось, почему качество кода имеет такое большое значение, какой код можно считать качественным и на какие стандарты можно ориентироваться.

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

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

Проверять будем следующий код. В нем есть целый ряд логических и стилистических ошибок:

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

Теперь давайте посмотрим на результаты.

Pylint

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

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

Итак, вот результат запуска Pylint для приведенного выше кода:

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

Обратите внимание, что Pylint добавляет к каждой проблемной области префикс R, C, W, E или F, что означает:

• [R]efactor — нужен рефакторинг, поскольку показатель «good practice» не на должном уровне.
• [C]onvention — нарушение соглашения о стандарте кода
• [W]arning — предупреждение о стилистических проблемах или минорных программных проблемах
• [E]rror — существенные проблемы в программе (скорее всего баг)
• [F]atal — ошибки, мешающие дальнейшей работе.

PyFlakes

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

Преимущество этого инструмента в скорости. PyFlakes обработал файл лишь за небольшую долю времени, которое потребовалось Pylint.

Вывод после запуска Pyflakes для приведенного выше кода:

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

pycodestyle (прежде — pep8)

Этот инструмент проверяет код на соответствие некоторым соглашениям из PEP 8. Нейминг не проверяется, так же как и docstrings. Ошибки и предупреждения, выдаваемые этим инструментом, можно посмотреть в таблице.

Результат использования pycodestyle для приведенного выше кода:

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

pydocstyle (прежде — pep257)

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

Результат запуска для приведенного выше кода:

Как и pycodestyle, pydocstyle помечает и разбивает по категориям найденные ошибки. Этот список не конфликтует ни с чем из pycodestyle, поскольку все ошибки имеют приставку D (означающую docstring). Список ошибок можно посмотреть здесь.

Код без ошибок

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

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

В рассмотренном случае мы запускали линтеры на уже написанном коде. Но это не единственный способ проверки качества кода.

Когда можно проверять качество кода?

Вы можете проверять качество своего кода:

• по мере написания,
• перед отправкой,
• при запуске тестов.

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

Чтобы этого избежать, проверяйте качество кода почаще!

Проверка кода по мере его написания

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

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

Проверка кода перед его отправкой

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

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

При запуске тестов

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

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

Заключение

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

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

Благодаря руководствам по стилю ваш код может стать единообразным. PEP8 — отличная отправная точка, если речь идет о Python. Линтеры помогут вам обнаружить проблемные места и стилевые несоответствия. Использовать эти инструменты можно на любой стадии процесса разработки; их можно даже автоматизировать, чтобы код с «пухом» не прошел слишком далеко.

Использование линтеров позволяет избежать ненужных дискуссий о стиле в ходе код-ревью. Некоторым людям морально легче получить объективный фидбэк от инструментов, а не от товарищей по команде. Кроме того, некоторые ревьюеры могут просто не хотеть «придираться» к стилю проверяемого кода. Линтеры не озабочены всеми этими политесами и экономией времени: они жалуются на любое несоответствие.

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

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