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

What are exceptions in Python?

Python has built-in exceptions which can output an error. If an error occurs while running the program, it’s called an exception.

If an exception occurs, the type of exception is shown. Exceptions needs to be dealt with or the program will crash. To handle exceptions, the block is used.

Some exceptions you may have seen before are , or but there are many more.

All exceptions in Python inherit from the class BaseException. If you open the Python interactive shell and type the following statement it will list all built-in exceptions:

The idea of the try-except clause is to handle exceptions (errors at runtime). The syntax of the try-except block is:

1234	try: <do something>except Exception: <handle the error>

The idea of the try-except block is this:

try: the code with the exception(s) to catch. If an exception is raised, it jumps straight into the except block.
except: this code is only executed if an exception occured in the try block. The except block is required with a try block, even if it contains only the pass statement.

It may be combined with the else and finally keywords.

else: Code in the else block is only executed if no exceptions were raised in the try block.
finally: The code in the finally block is always executed, regardless of if a an exception was raised or not.

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

Обработка чекбоксов в php

Инструкция позволяет программисту принудительно вызвать указанное исключение. Например:

>>> raise NameError('HiThere')
# Traceback (most recent call last):
#  File "<stdin>", line 1, in <module>
# NameError: HiThere

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

try
    raise NameError('HiThere')
except NameError
    print('An exception flew by!')
    raise

# An exception flew by!
# Traceback (most recent call last):
#   File "<stdin>", line 2, in <module>
# NameError: HiThere

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

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

Тип исключения — это класс экземпляра исключения, а значение — сам экземпляр.

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

raise Exception("foo occurred").with_traceback(tracebackobj)

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

try
    print(1  )
except Exception as exc
    raise RuntimeError("Something bad happened") from exc

# Traceback (most recent call last):
#   File "<stdin>", line 2, in <module>
# ZeroDivisionError: division by zero

# The above exception was the direct cause of the following exception:

# Traceback (most recent call last):
#   File "<stdin>", line 4, in <module>
# RuntimeError: Something bad happened

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

try
    print(1  )
except Exception as exc
    raise RuntimeError("Something bad happened")

# Traceback (most recent call last):
#   File "<stdin>", line 2, in <module>
# ZeroDivisionError: division by zero

# The above exception was the direct cause of the following exception:

# Traceback (most recent call last):
#   File "<stdin>", line 4, in <module>
# RuntimeError: Something bad happened

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

8.8. Predefined Clean-up Actions¶

Обработка фото в powerpoint

Some objects define standard clean-up actions to be undertaken when the object
is no longer needed, regardless of whether or not the operation using the object
succeeded or failed. Look at the following example, which tries to open a file
and print its contents to the screen.

for line in open("myfile.txt"):
    print(line, end="")

The problem with this code is that it leaves the file open for an indeterminate
amount of time after this part of the code has finished executing.
This is not an issue in simple scripts, but can be a problem for larger
applications. The statement allows objects like files to be
used in a way that ensures they are always cleaned up promptly and correctly.

with open("myfile.txt") as f
    for line in f
        print(line, end="")

After the statement is executed, the file f is always closed, even if a
problem was encountered while processing the lines. Objects which, like files,
provide predefined clean-up actions will indicate this in their documentation.

deque

Улучшаем качество фотографий в один клик: обработка фото онлайн

В соответствии с документацией Python, deque – это обобщение стеков и очередей. Они являются контейнером замен для списка Python. Они защищены от потоков и поддерживают эффективность соединения памяти, а также сноски с обеих сторон deque. Список оптимизирован под быстрые операции с фиксированной длиной. За всеми подробностями можете обратиться к . Наш deque поддерживает аргумент maxlen, который устанавливает границы для deque. В противном случае deque будет расти до произвольных размеров. Когда ограниченный deque заполнен, любые новые объекты, которые были добавлены, вызовут такое же количество элементов, которые выскочат с другого конца. Вот основное правило: если вам нужно что-то быстро дописать или вытащить, используйте deque. Если вам нужен быстрый случайный доступ, используйте list. Давайте уделим пару минут, и посмотрим, как мы можем создавать и использовать deque.

Python

from collections import deque
import string

d = deque(string.ascii_lowercase)
for letter in d:
print(letter)

1
2
3
4
5
6

fromcollectionsimportdeque

importstring

d=deque(string.ascii_lowercase)

forletter ind

print(letter)

Здесь мы импортируем deque из нашего модуля collections, а также модуль string. Для того, чтобы создать экземпляр deque, нам нужно передать его итерируемой. В данном случае, мы передали его string.ascii_lowercase, и получили список всех строчных букв в алфавите. Наконец, мы сделали цикл над deque и вывели каждый объект. Теперь давайте взглянем на несколько методов, которыми обладает deque.

