Ошибка во время исполнения python - Решение и исправление самых разных ошибок на TopOshibok.ru

by Radu Tyrsina

Radu Tyrsina has been a Windows fan ever since he got his first PC, a Pentium III (a monster at that time). For most of the kids of… read more

Updated on March 4, 2021

A run-time error happens when Python understands what you are saying, but runs into trouble when following your instructions.
You need to know that Python runs the program in two steps.
Not only Python features runtime errors and if you stumble across one, check our Runtime Errors Hub.
We wrote extensively about developer tools like Python. Go to our Developer tools Hub.

XINSTALL BY CLICKING THE DOWNLOAD FILE

Get rid of malfunctioning drivers on your PC

SPONSORED

Drivers can often become corrupt as they can interfere with malfunctioning system files, thus arriving to be installed but not running correctly. To keep your drivers running smoothly, your Windows OS must run even smoother. Get it in perfect shape by following the steps below:

Download Fortect and install it on your PC.
Start the tool’s scanning process to look for corrupt files that are the source of your problem
Right-click on Start Repair so the tool can start the fixing algorithm

Fortect has been downloaded by 0 readers this month, rated 4.4 on TrustPilot

Programming is pretty fun but at some point, when you try to run the program, unfortunately, and inevitably, errors will show up. So, causing, understanding, and fixing errors is an important part of programming.

There are three major types of error that you can get in Python but here we will talk about how to solve Python runtime errors.

A run-time error happens when Python understands what you are saying, but runs into trouble when following your instructions.

How can I fix Python runtime error?

So you’ve written everything correctly, in other words, your syntax is correct, but Python still doesn’t understand what you’re saying. Let’s have a simple example of a Python runtime error:

print(solution)

If you try to run this simple line, you will receive a runtime error simply because you didn’t define the solution variable. The line doesn’t have sense.

To understand better that conundrum, let’s make an association with English grammar. Let’s take this sentence for instance.

Please eat the door.

Grammatically, there is absolutely no problem with this sentence. Everything is there, we have all the syntax elements correct.

But when you are trying to understand the sentence, when you piece up the words, it doesn’t make sense because you know you can open and close the door, even shut it or taking it out but eating it?

In programming, this will be called a run-time error because it shows up before you start the program. There are a few types of runtime errors. In this article, you will learn how to solve them.

1. Use an undefined variable or function.

This can also occur if you use capital letters inconsistently in a variable name:

callMe = “Brad”
print(callme)

Traceback (most recent call last):
  In line 2 of the code you submitted:
    print(callme)
NameError: name 'callme' is not defined

In this case, the program returned the undefined variable error. You defined the variable callMe, but you try to print another variable, callme. You have to use the variables exactly as you define them, case sensitive.

2. Dividing by zero

Guess what? Python cares about math, and in math, dividing by zero makes no sense.

print(1/0)

Traceback (most recent call last):
  In line 1 of the code you submitted:
    print(1/0)
ZeroDivisionError: division by zero

So this line returns a runtime error as Python can read it properly, but when it comes to executing it, he refuses to do so as it has no mathematical sense.

3. Use operators on the wrong type of data

print(“you are trying to add text and numbers” + 20)

Traceback (most recent call last):
  In line 1 of the code you submitted:
    print("you are trying to add text and numbers" + 20)
TypeError: can only concatenate str (not "int") to str

This line returns the runtime error because you try to add text with numbers, crayons, and oranges, chairs with pigeons, etc. It just doesn’t make sense to perform operations with different types of variables.

You also need to know that Python runs the program in two steps. It first checks the syntax and if the syntax is correct, it goes to the second step of executing the program. That’s where he stumbles on possible runtime errors.

We hope this guide answers all your questions but if you have any others or you run into other problems, please throw them down into the comments section below and we will get back at you ASAP.

Источник

A runtime error is a type of error that occurs during program execution. The Python interpreter executes a script if it is syntactically correct. However, if it encounters an issue at runtime, which is not detected when the script is parsed, script execution may halt unexpectedly.

What Causes Runtime Errors

Some of the most common examples of runtime errors in Python are:

Division by zero.
Using an undefined variable or function name.
Performing an operation on incompatible types.
Accessing a list element, dictionary key or object attribute that does not exist.
Accessing a file that does not exist.

Python Runtime Error Examples

Here’s a few examples of runtime errors in Python:

Division by zero

If a number is divided by zero in Python, a runtime error is raised:

print(100/0)

In the above example, a number is attempted to be divided by zero. Running the above code raises a ZeroDivisionError:

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

Using an undefined variable or function name

A runtime error is raised if an attempt is made to access an identifier, such as a variable or function name, that is not declared previously:

