Ошибки времени выполнения python

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

Содержание

  • Известные ошибки в ПО

    • 1962 г.: ракета Маринер-1

    • 1985 г.: аппарат лучевой терапии Therac-25

    • 1991 г.: ЗРК Patriot

    • 2000 г.: Проблема 2000 года (Y2K)

    • 2009-2011 г.: отзыв автомобилей Toyota

  • Определение и разновидности ошибок

    • Синтаксические ошибки

    • Логические (семантические) ошибки

    • Ошибки времени выполнения

    • Недокументированное поведение

  • Поиск ошибок и отладка программы

  • Подходы к обработке ошибок

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

    • Понятия исключения

    • Конструкция try

    • Возбуждение исключений (raise)

    • Особенности обработки исключений внутри функций

    • Утверждения (assert)

    • Исключения или утверждения?

  • Рекомендации

7.1.1. Известные ошибки в ПО¶

История знает множество примеров, где программные ошибки стоили не только огромных денег, но и человеческих жизней 6 7:

7.1.1.1. 1962 г.: ракета Маринер-1¶

Маринер-1 — космический аппарат США для изучения Венеры (Рисунок 7.1.1).

_images/07_01_01.png

Рисунок 7.1.1 — Ракета Маринер-1 9

  • Описание и причина:

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

  • Примерный ущерб / потери

    Никто не погиб, однако экономические потери составили 18,3 млн. долларов.

7.1.1.2. 1985 г.: аппарат лучевой терапии Therac-25¶

Therac-25 — канадский аппарат лучевой терапии (Рисунок 7.1.2).

_images/07_01_02.png