Python

d.append(‘bork’)
print(d)

# deque()

d.appendleft(‘test’)
print(d)

# deque()

d.rotate(1)
print(d)

# deque()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

d.append(‘bork’)

print(d)

# deque()

d.appendleft(‘test’)

print(d)

# deque()

d.rotate(1)

print(d)

# deque()

Давайте устроим небольшой разбор полетов. Сначала мы разместили строку в правом краю deque. Далее разместили другую строку в левом краю deque. Наконец, мы вызываем rotate в нашем deque и передаем его единице, что заставляет его сместиться один раз в право. Другими словами, это заставляет один объект сместиться с правой части на фронтальную. Вы можете передать ему отрицательное число, чтобы происходило то же самое, но с левой стороны. Давайте закончим этот раздел и взглянем на пример, основанный на документации Python:

Python

from collections import deque

def get_last(filename, n=5):
«»»
Возвращаем последние N кол-во строк из файла
«»»
try:
with open(filename) as f:
return deque(f, n)
except OSError:
print(«Файл не открывается: {}».format(filename))
raise

1
2
3
4
5
6
7
8
9
10
11
12
13

fromcollectionsimportdeque

defget_last(filename,n=5)

«»»

Возвращаем последние N кол-во строк из файла
«»»

try

withopen(filename)asf

returndeque(f,n)

exceptOSError

print(«Файл не открывается: {}».format(filename))

raise

Этот код работает по схожему принципу с программой-хвостом Linux. Здесь мы передаем имя файла нашему скрипту вместе с n количеством строк, которые мы хотим вернуть. Наш deque ограничен той или иной цифрой, которую мы указываем как n. Это значит, что как только deque заполнится, когда новые строки прочитаны и добавлены в deque, старые строки выпадают из другого конца и отбрасываются. Я также завернул открываемый в операторе файл в простой обработчик исключений, так как очень легко выполнить передачу по неверному пути. Таким образом, мы поймаем несуществующие файлы, к примеру. Теперь мы готовы идти дальше и приступить к изучению namedtuple.

Exceptions versus Syntax Errors

Syntax errors occur when the parser detects an incorrect statement. Observe the following example:

The arrow indicates where the parser ran into the syntax error. In this example, there was one bracket too many. Remove it and run your code again:

This time, you ran into an exception error. This type of error occurs whenever syntactically correct Python code results in an error. The last line of the message indicated what type of exception error you ran into.

Instead of showing the message , Python details what type of exception error was encountered. In this case, it was a . Python comes with various built-in exceptions as well as the possibility to create self-defined exceptions.

Создание настраиваемого класса исключения

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

class EmployeeModuleError(Exception):
    """Base Exception Class for our Employee module"""
    pass


class EmployeeNotFoundError(EmployeeModuleError):
    """Error raised when employee is not found in the database"""

    def __init__(self, emp_id, msg):
        self.employee_id = emp_id
        self.error_message = msg


class EmployeeUpdateError(EmployeeModuleError):
    """Error raised when employee update fails"""

    def __init__(self, emp_id, sql_error_code, sql_error_msg):
        self.employee_id = emp_id
        self.error_message = sql_error_msg
        self.error_code = sql_error_code

По соглашению об именах к имени класса исключения добавляется суффикс «Ошибка».

8.7. Defining Clean-up Actions¶

The statement has another optional clause which is intended to
define clean-up actions that must be executed under all circumstances. For
example:

>>> try
...     raise KeyboardInterrupt
... finally
...     print('Goodbye, world!')
...
Goodbye, world!
KeyboardInterrupt
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>

If a clause is present, the
clause will execute as the last task before the
statement completes. The clause runs whether or
not the statement produces an exception. The following
points discuss more complex cases when an exception occurs:

If an exception occurs during execution of the
clause, the exception may be handled by an
clause. If the exception is not handled by an
clause, the exception is re-raised after the
clause has been executed.
An exception could occur during execution of an
or clause. Again, the exception is re-raised after
the clause has been executed.
If the statement reaches a ,
or statement, the
clause will execute just prior to the
, or
statement’s execution.
If a clause includes a
statement, the returned value will be the one from the
clause’s statement, not the
value from the clause’s
statement.

For example:

>>> def bool_return():
...     try
...         return True
...     finally
...         return False
...
>>> bool_return()
False

A more complicated example:

>>> def divide(x, y):
...     try
...         result = x  y
...     except ZeroDivisionError
...         print("division by zero!")
...     else
...         print("result is", result)
...     finally
...         print("executing finally clause")
...
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, )
division by zero!
executing finally clause
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'