print(myString)

In the above example, an undefined identifier myString is attempted to be accessed. Running the above code raises a NameError:

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

Performing an operation on incompatible types

If an operation, such as addition, multiplication etc., is performed between incompatible data types, a runtime error is raised:

myString = "Hello World"
myNumber = 100
print(myString + myNumber)

In the above example, a string is attempted to be concatenated with a number. Since these types are incompatible, a TypeError is raised when the above code is executed:

File "main.py", line 3, in <module>
    print(myString + myNumber)
TypeError: can only concatenate str (not "int") to str

Accessing a non-existent list element, dictionary key or object attribute

If an attempt is made to access a non-existent index or element in a list, dictionary or object, a runtime error is raised.

numbers = [1, 2, 3]
print(numbers[3])

In the above example, an attempt is made to access an item in a list using an out-of-range index, which raises an IndexError:

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

Accessing a file that does not exist

If a file that does not exist is attempted to be accessed, a runtime error is raised:

open("myFile.txt", "r")

In the above example, a non-existent file myFile.txt is attempted to be opened in read-only mode, which raises a FileNotFoundError:

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

How to Fix Runtime Errors in Python

To fix runtime errors in Python, the following steps can be taken:

Identify the error message and note the specific problem being reported.
Check the code for logical, mathematical or typographical errors.
Ensure all identifiers are defined properly before being used.
Make sure the correct data types are being used and are being used correctly.
Verify that list items, dictionary keys, and other objects are being accessed using valid indices or keys.
If necessary, consult the documentation for the relevant library or module.

Track, Analyze and Manage Errors With Rollbar

Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you to proceed with more confidence. Rollbar automates error monitoring and triaging, making fixing Python errors easier than ever. Try it today!

Источник

Introduction
What is a Runtimeerror error?
What causes run time error message in Python?
How do you handle a runtime error?
What is runtime error message example?
Zero Division Error raised
Index Error
How do I fix a built-in exception value error in Python?
What causes the built-in exception overflow error?
Summary
Next steps
References

Introduction

There are several types of errors in Python that help you debug your program. When you run your program, Python first checks for any syntax errors, and then runs the program. Errors thrown during syntax checking are called syntax errors. Errors that are thrown once the code is run are under the class of runtime errors. These errors will always include an error message printed to the interpreter. In this tutorial, you will learn several different types of runtime errors in python, what their error messages are, and how to fix them.

What is a Runtimeerror error?

A python run-time error is a class of python built-in exceptions that are thrown at run-time. There are many different types of run-time errors, we will cover them in this article. Some examples include type errors and name errors. run-time attribute errors fall under a larger group of concrete built-in exceptions in Python.

What causes run time error message in Python?

There are many things that can raise a runtime errors in python depending on the type of error that is thrown. Some questions you can ask yourself to debug including, are you:

dividing by zero?
using incorrect types in operations?
indexing past the length of a list?
accessing a key in dictionary that doesn’t exist?
using variables that haven’t been defined yet?
trying to import or access a file that does not exist?

If you checked for all of these things and you are still getting an error, then it may be caused by something else. We will cover some examples of causes and fixes of certain errors in the following sections.

How do you handle a runtime error?

How you handle a run-time error in python depends on the specific error that was thrown. Once way to generally handle run-time errors is by using a try/except block. You include the code that may cause a runtime error in the try clause. You can then specify how you want to handle the code in the case of an error in the except clause. Here is an example:

>>> y = 12
>>> x = 0
>>> try:
... z = y / x
>>> except:
...print("An error occurred")
...z = 0

This way you are alerted of the error without causing a raised exception and stopping your program.

What is runtime error message example?

Every run-time error in python prints a message to the interpreter indicating what caused raised error and what line it was on. Let’s take a look at some examples of common run-time errors and how to fix them.

Zero Division Error raised

A ZeroDivisionError is thrown when you try to divide or modulo by zero in your code, for example:

>>> x = 0
>>> y = 2
>>> if y % x == 0:
... print(y, :is divisible by", x)
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
ZeroDivisionError: integer division or modulo by zero

Note that the error message idicates the error is happening on line 3. We can avoid this by adding a check to make sure the number we’re modding by isn’t 0 before we perform the operation:

>>> x = 0
>>> y = 2
>>> if (x != 0) and (y % x == 0):
... print(y, "is divisible by", x)

Type Error

A TypeError is thrown when you try to perform an operation with incorrect types. For example, if you tried to concatenate an int and a string, you get a type error:

>>> x = "1"
>>> y = 2
>>> z = x + y
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

The error will also specify which operation is throwing the error and what types you’re trying to use. In this case we can resolve this error by casting all the variables to integers to make sure we are only adding integers:

>>> x = "1"
>>> y = 2
>>> z = int(x) + int(y)
>>> print(x+y)
3

Another common cause for type errors is attempting to loop through an incorrect type. For example, attempting to iterate through an integer:

>>> for i in 10:
... print(i)
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
TypeError: 'int' object is not iterable

In this case the error tells us that we are attempting to iterate through an integer on line 3, which is not a type we can iterate through. Instead we want to use a for-range loop:

>>> for i in range(10):
... print(i)
0
1

One example of a library function that can throw a type error is the pandas.head() method from the Pandas library. The head function throws a type error if you provide an argument that is not an integer:

>>>df.head(2.5)
TypeError: cannot do positional indexing on RangeIndex with these indexers [2.5] of type float

You can learn more about the pandas head function here.

Key Error

A KeyError is thrown when you are trying to access a key in a dictionary that doesn’t exist. For example:

>>> d = {1: ["a"], 2: ["b"]}
>>> print(d[3])
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
KeyError: 3

The error will specify which key you are trying to access that does not exist. You can fix this by making sure to check if the key is in the dictionary before trying to access that specific key. You can check if a key exists in a dictionary by using the in function, which returns a boolean:

>>> d = {1: ["a"], 2: ["b"]}
>>> if 3 in d:
... print(d[3])

Index Error

An index error is caused by indexing into a list with an out of bounds index:

>>> L = [1,2,3]
>>> for i in range(10):
... print(L[i])

We can fix this by either adjusting the for loop to only loop over the range of the list, or adding a check before we index into the list to make sure the index is in range:

>>> L = [1,2,3]
>>> for i in range(len(L)):
... print(L[i])

>>> L = [1,2,3]
>>> for i in range(10):
... if i < len(L):
... print(L[i])

Name Error

A NameError is thrown when you try to use a variable that is not defined yet in the file. For example:

>>>print(x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined

You can fix this by defining the variable on a line before the line it is called on:

>>>x = 5
>>>print(x)
5

Name errors can also be thrown if you try to use a variable that is already defined but out of scope. For example, if you try to use a local variable defined inside of a function globally:

>>>def foo(x,y):
             print(x + y)
>>>
>>>print(x)
Traceback (most recent call last):
  File "<string>", line 4, in <module>
NameError: name 'x' is not defined

To fix this, make sure you are only trying to access variables that are within scope.

File not found error

A FileNotFoundError is thrown when you try to access a file that does not exist in the directory you specified:

>>> open("file", "r")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileNotFoundError: [Errno 2] No such file or directory: 'file'

There are a couple ways to resolve the error. First you should check to make sure that the file you are trying to access is in your current directory. If not, make sure to specify the full filepath when trying to access that file, for example:

>>> open("/C:/folder1/folder2/file", "r")

How do I fix a built-in exception value error in Python?

A value error is caused by giving a function an input that is of the correct type, but an incorrect value. For example:

>>>import math
>>>math.sqrt(-100)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error

Here we get an error because the math.sqrt function only works with positive integers or zero as input. We can prevent this error by making sure that anything passed into the function is greater than or equal to zero.

What causes the built-in exception overflow error?

An overflow error is caused by an arithmetic operation that is too large for Python to represent.

For example:

>>>math.exp(5000)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OverflowError: math range error

You can prevent overflow errors by making sure that the numbers you pass into functions are not too large.

Summary

In this tutorial, you learned that run-time errors are, when they occur in your program, and several ways to fix them. First, you learned that run-time errors are a type of built-in exceptions thrown at run-time. Next, you learned some common causes of run-time errors like dividing by zero and using incorrect types in operations. Then, you learned how to generally handle run-time errors using a try-except block. Last, you looked at several examples of things that can raise run-time errors and how to resolve them, including some less common errors like overflow errors and value errors.

Next steps

If you’re interested in learning more about the basics of Python, coding, and software development, check out our Coding Essentials Guidebook for Developers, where we cover the essential languages, concepts, and tools that you’ll need to become a professional developer.

Thanks and happy coding! We hope you enjoyed this article. If you have any questions or comments, feel free to reach out to jacob@initialcommit.io.

References

Concrete Exceptions
Built-in Exceptions

Final Notes

Источник

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

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

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

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

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

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

Содержание

Runtime error в Python: что это такое и как исправить
Причины возникновения runtime error в Python
Способы исправления runtime error в Python
1. Проверка типов данных
2. Обработка исключений
3. Проверка входных данных
4. Документирование кода
5. Использование отладчика
6. Перепроверка логики кода

Runtime error в Python: что это такое и как исправить

Runtime error (или ошибка времени выполнения) в Python возникает, когда программа запускается, но происходит некоторая ошибка, которая приводит к непредвиденному поведению программы или к ее аварийному завершению.

Ошибки времени выполнения могут возникать по разным причинам:

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

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

Отладка (Debugging): использование IDE или инструментов для обнаружения и исправления ошибок в коде.
Обработка исключений (Exception handling): использование конструкций try/except для перехвата и обработки исключительных ситуаций.
Проверка входных данных: проверка входных данных на корректность перед их использованием в программе.
Тестирование (Testing): создание набора тестовых данных для проверки функциональности программы.
Использование статического анализатора кода: использование инструментов, позволяющих производить анализ кода на предмет обнаружения потенциальных ошибок.

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

Причины возникновения runtime error в Python

Runtime error или ошибка времени выполнения является одним из типов ошибок, которые могут возникнуть при выполнении программы на языке Python. Такая ошибка возникает во время работы программы, когда происходит нарушение правил исполнения кода.

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

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

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

Примеры runtime error в Python:

Ошибка	Описание
NameError	Использование неопределенной переменной.
TypeError	Неправильное использование типов данных.
ZeroDivisionError	Деление на ноль.
IndexError	Обращение к несуществующему индексу списка.

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

Способы исправления runtime error в Python

Ошибки времени выполнения (runtime error) в Python могут возникать по разным причинам. Их исправление зависит от конкретной ошибки и ситуации. В данной статье мы рассмотрим некоторые способы исправления наиболее распространенных ошибок времени выполнения в Python.

1. Проверка типов данных

Одной из самых частых причин возникновения runtime error является неправильное использование типов данных. Для избежания этой проблемы важно проводить проверку типов данных перед выполнением операций. Для этого можно использовать функции, такие как isinstance(), type() и другие.

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

Использование конструкции try-except поможет обрабатывать возможные исключения и предотвратит возникновение runtime error в Python. Оператор try используется для обозначения блока кода, в котором может произойти исключение. Оператор except указывает, как обработать это исключение.

3. Проверка входных данных

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

4. Документирование кода

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

5. Использование отладчика

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

6. Перепроверка логики кода

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

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

Источник

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

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

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

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

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

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

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

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

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

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

a = 8
b = 10
c = a b

File "<ipython-input-8-3b3ffcedf995>", 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)

<ipython-input-3-c6e0f7eb0cde> in <module>
----> 1 recursion()


<ipython-input-2-5395140f7f05> in recursion()
      1 def recursion():
----> 2     return recursion()


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


<ipython-input-2-5395140f7f05> in recursion()
      1 def recursion():
----> 2     return recursion()


RecursionError: maximum recursion depth exceeded

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

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

Пример:

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

  File "<ipython-input-6-628f419d2da8>", line 2
    print('Привет Мир!')
        ^
IndentationError: expected an indented block

Исключения

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

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

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

a = 2
b = 'PythonRu'
a + b

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

TypeError                                 Traceback (most recent call last)

<ipython-input-7-86a706a0ffdf> in <module>
      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)