Рисунок 7.1.2 — Аппарат лучевой терапии `Therac-25 10

  • Описание и причина:

    Неисправность была вызвана тем, что в проекте использовались библиотеки с ошибками, входящие в состав ПО аппарата Therac-20, что и привело к фатальным последствиям. В коде была найдена довольно распространенная ошибка многопоточности, называемое состоянием гонки. Тем не менее ошибку не заметили, так как Therac-20 работал исправно из-за дополнительных (аппаратных) мер предосторожности.

  • Примерный ущерб / потери

    Умерло 2 человека, 4 получили серьезное облучение.

7.1.1.3. 1991 г.: ЗРК Patriot¶

Patriot — американский зенитный ракетный комплекс (Рисунок 7.1.3)

_images/07_01_03.png

Рисунок 7.1.3 — ЗРК Patriot 11

  • Описание и причина:

    Во время Войны в Персидском заливе по казармам подразделений США был нанесен ракетный удар иракскими ракетами типа Р-17 (советская баллистическая ракета). Ни одна из ракет не была перехвачена, и удар достиг цели.

    В программном обеспечении ЗРК, отвечающем за ведение и перехват цели, присутствовала ошибка, из-за которой со временем внутренние часы постепенно отходили от истинного значения времени: системное время хранилось как целое число в 24-битном регистре с точностью до 0,1 секунды; при итоговом расчете данные переводились в вещественное число.

    Проблема заключалась в том, что число (cfrac{1}{10}) не имеет точного представления в двоичной системе счисления:

    • (cfrac{1}{10}_{10} = 0,0001100110011001100110011001100…_{2});

    • (cfrac{1}{10}_{10} = 0,00011001100110011001100_{2}) (24-битное целое в системе Patriot);

    • ошибка 1 измерения: ~ (0,000000095_{10});

    • ошибка за 100 часов работы (0,000000095 cdot 10 cdot 60 cdot 60 cdot 100 = 0,34) с.;

    • ракета Р-17 летит со скоростью 1676 м/c, и проходит за 0,34 с. больше полукилометра.

    Данной ошибки в измерениях было достаточно, чтобы ракета преодолела радиус поражения Patriot (Рисунок 7.1.4, Видео 7.1.1).

    _images/07_01_04.png

    Рисунок 7.1.4 — Неправильное определение зоны пролета ракеты 12

    Видео 7.1.1 — Демонстрация ошибки ПО Patriot

  • Примерный ущерб / потери

    Погибло 28 американских солдат и еще двести получили ранения.

7.1.1.4. 2000 г.: Проблема 2000 года (Y2K)¶

  • Описание и причина:

    Разработчики программного обеспечения, выпущенного в XX веке, зачастую использовали два знака для представления года в датах: например, 1 января 1961 года представлялось как «01.01.61». При наступлении 1 января 2000 года при двузначном представлении года после 99 наступал 00 год (т.е. 99 + 1 = 00), что интерпретировалось многими старыми программами как 1900 год. Сложность была еще и в том, что многие программы обращались к вычислению дат вперед (например, при составлении плана закупок, планировании даты полета и т.д.) (Рисунок 7.1.5).

    _images/07_01_05.png

    Рисунок 7.1.5 — Табло показывает 3 января 1900 года, вместо 3 января 2000 года. Франция 13

  • Примерный ущерб / потери

    30-300 млрд. долларов.

7.1.1.5. 2009-2011 г.: отзыв автомобилей Toyota¶

  • Описание и причина:

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

    Видео 7.1.2 — Случайное ускорение автомобиля

    В ходе десятимесячного расследования специалисты NASA выявили, что программное обеспечение не соответствует стандартам MISRA (англ. Motor Industry Software Reliability Association) и содержит 7134 нарушения. Представители Toyota ответили, что у них свои собственные стандарты.

    20 декабря 2010 года Тойота отвергнула обвинения, но выплатила 16 млрд. долларов в досудебном порядке по искам, выпустила обновление ПО для некоторых моделей машин и отозвала 5,5 млн. автомобилей 8 (Рисунок 7.1.6).

    _images/07_01_06.png

    Рисунок 7.1.6 — Lexus ES 350 2007-2010 — одна из моделей с неисправностью 14

  • Примерный ущерб / потери

    Погибло не менее 89 человек, многомиллиардные потери компании.

7.1.2. Определение и разновидности ошибок¶

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

Основные категории ошибок:

  • синтаксические;

  • логические;

  • ошибки времени выполнения;

  • недокументированное поведение.

7.1.2.1. Синтаксические ошибки¶

  • Причина:

    Несоответствие синтаксису языка программирования. Для компилируемых языков программирования синтаксическая ошибка не позволит выполнить компиляцию.

  • Пример:

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

7.1.2.2. Логические (семантические) ошибки¶

  • Причина:

    Несоответствие правильной логике работы программы.

  • Пример:

    >>> def avg_of_2(a, b):
    ...     return a + b / 2
    ...
    >>> avg_of_2(4, 8)  # Вернет 8 вместо 6
    

7.1.2.3. Ошибки времени выполнения¶

  • Причина:

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

  • Пример:

    >>> a = 5
    >>> b = 0
    >>> a / b
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ZeroDivisionError: division by zero
    

7.1.2.4. Недокументированное поведение¶

  • Причина:

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

  • Пример:

    Одним из наиболее известных примеров являются SQL-инъекции — внедрение в запрос произвольного SQL-кода.

    -- Код на сервере
    txtUserId = getRequestString("UserId");
    txtSQL = "SELECT * FROM Users WHERE UserId = " + txtUserId;
    
    -- "Стандартный" вызов на клиенте при UserId = 105 сформирует запрос
    SELECT * FROM Users WHERE UserId = 105
    
    -- Передача в качестве 'UserId' значения
    -- "105; DROP TABLE Suppliers" приведет к удалению таблицы 'Suppliers'
    SELECT * FROM Users WHERE UserId = 105; DROP TABLE Suppliers
    

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

Видео 7.1.3 — Презентация ОС Windows 98

7.1.3. Поиск ошибок и отладка программы¶

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

Существуют две взаимодополняющие технологии отладки:

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

    _images/07_01_07.png

    Рисунок 7.1.7 — Пример отладки в IDE PyCharm: выполнение «заморожено» на точке останова (англ. Breakpoint), при этом IDE отображает текущие значения переменных, дополнительные окна и параметры

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

    Листинг 7.1.1 — Пример отладочного вывода с использованием функции print() | скачать

    import random
    
    a = random.randint(1, 100)
    b = random.randint(1, 100)
    
    print(a, b)  # 44 97
    
    print(a**2 + b**2)  # 11345
    

7.1.4. Подходы к обработке ошибок¶

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

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

  1. «Семь раз отмерь, один раз отрежь» — LBYL (англ. Look Before You Leap);

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

  2. «Легче попросить прощения, чем разрешения» — EAFP (англ. «It’s Easier To Ask Forgiveness Than Permission»).

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

В Листинге 7.1.2 приведен пример сравнения двух подходов.

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

Обе функции возвращают решение линейного уравнения и НИЧЕГО, если 'a' = 0


ФУНКЦИЯ найти_корень_1(a, b):
    ЕСЛИ a не равно 0
        ВЕРНУТЬ -b / a
    ИНАЧЕ
        ВЕРНУТЬ НИЧЕГО


ФУНКЦИЯ найти_корень_2(a, b):
    ОПАСНЫЙ БЛОК КОДА      # Внутри данного блока пишется код, который
        ВЕРНУТЬ -b / a     # потенциально может привести к ошибкам
    ЕСЛИ ПРОИЗОШЛА ОШИБКА  # В случае деления на 0 попадаем сюда
        ВЕРНУТЬ НИЧЕГО

Подход «Семь раз отмерь, один раз отрежь» имеет определенные минусы:

  • проверки могут уменьшить читаемость и ясность основного кода;

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

  • разработчик может легко допустить ошибку, забыв какую-либо из проверок;

  • ситуация может изменится между моментом проверки и моментом выполнения операции.

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

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

7.1.5.1. Понятия исключения¶

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

  • BaseException (базовое исключение)

    • SystemExit (исключение, порождаемое функцией sys.exit() при выходе из программы)

    • KeyboardInterrupt (прерывании программы пользователем, Ctrl+C)

    • Exception (базовое несистемное исключение)

      • ArithmeticError (арифметическая ошибка)

        • FloatingPointError (неудачное выполнение операции с плавающей запятой)

        • OverflowError (результат арифметической операции слишком велик для представления)

        • ZeroDivisionError (деление на ноль)

      • LookupError (некорректный индекс или ключ)

        • IndexError (индекс не входит в диапазон элементов)

        • KeyError (несуществующий ключ)

      • MemoryError (недостаточно памяти)

      • NameError (не найдено переменной с таким именем)

      • OSError (ошибка, связанная с ОС — есть подклассы, например FileNotFoundError)

      • SyntaxError (синтаксическая ошибка, включает классы IndentationError и TabError)

      • SystemError (внутренняя ошибка)

      • TypeError (операция применена к объекту несоответствующего типа)

      • ValueError (аргумент правильного типа, но некорректного значения)

Пример встроенного возбуждения исключения:

>>> "я - строка" / 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for /: 'str' and 'int'

7.1.5.2. Конструкция try

Придерживаясь идеологии «Легче попросить прощения, чем разрешения», Python предусматривает конструкцию try для обработки возникающих исключений.

try
except
else
finally
try:                              # (try строго 1)
    try_ suite                    # код, который может выполниться с ошибкой
except exception_group1 as var1:  # (except - 0 (если есть finally) и более)
    except_suite1                 # код, выполняемый в случае исключения 'exception_group1'
...                               # ссылка на исключение может быть записана в 'var1'
except exception_groupN as varN:
    except_suiteN                 # код, выполняемый в случае исключения 'exception_groupN'
...                               # except-блоков может быть произвольное кол-во
else:                             # (else - 0 или 1)
    else_suite                    # выполняется, если try не завершен преждевременно (например, break)
finally:                          # (finally - 0 или 1)
    finally_suite                 # код, который должен выполнится всегда (была ошибка выше или нет)

Ход выполнения:

  • код, который потенциально может привести к ошибке, помещается в блок try;

  • в случае ошибки, код немедленно завершается и переходит в обработчик except (если он указан для соответствующего исключения);

  • после поток выполнения переходит к else (если исключений не было) и finally (в любом случае).

На Рисунке 7.1.8 приведены общие варианты потока выполнения программы при обработке исключений.

_images/07_01_08.png

Рисунок 7.1.8 — Варианты потока выполнения программы при обработке исключений 4

Обработка исключений (и соответственно идеология «Легче попросить прощения, чем разрешения») — предпочитаемый способ в Python, а использование блоков зависит от конкретной ситуации.

Наиболее общий вариант обработки исключений приведен в Листинге 7.1.3.

Листинг 7.1.3 — Наиболее простой способ обработки исключений | скачать

try:
    x = int(input("Введите целое число x (для вычисления 1/x): "))
    res = 1 / x

    print("1/{} = {:.2f}".format(x, res))
except:
    print("Произошла ошибка!")

# --------------
# Примеры вывода:

# Введите целое число x (для вычисления 1/x): 3
# 1/3 = 0.33

# Введите целое число x (для вычисления 1/x): qwerty
# Произошла ошибка!

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

Листинг 7.1.4 — Обработка общего класса исключений Exception | скачать

try:
    x = int(input("Введите целое число x (для вычисления 1/x): "))
    res = 1 / x

    print("1/{} = {:.2f}".format(x, res))
except Exception as err:
    print("Произошла ошибка!")
    print("Тип:", type(err))
    print("Описание:", err)

# --------------
# Примеры вывода:

# Введите целое число x (для вычисления 1/x): 3
# 1/3 = 0.33

# Введите целое число x (для вычисления 1/x): 5.5
# Произошла ошибка!
# Тип: <class 'ValueError'>
# Описание: invalid literal for int() with base 10: '5.5'

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

Листинг 7.1.5 — Обработка конкретных классов исключений | скачать

try:
    x = int(input("Введите целое число x (для вычисления 1/x): "))
    res = 1 / x

    print("1/{} = {:.2f}".format(x, res))
except ZeroDivisionError:
    print("На ноль делить нельзя!")
except ValueError as err:  # 'err' содержит ссылку на исключение
    print("Будьте внимательны:", err)
except (FileExistsError, FileNotFoundError):  # Исключения можно перечислять в виде кортежа
    print("Этого никогда не случится - мы не работаем с файлами")
except Exception as err:
    # Все, что не обработано выше и является потомком 'Exception',
    # будет обработано здесь
    print("Произошла ошибка!")
    print("Тип:", type(err))
    print("Описание:", err)

# --------------
# Примеры вывода:

# Введите целое число x (для вычисления 1/x): 3
# 1/3 = 0.33

# Введите целое число x (для вычисления 1/x): 0
# На ноль делить нельзя!

# Введите целое число x (для вычисления 1/x): qwerty
# Будьте внимательны: invalid literal for int() with base 10: 'qwerty'

7.1.5.3. Возбуждение исключений (raise

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

raise
raise exception(args)  # явное указание класса возбуждаемого исключения

# или

raise                  # 1) повторное возбуждение активного исключения (re-raise)
                       #    внутри блока except
                       # 2) 'TypeError' по умолчанию

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

В Листинге 7.1.6 приведен пример использование оператора raise.

Листинг 7.1.6 — Использование raise для управления потоком выполнения | скачать

MIN = 1
MAX = 10

try:
    x = int(input("Введите целое число от {} до {}: ".format(MIN, MAX)))

    if not MIN <= x <= MAX:
        # Возбудив исключение, его можно будет обработать в except
        # вместе с другими похожими исключениями
        raise ValueError("Число лежит вне интервала [{}; {}]!".format(MIN, MAX))

    print("Спасибо!")
except ValueError as err:  # 'err' содержит ссылку на исключение
    print("Будьте внимательны:", err)

# --------------
# Примеры вывода:

# Введите целое число от 1 до 10: 5
# Спасибо!

# Введите целое число от 1 до 10: 15
# Будьте внимательны: Число лежит вне интервала [1; 10]!

# Введите целое число от 1 до 10: qwerty
# Будьте внимательны: invalid literal for int() with base 10: 'qwerty'

7.1.5.4. Особенности обработки исключений внутри функций¶

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

Разница в обработке исключений приведена в Листинге 7.1.7.

Листинг 7.1.7 — Различная обработка исключений в функции | скачать

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


def get_1_x(x):
    """Вернуть 1/x.

    Функция не обрабатывает исключения - ответственность на вызывающем коде.
    """
    return 1/x


def get_2_x(x):
    """Вернуть 2/x.

    Функция обрабатывает исключения, "затушив" ошибку - вызывающий код
    не будет знать, сработала функция правильно или нет.

    Данный способ использовать не рекомендуется!
    """
    try:
        return 2/x
    except Exception as e:
        print("Внутри произошла ошибка...", e)


def get_3_x(x):
    """Вернуть 3/x.

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

    Внутренняя обработка исключений может быть полезна, если в целом результат
    функции не связан с внутренней ошибкой.
    """
    try:
        return 3/x
    except Exception as e:
        print("Внутри произошла ошибка...", e)
        raise

funcs = (get_1_x, get_2_x, get_3_x)
# Вызываем каждую функцию с "ошибочным" параметром
for func in funcs:
    try:
        print("-" * 50)
        print("Запущена функция:", func.__name__)
        print(func(0))
    except Exception as e:
        print("Произошла ошибка: {}.".format(e))

# -------------
# Пример вывода:

# --------------------------------------------------
# Запущена функция: get_1_x
# Произошла ошибка: division by zero.
# --------------------------------------------------
# Запущена функция: get_2_x
# Внутри произошла ошибка... division by zero
# None
# --------------------------------------------------
# Запущена функция: get_3_x
# Внутри произошла ошибка... division by zero
# Произошла ошибка: division by zero.

7.1.5.5. Утверждения (assert

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

В Python утверждения поддерживаются оператором assert.

assert
assert boolean_expression[, optional_expression]

# boolean_expression: логическое выражение для проверки
# optional_expression: необязательное сообщение (строка)

Если boolean_expression возвращает False, возбуждается исключение AssertionError с сообщением optional_expression (если задано).

Пример использования утверждений приведен в Листинге 7.1.8.

Листинг 7.1.8 — Использование утверждений в Python | скачать

# Использование оператора assert
# поможет отследить неверно реализованную функцию


def add_to_list(x, lst=[]):
    # Использование assert здесь оправдано - список всегда
    # подразумевается пустым
    assert len(lst) == 0, "Список должен быть пуст!"

    lst.append(x)
    return lst


print(add_to_list(1))
print(add_to_list(2))

# -------------
# Пример вывода:

# [1]
# Traceback (most recent call last):
#   File "07_01_08_a.py", line 15, in <module>
#     print(add_to_list(2))
#   File "07_01_08_a.py", line 8, in add_to_list
#     assert len(lst) == 0, "Список должен быть пуст!"
# AssertionError: Список должен быть пуст!

Примечание

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

7.1.5.6. Исключения или утверждения?¶

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

Таблица 7.1.1 — Использовать исключения или утверждения?

Исключения

Утверждения

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

Проверка ситуаций, которые предположительно не могут произойти

1

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

Проверка предусловий, постусловий и инвариантов в необщедоступном коде (локальных функциях, внутреннем коде и т.д.)

2

Предоставление информации об ошибке пользователю

Предоставление информации об ошибке команде разработки

3

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

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

Примеры использования исключения и утверждений приведены в Листингах 7.1.9 (а-в).

Листинг 7.1.9 (а) — Использование исключений и утверждений в Python | скачать

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


def fact(x):
    """Вернуть факториал 'x'.

    Не передавайте числа больше 15 во избежание переполнения памяти.
    """
    if x <= 1:
        return 1
    else:
        return x * fact(x-1)


def fact_save_1(x):
    assert x <= 15, 
        "Не передавайте числа больше 15 во избежание переполнения памяти"

    return fact(x)


def fact_save_2(x):
    if not x <= 15:
        raise ValueError("Не передавайте числа больше 15 во избежание "
                         "переполнения памяти")

    return fact(x)


print("{:>3} {:>20} {:>20}".format(*("x", "fact()", "fact_save()")))
for x in (5, 20):
    print("{:3}".format(x), end=" ")
    print("{:20}".format(fact(x)), end=" ")
    # print("{:20}".format(fact_save_1(x)))
    print("{:20}".format(fact_save_2(x)))

# -------------
# Пример вывода:

#   x               fact()          fact_save()
#   5                  120                  120
#  20  2432902008176640000 Traceback (most recent call last):
#   File "07_01_08_b.py", line 23, in <module>
#     print("{:20}".format(fact_save(x)))
#   File "07_01_08_b.py", line 15, in fact_save
#     assert x <= 15, "Не передавайте числа больше 15 во избежание переполнения памяти"
# AssertionError: Не передавайте числа больше 15 во избежание переполнения памяти
#
#   x               fact()          fact_save()
#   5                  120                  120
#  20  2432902008176640000 Traceback (most recent call last):
#   File "07_01_08_b.py", line 34, in <module>
#     print("{:20}".format(fact_save_2(x)))
#   File "07_01_08_b.py", line 24, in fact_save_2
#     raise ValueError("Не передавайте числа больше 15 во избежание "
# ValueError: Не передавайте числа больше 15 во избежание переполнения памяти

Листинг 7.1.9 (б) — Использование исключений и утверждений в Python | скачать

# Использование оператора assert для проверки входных и выходных данных


def make_call(accounts, account_id, mins, costs_per_min):
    """Списать со счета 'account' на 'value' баллов в случае звонка.

    Параметры:
        - accounts (dict): словарь со всеми счетами абонентов;
        - account_id (int): идентификатор абонента в словаре 'accounts';
        - mins (int): количество минут разговора;
        - costs_per_min (int): стоимость минуты разговора.
    """

    def get_costs(mins, costs_per_min):
        """Вернуть стоимость звонка.

        Параметры:
            - mins (int): количество минут разговора;
            - costs_per_min (int): стоимость минуты разговора.
        """
        return -mins * costs_per_min

    # Проверка типов
    assert isinstance(mins, int), "Параметр 'mins' имеет неверный тип!"
    assert isinstance(costs_per_min, (int, float)),
        "Параметр 'costs_per_min' имеет неверный тип!"

    # Проверка значений
    assert mins > 0, "Параметр 'mins' должен быть > 0"
    assert costs_per_min >= 0, "Параметр 'costs' должен быть >= 0"

    # Расчет (стоимость звонка не должна быть меньше 0)
    costs_total = get_costs(mins, costs_per_min)
    assert costs_total >= 0,
        "Расчет стоимости звонка был осуществлен неверно!"
    accounts[account_id] -= costs_total


# Словарь ID=Баланс
accounts = {"Василий Иванов": 100}
print(accounts)

try:
    make_call(accounts, "Василий Иванов", mins=4, costs_per_min=2)
except Exception as e:
    print("Во время списывания стоимости звонка произошла ошибка:", e)

print(accounts)

Листинг 7.1.9 (в) — Использование исключений и утверждений в Python | скачать

# Совместное использование исключений и утверждений

weekday_names = {
    1: "Понедельник",
    2: "Вторник",
    3: "Среда",
    4: "Четверг",
    5: "Пятница",
    6: "Суббота",
    7: "Воскресенье"
}


def weekday_name(weekday):
    """Вернуть название дня недели. Нумерация с 1.

    Параметры:
        weekday (int): номер дня недели.

    Исключения:
        - TypeError: 'weekday' не int;
        - ValueError: 'weekday' не число от 1 до 7.

    Результат:
        str: название дня недели.
    """
    # "Невозможная" ситуация - словарь 'weekday_names' может быть
    # "испорчен" - проверяется с помощью assert.
    assert weekday_names is not None and isinstance(weekday_names, dict), 
        "Внутренняя ошибка программы. Обратитесь в разрабочику."

    # Параметры функции проверяются с помощью исключений
    if not isinstance(weekday, int):
        raise TypeError("Параметр 'weekday' должен быть типа 'int'.")
    if weekday not in weekday_names:
        raise ValueError("Параметр 'weekday' должен быть целым числом "
                         "от 1 до 7.")

    return weekday_names[weekday]


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

while True:
    try:
        weekday = int(input("Введите номер дня недели (1-7): "))

        # if not 1 <= weekday <= 7:
        #     raise ValueError("Номер дня недели должен быть целым числом "
        #                      "от 1 до 7.")

        # Раскомментируйте код ниже, чтобы получить срабатывание assert
        # weekday_names = None

        print("Это -", weekday_name(weekday))

        break
    except TypeError as err:
        print("Проверьте, что введено целое число.")
    except ValueError as err:
        print("Проверьте, что введено целое число, и оно "
              "находится в допустимых границах.")
    except Exception as err:
        print("Ошибка при определении названия дня недели.")
        print(err)  # Запись в лог информации об ошибке

7.1.6. Рекомендации¶

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

  • код, который потенциально может привести к ошибкам, должен быть помещен в блок try;

  • блок except должен:

    • обрабатывать исключения максимально конкретно (указывать конкретные классы); стоит определять свои классы исключений, когда это это имеет смысл;

    • категорически не следует «тушить» исключения (писать пустой или бессмысленный except);

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

  • блок finally следует использовать для освобождения ресурсов (это может быть закрытие файла или сетевого соединения), независимо от того, прошла операция успешно или нет.


1

Sebesta, W.S Concepts of Programming languages. 10E; ISBN 978-0133943023.

2

Python — официальный сайт. URL: https://www.python.org/.

3

Python — FAQ. URL: https://docs.python.org/3/faq/programming.html.

4

Саммерфилд М. Программирование на Python 3. Подробное руководство. — М.: Символ-Плюс, 2009. — 608 с.: ISBN: 978-5-93286-161-5.

5

Лучано Рамальо. Python. К вершинам мастерства. — М.: ДМК Пресс , 2016. — 768 с.: ISBN: 978-5-97060-384-0, 978-1-491-94600-8.

6

5 худших багов в истории. URL: https://tproger.ru/articles/5-worst-bugs-in-history/.

7

List of software bugs. URL: https://en.wikipedia.org/wiki/List_of_software_bugs.

8

Toyota: 81 514 нарушений в коде. URL: https://habrahabr.ru/company/pvs-studio/blog/310862/.

9

Mariner-1. URL: https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%80%D0%B8%D0%BD%D0%B5%D1%80-1#/media/File:Atlas_Agena_with_Mariner_1.jpg.

10

Therac-25. URL: https://upload.wikimedia.org/wikipedia/commons/b/bd/Clinac_2rtg.jpg.

11

ЗРК Patriot. URL: http://vpk.name/file/img/Patriot_antimissile.t.jpg.

12

Incorrectly Calculated Range Gate. URL: https://hsto.org/files/853/04a/1dc/85304a1dc1b6499d94d5394436e42faf.jpg.

13

Табло показывает 3 января 1900 года, вместо 3 января 2000 года. Франция. URL: https://upload.wikimedia.org/wikipedia/commons/f/fb/Bug_de_l%27an_2000.jpg.

14

MY 2007–2010 Lexus ES 350. URL: http://pictures.topspeed.com/IMG/crop/201108/lexus-es-350-6_1600x0w.jpg.

Отладка¶

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

  1. Синтаксические ошибки — ошибки, обнаруживаемые Python в ходе трансляции
    исходного кода в байт-код. Такие ошибки вызваны тем, что что-то не так с
    синтаксисом программы. Пример: забыв поставить двоеточие в конце строки def,
    получим такое сообщение об ошибке: SyntaxError: invalid syntax.
  2. Ошибки времени выполнения — ошибки, возникающие при выполнении программы
    в случае, если происходит что-то неожиданное. Большинство ошибок времени выполнения
    включают информацию о том, где произошла ошибка и какие функции при этом выполнялись.
    Пример: бесконечная рекурсия в конце концов приводит к ошибке времени выполнения
    из-за превышения максимальной разрешенной глубины рекурсии.
  3. Семантические ошибки — логические ошибки в программе, которая компилируется и выполняется,
    но делает не то, что от нее ожидается. Пример: Выражение может быть вычислено не в том
    порядке, как ожидает программист, не позаботившийся о скобках.

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

Синтаксические ошибки¶

Синтаксическую ошибку легко исправить, как только вы поняли, в чем она состоит. К сожалению, сообщения об ошибках часто оказываются не очень полезны. Наиболее частые сообщения SyntaxError: invalid syntax и SyntaxError: invalid token не очень информативны.

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

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

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

Вот несколько советов, как избежать самых распространенных синтаксических ошибок:

  1. Убедитесь, что вы не используете одно из ключевых слов Python как идентификатор
    (имя переменной или функции).
  2. Проверьте, что не забыли поставить двоеточие в конце заголовка каждого составного
    предложения, включая for, while, if и def.
  3. Проверьте, что отступы в вашей программе сделаны единообразно. Можете
    пользоваться пробелами или табуляцией, но лучше не смешивать одно с другим.
    Все строки каждого уровня вложенности кода должны иметь одинаковый отступ.
  4. Убедитесь, что все строковые литералы в коде имеют открывающие и закрывающие кавычки.
  5. Если в программе имеются строковые литералы в тройных кавычках,
    занимающие несколько строк в файле, убедитесь, что они корректно
    завершены. Незавершенная строка может привести к ошибке invalid token в конце
    вашей программы, или к тому, что последующая часть программы будет восприниматься
    как продолжение строки (пока не встретится другая строка). В последнем случае
    может даже не быть сообщения об ошибке!
  6. Незакрытая скобка – (, { или [ – заставляет Python полагать, что следующая строка
    является продолжением текущей. В этом случае Python почти всегда сообщает об ошибке в
    следующей строке.
  7. Проверьте, что в условии используется оператор ==, а не =.

Если ничто из этого не помогло, переходите к следующему разделу…

Не могу запустить программу, что бы я ни делал¶

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

Если это случилось, можно создать новую программу (вроде Hello World!) и убедиться, что она-то запускается. Затем постепенно добавляйте необходимый код к работающей программе.

Ошибки времени выполнения¶

Если ваша программа синтаксически корректна, Python, как минимум, начнет ее выполнение. Что теперь может пойти не так?

Моя программа совсем ничего не делает¶

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

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

Моя программа зависает¶

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

  1. Если вы подозреваете какой-то определенный цикл, то добавьте предложение
    print непосредственно перед циклом, которое сообщит о входе в цикл, и
    еще одно сразу после цикла, сообщающее о выходе из него.
  2. Запустите программу. Если вы видите первое сообщение, но не видите второго,
    то программа вошла в бесконечный цикл. См. раздел Бесконечный цикл ниже.
  3. Что касается неограниченной рекурсии, то в этом случае программа будет выполняться
    какое-то время, пока не выдаст ошибку RuntimeError: Maximum recursion depth exceeded.
    Если это случилось, см. раздел Неограниченная рекурсия ниже.
  4. Если программа не выдает такую ошибку, но вы подозреваете, что проблема в
    рекурсивном методе или функции, приемы, описанные в разделе Неограниченная рекурсия,
    все же могут оказаться полезны.
  5. Если вышеописанные шаги не работают, проверьте другие циклы или другие рекурсивные
    функции и методы.
  6. Если и это не помогает, то вы, вероятно, не понимаете последовательность
    выполнения предложений в вашей программе. См. раздел Поток выполнения ниже.

Бесконечный цикл¶

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

Например:

while x > 0 and y < 0:
    # do something to x
    # do something to y

    print  "x: ", x
    print  "y: ", y
    print  "condition: ", (x > 0 and y < 0)

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

Неограниченная рекурсия¶

В большинстве случаев неограниченная рекурсия приведет к ошибке RuntimeError: Maximum recursion depth exceeded.

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

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

Поток выполнения¶

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

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

При выполнении программы возникает исключение¶

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

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

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

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

Здесь несколько возможных причин:

  1. Вы пытаетесь неправильно использовать значение. Пример: индексирование
    строки, списка или кортежа значением, отличным от числа.
  2. Имеется несоответствие между строкой формата и элементами, которые должны
    быть в нее подставлены. Либо передается неверное количество элементов, либо
    в строке формата указано недопустимое для данного элемента преобразование.
  3. Вы передали неправильное число аргументов в функцию или метод.
    Для методов, посмотрите на определение метода и проверьте, что первым параметром
    является self. Затем посмотрите на вызов метода; убедитесь, что вызываете
    метод для объекта правильного типа, и что все аргументы корректны.
KeyError
Вы пытаетесь получить доступ к элементу словаря, используя ключ, которого нет в словаре.
AttributeError
Вы пытаетесь получить доступ к атрибуту или методу, который не существует.
IndexError
Индекс, который вы используете для доступа к списку (строке или кортежу), больше,
чем длина списка минус один. Непосредственно перед строкой, в которой возникает ошибка,
вставьте предложение print, которое выведет индекс и длину списка.
Длина правильная? А индекс?

Слишком много данных выводится на печать¶

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

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

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

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

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

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

Семантические ошибки¶

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

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

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

Моя программа не работает¶

Спросите себя:

  1. Есть ли что-то, что программа должна делать, но это не делается?
    Найдите ту часть кода, которая отвечает за эту функциональность, и
    убедитесь, что она выполняется тогда, когда вы этого ожидаете.
  2. Происходит ли что-то, чего не должно происходить? Найдите в программе
    код, отвечающий за это, и выясните, почему он выполняется вопреки
    вашим ожиданиям.
  3. Производит ли часть кода эффект, который вы не ожидаете?
    Убедитесь, что вы понимаете этот участок кода; будьте особенно внимательны,
    если код вызывает функции или методы из других модулей Python. Прочтите
    документацию по функциям, которые вы используете. Изучите эти функции, написав
    для них несложные тесты.

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

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

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

Мое длинное выражение не работает¶

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

Пример:

self.hands[i].addCard (self.hands[self.findNeighbor(i)].popCard())

Это выражение можно переписать так:

neighbor = self.findNeighbor (i)
pickedCard = self.hands[neighbor].popCard()
self.hands[i].addCard (pickedCard)

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

Другая проблема, связанная с длинными выражениями, состоит в том, что порядок вычисления выражения может оказаться не таким, какой вы ожидали. Например, если вы запишете выражение x/2pi на Python, у вас может получиться:

Это неправильно. Операции умножения и деления имеют одинаковый приоритет, и их вычисление производится слева направо. Поэтому данное выражение на Python вычисляет (x/2)pi.

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

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

Моя функция (или метод) возвращает не то, что мне нужно¶

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

return self.hands[i].removeMatches()

напишите:

count = self.hands[i].removeMatches()
return count

Теперь у вас есть возможность вывести значение count перед выходом из функции.

Ничего не понимаю, бред какой-то¶

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

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

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

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

Нет, мне реально нужна помощь¶

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

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

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

  1. Если имеется сообщение об ошибке, то что это за сообщение и где оно возникает?
  2. Какое последнее изменение вы сделали перед тем, как возникла проблема? Какие
    строки кода вы изменили/добавили, или какой новый тест не проходит?
  3. Что вы уже сделали, и что поняли к настоящему моменту в связи с этой проблемой?

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

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

In this article, we will look at some examples of runtime errors in Python Programming Language

Runtime Errors

  • A runtime error in a program is one that occurs after the program has been successfully compiled.

  • The Python interpreter will run a program if it is syntactically correct (free of syntax errors). However, if the program encounters a runtime error — a problem that was not detected when the program was parsed and is only revealed when a specific line is executed — it may exit unexpectedly during execution. When a program crashes due to a runtime error, we say it has crashed

Some examples of Python Runtime errors

  • division by zero

  • performing an operation on incompatible types

  • using an identifier that has not been defined

  • accessing a list element, dictionary value, or object attribute which doesn’t exist

  • trying to access a file that doesn’t exist

Let’s take a closer look at each of them by using an example

Division by zero

If we divide any number by zero, we get this error.

Algorithm (Steps)

Following are the Algorithm/steps to be followed to perform the desired task −

  • Take a variable to store the first input number.

  • Take another variable to store the second input number(Here the second number should be 0).

  • Divide the first number by the second number and print the result.

Example

The following program returns the runtime error if we divide a number with zero −

firstNumb = 11 secondNumb = 0 print(firstNumb/secondNumb)

Output

On executing, the above program will generate the following output −

Traceback (most recent call last):
  File "main.py", line 6, in <module>
print(firstNumb/secondNumb)
ZeroDivisionError: division by zero

Because the second number is 0 and no number can be divided by 0, we get a runtime
error.

Performing an operation on incompatible types

This error occurs when we perform operations like addition, multiplication, and so on on incompatible data types.

Algorithm (Steps)

Following are the Algorithm/steps to be followed to perform the desired task −

  • Take a string and assign some random value to it and store it in a variable.

  • Take an integer and assign some random integer value to it and store it in another variable.

  • Perform some operations such as addition on the above variables and print it.

Example

The following program returns the runtime error if we perform operation on incompatible data types −

inputString = "TutorialsPoint" inputNumber = 11 print(inputString + inputNumber)

Output

On executing, the above program will generate the following output −

Traceback (most recent call last):
  File "main.py", line 6, in <module>
    print(inputString + inputNumber)
TypeError: must be str, not int

We can’t add an integer to the string data type here, so we get a type error (runtime error).

Using an identifier that has not been defined

This error occurs when we attempt to access an identifier that has not been declared previously.

Example

The following program returns the runtime error if we are using undefined identifier −

print(tutorialsPoint)

Output

On executing, the above program will generate the following output −

Traceback (most recent call last):
  File "main.py", line 2, in <module>
    print(tutorialsPoint)
NameError: name 'tutorialsPoint' is not defined

Because we did not define the tutorialsPoint identifier and are accessing it by printing it, a runtime error occurs (Name error).

Accessing a list element, dictionary value, or object attribute which doesn’t exist

This runtime error occurs when we attempt to access a non-existent list,string,dictionary element/index.

When we attempt to use an index that does not exist or is too large, it throws an IndexError.

Algorithm (Steps)

Following are the Algorithm/steps to be followed to perform the desired task −

  • Create a list and assign some random values to it.

  • Access the list element by index by giving the index that doesn’t exist and printing it.

Example

The following program returns the index error if we access an element out of range −

inputList =[1, 4, 8, 6, 2] print("Element at index 10:", inputList[10])

Output

On executing, the above program will generate the following output −

Traceback (most recent call last):
  File "main.py", line 6, in <module>
    print("Element at index 10:", inputList[10])
IndexError: list index out of range

There are 5 elements in the list, and we are attempting to access the 10th index, which does not exist, resulting in an index error.

Trying to access a file that doesn’t exist

If we try to open a file that doesn’t exist, it throws a runtime error.

Algorithm (Steps)

Following are the Algorithm/steps to be followed to perform the desired task −

  • Create a variable to store the path of the text file. This is a fixed value. In the example below, this value must be substituted with the file path from your own system.

  • Use the open() function(opens a file and returns a file object as a result) to open the text file in read-only mode by passing the file name, and mode as arguments to it (Here “r” represents read-only mode)

givenFile = open(inputFile,"r")
  • Print it value of the given file.

Example

The following program returns the file not found error if we access an file that doesn’t exist −

inputFile = "tutorialsPoint.txt" givenFile = open(inputFile,"r") print(givenFile)

Output

On executing, the above program will generate the following output −

Traceback (most recent call last):
  File "main.py", line 4, in <module>
    givenFile = open(inputFile,"r")
FileNotFoundError: [Errno 2] No such file or directory: 'tutorialsPoint.txt'

Conclusion

We learned about runtime errors in Python in this article. We also used examples to explain the most common Python runtime errors.

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

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

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

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

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

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

Смотрите также описание инструкции try ... except и заявления raise в разделе «Ошибки и исключения в Python»

Типы ошибок Python - Gossipfunda - Технология

Типы ошибок Python — Gossipfunda — Технология

Содержание

  • Что такое питон?
  • Почему питон так знаменит?
  • Какие особенности Python?
  • Типы ошибок Python
  • Ошибка синтаксиса
  • Ошибка выполнения
  • Семантическая ошибка
  • Типы исключений в Python
  • Резюме
  • Вопросы-Ответы
  • Вопрос 1. Что такое обработка ошибок в Python?
  • Вопрос 2: Какие ошибки возникают чаще всего или основные ошибки в Python?
  • Вопрос 3: как избежать ошибок?
  • Вопрос 4: Как исправить ошибки?
  • Вопрос 5: почему логическую или семантическую ошибку решить сложнее всего?
  • Похожие сообщения:

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

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

Что такое питон?

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

Почему питон так знаменит?

Есть C, C ++, Java, JavaScript, вместо которых вы можете видеть, что python предпочтительнее. Некоторые люди думают, что, поскольку это новый язык, но это не настоящий питон, он появился до того, как Java появилась на рынке, но в то время Java была более предпочтительной, потому что в то время рынок рос. Но после этого с развитием машинного обучения искусственный интеллект увеличил использование Python среди разработчиков. Многие компании используют python в качестве основного языка и языка поддержки.

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

Не пропусти: Ошибка обновления Android 7 -Как исправить проблему

Какие особенности Python?

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

  • Программы на Python можно легко делить.
  • Python также поддерживает другие языки; также могут использоваться другие языки. Нет никаких ограничений. И самое большое преимущество — это библиотеки, которые вы можете легко использовать в различных больших проектах.
  • Python — объектно-ориентированный язык, поэтому он основан на концепции «упс», что делает его более гибким при решении реальных проблем.
  • Кроме того, у Python есть несколько версий: одна точка x, две точки x и многие другие, которые всегда пытаются извлечь из последней версии.

Типы ошибок Python

Теперь у вас также есть ошибки, которые очень распространены на всех языках, будь то C, C ++, Java, JavaScript, Python или любой другой язык. Типы ошибок Python делятся на три этапа:

  1. Ошибка синтаксиса
  2. Ошибка выполнения
  3. Семантическая ошибка
  4. Ключевая ошибка Python

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

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

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

Ошибка выполнения

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

Чтобы избежать таких ошибок, не используйте недопустимые команды, которые не определены или невозможны. Чтобы устранить исключения, используйте метод обработки ошибок, который включает в себя try и except. В этом случае выводится логика в блоке try и в except exceptions, если логика неверна и пользователь может увидеть ошибку. И если вы хотите выполнить еще одну строку кода, вы можете заблокировать finally и записать ее в этом блоке. Таким образом, нет дилеммы, как этот код будет выполняться независимо от того, является ли блок try истинным или блоком except истинным. Для обработки ошибок в Python есть еще одна функция — Raise. Это используется для создания исключений, которые могут предупредить пользователя.

Семантическая ошибка

Один из распространенных типов ошибок Python — семантическая ошибка. Это не ошибка кода, а логическая или арифметическая ошибка.

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

Типы исключений в Python

  • Ошибка импорта: это происходит, когда модуль, к которому пользователь пытается получить доступ, отсутствует. Эту ошибку можно решить, перейдя в командную строку write — pip install (имя модуля, который вы хотите использовать), если модуль не установлен, он будет установлен после этого, но, если он уже установлен, у вас могут быть два разных версия python проверьте, установлен ли модуль в правильной версии. Вам нужно было удалить ненужную версию Python.
  • Ошибка индекса: эта ошибка возникает, когда пользователь пытается вызвать несуществующий индекс в списке Python. Это можно решить, используя правильный индекс.
  • Ошибка значения: значение несовместимо. Например: если переменная назначена как строка, и пользователь пытается изменить ее тип данных. Решением этой проблемы является использование ошибки try and except.
  • Системная ошибка: это происходит, когда в вашей системе есть проблема.
  • Ошибка типа: когда пользователь пытается работать с двумя объектами разных типов. Например: добавление строковой переменной с целочисленной переменной. Это можно решить, позаботившись о типе данных.
  • Ошибка отступа: возникают, когда имеется неправильный отступ, или мы можем сказать, что неправильный интервал, и решение этого состоит в том, чтобы обеспечить правильный интервал.
  • Ошибка утверждения: эта ошибка возникает, когда условие утверждения утверждения ложно.
  • AttributeError: когда нет правильного атрибута для связывания строки.
  • KeyError: эта ошибка возникает, когда значение ключа, которое ищет пользователь, не найдено в словаре. В словаре каждый ключ связан с определенным значением. Итак, решение этой ошибки — ввести ключ, который присутствует в словаре.
  • EOFError: EOFError (ошибка конца файла) возникает, когда вы принимаете данные от пользователя. Это можно решить, используя try и except.
  • Ошибка GeneratorExit: close () используется для завершения генератора, при этом все будущие значения отбрасываются. Это эквивалентно выдаче ошибки выхода. Это можно решить, попробовав и ожидая.
  • Ошибка KeyboardInterrupt: в этой ошибке программа будет работать до бесконечности, она не остановится, поэтому, если пользователь вводит ctrl + c, она выдаст ошибку прерывания клавиатуры.
  • MemoryError: Когда вы пытаетесь загрузить огромный файл в Python с помощью записной книжки Jupyter или любого другого источника, наиболее распространенной ошибкой, с которой может столкнуться кто-то, является ошибка памяти.
  • NameError: когда переменная не определена в программе, и вы пытаетесь с ней работать, тогда ошибка возникает как ошибка имени.
  • TabError: ошибка возникает, когда программе предоставляются неправильные или несовместимые вкладки и пробелы.
  • UnboundLocalError: эта ошибка возникает, когда пользователь пытается получить доступ к локальной переменной в функции, которая не определена.
  • FloatingPointError: когда результат, который вы хотели, — это не то, что вы получаете.

Резюме

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

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

Вопросы-Ответы

Вопрос 1. Что такое обработка ошибок в Python?

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

Вопрос 2: Какие ошибки возникают чаще всего или основные ошибки в Python?

Ответ 2: Есть две основные ошибки, с которыми сталкивается программист. Это синтаксическая ошибка и ошибка времени выполнения или исключение.

Вопрос 3: как избежать ошибок?

Ответ 3: В исключениях в блоке try и except используется пропуск для игнорирования ошибки.

Вопрос 4: Как исправить ошибки?

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

Вопрос 5: почему логическую или семантическую ошибку решить сложнее всего?

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

Похожие сообщения:

  • команда «python setup.py egg_info» завершилась неудачно с кодом ошибки 1
  • Ключевая ошибка Python | KeyError в Python
  • Модуль не найден ошибка Python | ModuleNotFoundError
  • Синтаксическая ошибка python
  • Ошибка памяти Python
  • Python для веб-разработки: плюсы и минусы

  • Ошибки времени выполнения java
  • Ошибки врачей при проведении медицинского освидетельствования на состояние опьянения
  • Ошибки врачей при постановке диагноза
  • Ошибки врачей при лечении коронавируса
  • Ошибки врачей при ковиде