Что такое ошибка времени выполнения операторов

Improve Article

Save Article

Like Article

Отладка¶

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

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

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

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)

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

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

return self.hands[i].removeMatches()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

a = 8
b = 10
c = a b

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

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

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

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

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

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

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

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

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

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

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

def recursion():
    return recursion()

recursion()

---------------------------------------------------------------------------

RecursionError                            Traceback (most recent call last)

 in 
----> 1 recursion()


 in recursion()
      1 def recursion():
----> 2     return recursion()


... last 1 frames repeated, from the frame below ...


 in recursion()
      1 def recursion():
----> 2     return recursion()


RecursionError: maximum recursion depth exceeded

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

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

Пример:

for i in range(10):
    print('Привет Мир!')

  File "", line 2
    print('Привет Мир!')
        ^
IndentationError: expected an indented block

Исключения

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

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

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

a = 2
b = 'PythonRu'
a + b

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in 
      1 a = 2
      2 b = 'PythonRu'
----> 3 a + b


TypeError: unsupported operand type(s) for +: 'int' and 'str'

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

10 / 0

---------------------------------------------------------------------------

ZeroDivisionError                         Traceback (most recent call last)

 in 
----> 1 10 / 0


ZeroDivisionError: division by zero

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

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

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

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

BaseException
 +-- SystemExit
 +-- KeyboardInterrupt
 +-- GeneratorExit
 +-- Exception
      +-- StopIteration
      +-- StopAsyncIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EOFError
      +-- ImportError
      |    +-- ModuleNotFoundError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- OSError
      |    +-- BlockingIOError
      |    +-- ChildProcessError
      |    +-- ConnectionError
      |    |    +-- BrokenPipeError
      |    |    +-- ConnectionAbortedError
      |    |    +-- ConnectionRefusedError
      |    |    +-- ConnectionResetError
      |    +-- FileExistsError
      |    +-- FileNotFoundError
      |    +-- InterruptedError
      |    +-- IsADirectoryError
      |    +-- NotADirectoryError
      |    +-- PermissionError
      |    +-- ProcessLookupError
      |    +-- TimeoutError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      |    +-- RecursionError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning
           +-- ResourceWarning

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

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

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

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

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

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

try:
    inp = input()
    print('Нажмите Ctrl+C и прервите Kernel:')
except KeyboardInterrupt:
    print('Исключение KeyboardInterrupt')
else:
    print('Исключений не произошло')

Исключение KeyboardInterrupt

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

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

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

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

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

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

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

try:  
    a = 100 / 0
    print(a)
except ZeroDivisionError:  
    print("Исключение ZeroDivisionError." )
else:  
    print("Успех, нет ошибок!")

Исключение ZeroDivisionError.

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

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

try:  
    import math
    print(math.exp(1000))
except OverflowError:  
    print("Исключение OverFlow.")
else:  
    print("Успех, нет ошибок!")

Исключение OverFlow.

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

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

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

try:  
    a = 100
    b = "PythonRu"
    assert a == b
except AssertionError:  
    print("Исключение AssertionError.")
else:  
    print("Успех, нет ошибок!")

Исключение AssertionError.

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

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

class Attributes(obj):
    a = 2
    print(a)

try:
    obj = Attributes()
    print(obj.attribute)
except AttributeError:
    print("Исключение AttributeError.")

2
Исключение AttributeError.

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

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

import nibabel

---------------------------------------------------------------------------

ModuleNotFoundError                       Traceback (most recent call last)

 in 
----> 1 import nibabel


ModuleNotFoundError: No module named 'nibabel'

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

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

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

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

Ошибка ключа

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

try:  
    a = {1:'a', 2:'b', 3:'c'}  
    print(a[4])  
except LookupError:  
    print("Исключение KeyError.")
else:  
    print("Успех, нет ошибок!")

Исключение KeyError.

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

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

try:
    a = ['a', 'b', 'c']  
    print(a[4])  
except LookupError:  
    print("Исключение IndexError, индекс списка вне диапазона.")
else:  
    print("Успех, нет ошибок!")

Исключение IndexError, индекс списка вне диапазона.

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

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

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

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

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

try:
    print(ans)
except NameError:  
    print("NameError: переменная 'ans' не определена")
else:  
    print("Успех, нет ошибок!")

NameError: переменная 'ans' не определена

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

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

class BaseClass(object):
    """Опередляем класс"""
    def __init__(self):
        super(BaseClass, self).__init__()
    def do_something(self):
	# функция ничего не делает
        raise NotImplementedError(self.__class__.__name__ + '.do_something')

class SubClass(BaseClass):
    """Реализует функцию"""
    def do_something(self):
        # действительно что-то делает
        print(self.__class__.__name__ + ' что-то делает!')

SubClass().do_something()
BaseClass().do_something()

SubClass что-то делает!