<ipython-input-43-e9e866a10e2a> in <module>
----> 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)

<ipython-input-6-9e567e3ae964> in <module>
----> 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)

<ipython-input-1-57792b6bc7e4> in <module>
     14
     15 SubClass().do_something()
---> 16 BaseClass().do_something()


<ipython-input-1-57792b6bc7e4> 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 их обрабатывает.

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

Источник

How can I fix Python runtime error?

1. Use an undefined variable or function.

2. Dividing by zero

3. Use operators on the wrong type of data

What Causes Runtime Errors

Python Runtime Error Examples

Division by zero

Using an undefined variable or function name

Performing an operation on incompatible types

Accessing a non-existent list element, dictionary key or object attribute

Accessing a file that does not exist

How to Fix Runtime Errors in Python

Track, Analyze and Manage Errors With Rollbar

Table of Contents

Introduction

What is a Runtimeerror error?

What causes run time error message in Python?

How do you handle a runtime error?

What is runtime error message example?

Zero Division Error raised

Type Error

Key Error

Index Error

Name Error

File not found error

How do I fix a built-in exception value error in Python?

What causes the built-in exception overflow error?

Summary

Next steps

References

Final Notes

Runtime error в Python: что это такое и как исправить

Причины возникновения runtime error в Python

Способы исправления runtime error в Python

1. Проверка типов данных

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

3. Проверка входных данных

4. Документирование кода

5. Использование отладчика

6. Перепроверка логики кода

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

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

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

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

Исключения

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

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

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

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

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

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

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

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

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

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

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

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

Ошибка ключа

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

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

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

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

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

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

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

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

Выводы!