As you can see, the clause is executed in any event. The
raised by dividing two strings is not handled by the
clause and therefore re-raised after the
clause has been executed.

Конструкция Try .. Finally .. End

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

Синтаксис конструкции следующий:

Следует отметить, что, если исключение не будет возбуждено, то операторы из раздела Finally также будут освобождать ресурсы. Отличие заключается в том, что: • во-первых, при возникновении исключения часть операторов из раздела Try не выполняется, а при нормальной работе — выполняются все; • во-вторых, после освобождения ресурсов вследствие возбуждения исключения поиск обработчика исключения продолжится, поскольку исключения этой конструкцией не обрабатываются, а при нормальной работе будет выполняться оператор, следующий за конструкцией Try..Finally. Следует по возможности получать различные ресурсы перед конструкцией Try. Это гарантирует, что раздел Finally сможет должным образом освободить ресурсы.

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

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

Python

try:
1 / 0
except:
print(«You cannot divide by zero!»)

1
2
3
4

try

except

print(«You cannot divide by zero!»)

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

Python

my_dict = {«a»:1, «b»:2, «c»:3}

try:
value = my_dict
except KeyError:
print(«That key does not exist!»)

1
2
3
4
5
6

my_dict={«a»1,»b»2,»c»3}

try

value=my_dict»d»

exceptKeyError

print(«That key does not exist!»)

Python

my_list =

try:
my_list
except IndexError:
print(«That index is not in the list!»)

1
2
3
4
5
6

my_list=1,2,3,4,5

try

my_list6

exceptIndexError

print(«That index is not in the list!»)

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

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

Python

my_dict = {«a»:1, «b»:2, «c»:3}

try:
value = my_dict
except IndexError:
print(«This index does not exist!»)
except KeyError:
print(«This key is not in the dictionary!»)
except:
print(«Some other error occurred!»)

1
2
3
4
5
6
7
8
9
10

my_dict={«a»1,»b»2,»c»3}

try

value=my_dict»d»

exceptIndexError

print(«This index does not exist!»)

exceptKeyError

print(«This key is not in the dictionary!»)

except

print(«Some other error occurred!»)

Это самый стандартный способ выявить несколько исключений. Сначала мы попробовали открыть доступ к несуществующему ключу, которого нет в нашем словаре. При помощи try/except мы проверили код на наличие ошибки KeyError, которая находится во втором операторе except

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

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

Python

try:
value = my_dict
except (IndexError, KeyError):
print(«An IndexError or KeyError occurred!»)

1
2
3
4

try

value=my_dict»d»

except(IndexError,KeyError)

print(«An IndexError or KeyError occurred!»)

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

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

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

Base classes¶

The following exceptions are used mostly as base classes for other exceptions.

exception

The base class for all built-in exceptions. It is not meant to be directly
inherited by user-defined classes (for that, use ). If
is called on an instance of this class, the representation of
the argument(s) to the instance are returned, or the empty string when
there were no arguments.

The tuple of arguments given to the exception constructor. Some built-in
exceptions (like ) expect a certain number of arguments and
assign a special meaning to the elements of this tuple, while others are
usually called only with a single string giving an error message.

(tb)

This method sets tb as the new traceback for the exception and returns
the exception object. It is usually used in exception handling code like
this:

try
    ...