---------------------------------------------------------------------------

NotImplementedError                       Traceback (most recent call last)

 in 
     14
     15 SubClass().do_something()
---> 16 BaseClass().do_something()


 in do_something(self)
      5     def do_something(self):
      6         # функция ничего не делает
----> 7         raise NotImplementedError(self.__class__.__name__ + '.do_something')
      8
      9 class SubClass(BaseClass):


NotImplementedError: BaseClass.do_something

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

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

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

try:
    a = 5
    b = "PythonRu"
    c = a + b
except TypeError:
    print('Исключение TypeError')
else:
    print('Успех, нет ошибок!')

Исключение TypeError

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

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

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

try:
    print(float('PythonRu'))
except ValueError:
    print('ValueError: не удалось преобразовать строку в float: 'PythonRu'')
else:
    print('Успех, нет ошибок!')

ValueError: не удалось преобразовать строку в float: 'PythonRu'

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

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

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

class UnAcceptedValueError(Exception):   
    def __init__(self, data):    
        self.data = data
    def __str__(self):
        return repr(self.data)

Total_Marks = int(input("Введите общее количество баллов: "))
try:
    Num_of_Sections = int(input("Введите количество разделов: "))
    if(Num_of_Sections < 1):
        raise UnAcceptedValueError("Количество секций не может быть меньше 1")
except UnAcceptedValueError as e:
    print("Полученная ошибка:", e.data)

Введите общее количество баллов: 10
Введите количество разделов: 0
Полученная ошибка: Количество секций не может быть меньше 1

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

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

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

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

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

import timeit
setup="a=0"
stmt1 = '''
try:
    b=10/a
except ZeroDivisionError:
    pass'''

stmt2 = '''
if a!=0:
    b=10/a'''

print("time=",timeit.timeit(stmt1,setup,number=10000))
print("time=",timeit.timeit(stmt2,setup,number=10000))

time= 0.003897680000136461
time= 0.0002797570000439009

Выводы!

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

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

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

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

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

1. Синтаксические.
2. Логические (исключения).

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

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

Давайте посмотрим на один пример:

>>> if a < 3
  File "<interactive input>", line 1
    if a < 3
           ^
SyntaxError: invalid syntax

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

Мы можем заметить здесь, что в операторе if отсутствует двоеточие.

Логические ошибки (исключения)

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

Например, они возникают, когда мы пытаемся открыть файл (для чтения), который не существует (FileNotFoundError), пытаемся разделить число на ноль (ZeroDivisionError) или импортировать несуществующий модуль (ImportError).

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

Давайте посмотрим, как Python обрабатывает эти ошибки:

>>> 1 / 0
Traceback (most recent call last):
 File "<string>", line 301, in runcode
 File "<interactive input>", line 1, in <module>
ZeroDivisionError: division by zero

>>> open("imaginary.txt")
Traceback (most recent call last):
 File "<string>", line 301, in runcode
 File "<interactive input>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'imaginary.txt'

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

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

print(dir(locals()['__builtins__']))

locals() [‘__ builtins__’] вернет модуль встроенных исключений, функций и атрибутов. dir позволяет нам перечислять эти атрибуты в виде строк.

Ниже перечислены некоторые из распространенных встроенных исключений в программировании на Python, а также ошибки, вызывающие их:

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

Встроенные и определяемые пользователем исключения в Python можно обрабатывать с помощью операторов try, except и finally.

47422cookie-checkОшибки и встроенные исключения в Python

Содержание

• Что такое питон?
• Почему питон так знаменит?
• Какие особенности 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 есть несколько версий: одна точка 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 для веб-разработки: плюсы и минусы

Python Ошибки неизбежны при создании программ.

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

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

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

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

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

Существуют три типа ошибок в программе:

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

>>> print(«Heт завершающей кавычки!)

SyntaxError: EOL while scanning string literal

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

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

>>> def test(x, у) : return х / у

>>> test(4, 2) # Нормально 2.0

>>> test(4, О) # Ошибка Traceback (most recent call last): File «<pyshell#4>», line 1, in <module> test(4, 0) # Ошибка File «<pyshell#2>», line 1, in test def test(x, у): return х / у ZeroDivisionError: division bу zero

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

Обработка исключений >>> «Строка».indех(«текст») Traceback (most recent call last): File «<pyshell#5>», line 1, in <module> «Строка».indех(«текст») ValueError: suЬstring not found

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

Начал составлять небольшие расчётные программы на языке Python — две версии программы расчёта трапеции и результаты её работы представлены на странице Протока. Смотрите, восхищайтесь и пользуйтесь!

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

Поэтому 4-м типом ошибки предлагаю считать отсутствие Дневника программиста.

!…

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

И не забывайте, пожалуйста, нажимать на кнопки социальных сетей, которые расположены под текстом каждой страницы сайта.
Продолжение тут…