except SomeException
    tb = sys.exc_info()[2
    raise OtherException(...).with_traceback(tb)

exception: All built-in, non-system-exiting exceptions are derived from this class. All
user-defined exceptions should also be derived from this class.

exception: The base class for those built-in exceptions that are raised for various
arithmetic errors: , ,
.

exception: Raised when a related operation cannot be
performed.

Exception hierarchy¶

The class hierarchy for built-in exceptions is:

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

Перехват исключений в Python

В Python исключения обрабатываются при помощи инструкции .

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

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

# Для получения типа исключения импортируем модуль sys
import sys

randomList = 

for entry in randomList:
    try:
        print("The entry is", entry)
        r = 1/int(entry)
        break
    except:
        print("Oops!", sys.exc_info(), "occurred.")
        print("Next entry.")
        print()
print("The reciprocal of", entry, "is", r)

Результат:

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

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

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

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

# Для получения типа исключения импортируем модуль sys
import sys

randomList = 

for entry in randomList:
    try:
        print("The entry is", entry)
        r = 1/int(entry)
        break
    except Exception as e:
        print("Oops!", e.__class__, "occurred.")
        print("Next entry.")
        print()
print("The reciprocal of", entry, "is", r)

Результат выполнения этого кода будет точно таким же.

3. Блоки try/except

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

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

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

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

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

a. Несколько except в Python

У одного блока может быть несколько блоков . Рассмотрим примеры с несколькими вариантами обработки.

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

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

Рассмотрим вывод:

b. Несколько исключений в одном except

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

c. Общий except после всех блоков except

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

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

Отдельную инструкцию нельзя разместить между блоками и .

Это приведет к синтаксической ошибке.

Но может быть только один общий или блок по умолчанию типа . Следующий код вызовет ошибку :

try-except

Lets take do a real world example of the try-except block.

The program asks for numeric user input. Instead the user types characters in the input box. The program normally would crash. But with a try-except block it can be handled properly.

The try except statement prevents the program from crashing and properly deals with it.

try:    x = input("Enter number: ")    x = x + 1    print(x)except:    print("Invalid input")

Entering invalid input, makes the program continue normally:

The try except statement can be extended with the finally keyword, this will be executed if no exception is thrown:

12	finally: print("Valid input.")

The program continues execution if no exception has been thrown.

There are different kinds of exceptions: ZeroDivisionError, NameError, TypeError and so on. Sometimes modules define their own exceptions.

The try-except block works for function calls too:

123456789

def fail():    1 / try:    fail()except:    print('Exception occured')print('Program continues')

This outputs:

If you are a beginner, then I highly recommend this book.

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

Синтаксические ошибки (Syntax Errors), также известны как ошибки грамматического разбора (parsing errors), являются, пожалуй, наиболее распространенным видом жалоб пока вы все еще изучаете Python:

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

Иерархия исключений

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

Например, и являются подклассами . Код , который ловит не поймать . Тем не менее, код , который ловит будет ловить как s и s.

Иерархия встроенных исключений:

Warnings¶

The following exceptions are used as warning categories; see the
documentation for more details.

exception: Base class for warning categories.

exception: Base class for warnings generated by user code.

exception: Base class for warnings about deprecated features when those warnings are
intended for other Python developers.

exception

Base class for warnings about features which are obsolete and
expected to be deprecated in the future, but are not deprecated
at the moment.

This class is rarely used as emitting a warning about a possible
upcoming deprecation is unusual, and
is preferred for already active deprecations.

exception: Base class for warnings about dubious syntax.

exception: Base class for warnings about dubious runtime behavior.

exception: Base class for warnings about deprecated features when those warnings are
intended for end users of applications that are written in Python.

exception: Base class for warnings about probable mistakes in module imports.

exception: Base class for warnings related to Unicode.

exception: Base class for warnings related to and .

Основные исключения

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

Exception – то, на чем фактически строятся все остальные ошибки;
AttributeError – возникает, когда ссылка атрибута или присвоение не могут быть выполнены;
IOError – возникает в том случае, когда операция I/O (такая как оператор вывода, встроенная функция open() или метод объекта-файла) не может быть выполнена, по связанной с I/O причине: «файл не найден», или «диск заполнен», иными словами.
ImportError – возникает, когда оператор import не может найти определение модуля, или когда оператор не может найти имя файла, который должен быть импортирован;
IndexError – возникает, когда индекс последовательности находится вне допустимого диапазона;
KeyError – возникает, когда ключ сопоставления (dictionary key) не найден в наборе существующих ключей;
KeyboardInterrupt – возникает, когда пользователь нажимает клавишу прерывания(обычно Delete или Ctrl+C);
NameError – возникает, когда локальное или глобальное имя не найдено;
OSError – возникает, когда функция получает связанную с системой ошибку;
SyntaxError — возникает, когда синтаксическая ошибка встречается синтаксическим анализатором;
TypeError – возникает, когда операция или функция применяется к объекту несоответствующего типа. Связанное значение представляет собой строку, в которой приводятся подробные сведения о несоответствии типов;
ValueError – возникает, когда встроенная операция или функция получают аргумент, тип которого правильный, но неправильно значение, и ситуация не может описано более точно, как при возникновении IndexError;
ZeroDivisionError – возникает, когда второй аргумент операции division или modulo равен нулю;

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

Catching Exceptions in Python

The try-except block can handle exceptions. This prevents abrupt exits of the program on error. In the example below we purposely raise an exception.

try:     1 / except ZeroDivisionError:     print('Divided by zero')print('Should reach here')

After the except block, the program continues. Without a try-except block, the last line wouldn’t be reached as the program would crash.

In the above example we catch the specific exception ZeroDivisionError. You can handle any exception like this:

try:     open("fantasy.txt")except:     print('Something went wrong')print('Should reach here')

You can write different logic for each type of exception that happens:

12345678910

try: except FileNotFoundError: except IsADirectoryError:except:print('Should reach here')

Related course: Complete Python Programming Course & Exercises