Исключения

5.4. 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

Дополнение: Полная форма try..except

Форма try…except не полная, полной же является try..except..else..finaly.

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

Иными словами, finally выполняет блок инструкций в любом случае, было ли исключение, или нет. А инструкция else выполняется в том случае, если исключения не было.

В целом, использование полной формы таково:

try
    исполяем какой-то код
except Exception as e
    обработка исключения
else
    код, который будет исполнен в случае, когда не возникает исключения
finally
    код, который гарантированно будет исполнен последним (всегда исполняется)

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.

8.3. Handling Exceptions¶

It is possible to write programs that handle selected exceptions. Look at the
following example, which asks the user for input until a valid integer has been
entered, but allows the user to interrupt the program (using Control-C or
whatever the operating system supports); note that a user-generated interruption
is signalled by raising the exception.

>>> while True
...     try
...         x = int(input("Please enter a number: "))
...         break
...     except ValueError
...         print("Oops!  That was no valid number.  Try again...")
...

The statement works as follows.

• First, the try clause (the statement(s) between the and
  keywords) is executed.

• If no exception occurs, the except clause is skipped and execution of the
  statement is finished.

• If an exception occurs during execution of the try clause, the rest of the
  clause is skipped. Then if its type matches the exception named after the
  keyword, the except clause is executed, and then execution
  continues after the statement.

• If an exception occurs which does not match the exception named in the except
  clause, it is passed on to outer statements; if no handler is
  found, it is an unhandled exception and execution stops with a message as
  shown above.

A statement may have more than one except clause, to specify
handlers for different exceptions. At most one handler will be executed.
Handlers only handle exceptions that occur in the corresponding try clause, not
in other handlers of the same statement. An except clause may
name multiple exceptions as a parenthesized tuple, for example:

... except (RuntimeError, TypeError, NameError):
...     pass

A class in an clause is compatible with an exception if it is
the same class or a base class thereof (but not the other way around — an
except clause listing a derived class is not compatible with a base class). For
example, the following code will print B, C, D in that order:

class B(Exception):
    pass

class C(B):
    pass

class D(C):
    pass

for cls in B, C, D]:
    try
        raise cls()
    except D
        print("D")
    except C
        print("C")
    except B
        print("B")

Note that if the except clauses were reversed (with first), it
would have printed B, B, B — the first matching except clause is triggered.

The last except clause may omit the exception name(s), to serve as a wildcard.
Use this with extreme caution, since it is easy to mask a real programming error
in this way! It can also be used to print an error message and then re-raise
the exception (allowing a caller to handle the exception as well):

import sys

try
    f = open('myfile.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err
    print("OS error: {0}".format(err))
except ValueError
    print("Could not convert data to an integer.")
except
    print("Unexpected error:", sys.exc_info()[])
    raise

The … statement has an optional else
clause, which, when present, must follow all except clauses. It is useful for
code that must be executed if the try clause does not raise an exception. For
example:

for arg in sys.argv1:]:
    try
        f = open(arg, 'r')
    except OSError
        print('cannot open', arg)
    else
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

The use of the clause is better than adding additional code to
the clause because it avoids accidentally catching an exception
that wasn’t raised by the code being protected by the …
statement.

When an exception occurs, it may have an associated value, also known as the
exception’s argument. The presence and type of the argument depend on the
exception type.

The except clause may specify a variable after the exception name. The
variable is bound to an exception instance with the arguments stored in
. For convenience, the exception instance defines
so the arguments can be printed directly without having to
reference . One may also instantiate an exception first before
raising it and add any attributes to it as desired.

>>> try
...     raise Exception('spam', 'eggs')
... except Exception as inst
...     print(type(inst))    # the exception instance
...     print(inst.args)     # arguments stored in .args
...     print(inst)          # __str__ allows args to be printed directly,
...                          # but may be overridden in exception subclasses
...     x, y = inst.args     # unpack args
...     print('x =', x)
...     print('y =', y)
...
<class 'Exception'>
('spam', 'eggs')
('spam', 'eggs')
x = spam
y = eggs

If an exception has arguments, they are printed as the last part (‘detail’) of
the message for unhandled exceptions.

Exception handlers don’t just handle exceptions if they occur immediately in the
try clause, but also if they occur inside functions that are called (even
indirectly) in the try clause. For example:

Что такое исключения?

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

На сегодняшний день принято выделять такие типы ошибок:

• Синтаксические – возникают из-за синтаксических погрешностей кода;
• Логические – проявляются вследствие логических неточностей в алгоритме;
• Исключения – вызваны некорректными действиями пользователя или системы.

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

print("Hello World!)

После попытки запуска выдастся текст ошибки:

  File "main.py", line 1
    print("Hello World!)
                       ^
SyntaxError: EOL while scanning string literal

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

def avg(a, b):
    return a + b / 2
print(avg(10, 20))

20

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

print(10 / 0)

После попытки запуска будет выведено:

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

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

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

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

• 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 равен нулю;

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

Argument of an Exception

An exception can have an argument, which is a value that gives additional information about the problem. The contents of the argument vary by exception. You capture an exception’s argument by supplying a variable in the except clause as follows −

try:
   You do your operations here
   ......................
except ExceptionType as Argument:
   You can print value of Argument here...

If you write the code to handle a single exception, you can have a variable follow the name of the exception in the except statement. If you are trapping multiple exceptions, you can have a variable follow the tuple of the exception.

This variable receives the value of the exception mostly containing the cause of the exception. The variable can receive a single value or multiple values in the form of a tuple. This tuple usually contains the error string, the error number, and an error location.

Example

Following is an example for a single exception −

#!/usr/bin/python3

# Define a function here.
def temp_convert(var):
   try:
      return int(var)
   except ValueError as Argument:
      print ("The argument does not contain numbers\n", Argument)

# Call above function here.
temp_convert("xyz")

This produces the following result −

The argument does not contain numbers
invalid literal for int() with base 10: 'xyz'

Python try…finally

The statement in Python can have an optional clause. This clause is executed no matter what, and is generally used to release external resources.

For example, we may be connected to a remote data center through the network or working with a file or a Graphical User Interface (GUI).

In all these circumstances, we must clean up the resource before the program comes to a halt whether it successfully ran or not. These actions (closing a file, GUI or disconnecting from network) are performed in the clause to guarantee the execution.

Here is an example of file operations to illustrate this.

This type of construct makes sure that the file is closed even if an exception occurs during the program execution.

5.3. Warnings¶

The following exceptions are used as warning categories; see the
module for more information.

exception

Base class for warning categories.

exception

Base class for warnings generated by user code.

exception

Base class for warnings about deprecated features.

exception

Base class for warnings about features which will be deprecated in the future.

exception

Base class for warnings about dubious syntax.

exception

Base class for warnings about dubious runtime behavior.

exception

Base class for warnings about constructs that will change semantically in the
future.

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 .

Issuing warnings¶

Use these functions to issue warnings from C code. They mirror similar
functions exported by the Python module. They normally
print a warning message to sys.stderr; however, it is
also possible that the user has specified that warnings are to be turned into
errors, and in that case they will raise an exception. It is also possible that
the functions raise an exception because of a problem with the warning machinery.
The return value is if no exception is raised, or if an exception
is raised. (It is not possible to determine whether a warning message is
actually printed, nor what the reason is for the exception; this is
intentional.) If an exception is raised, the caller should do its normal
exception handling (for example, owned references and return
an error value).

int ( *category, const char *message, Py_ssize_t stack_level)

Issue a warning message. The category argument is a warning category (see
below) or ; the message argument is a UTF-8 encoded string. stack_level is a
positive number giving a number of stack frames; the warning will be issued from
the currently executing line of code in that stack frame. A stack_level of 1
is the function calling , 2 is the function above that,
and so forth.

Warning categories must be subclasses of ;
is a subclass of ;
the default warning category is . The standard
Python warning categories are available as global variables whose names are
enumerated at .

For information about warning control, see the documentation for the
module and the option in the command line
documentation. There is no C API for warning control.

* ( *exception,  *msg,  *name,  *path)

Return value: Always NULL.

Much like but this function allows for
specifying a subclass of to raise.

New in version 3.6.

int ( *category,  *message,  *filename, int lineno,  *module,  *registry)

Issue a warning message with explicit control over all warning attributes. This
is a straightforward wrapper around the Python function
, see there for more information. The module
and registry arguments may be set to to get the default effect
described there.

New in version 3.4.

int ( *category, const char *message, const char *filename, int lineno, const char *module,  *registry)

Similar to except that message and
module are UTF-8 encoded strings, and filename is decoded from the
filesystem encoding ().

int ( *category, Py_ssize_t stack_level, const char *format, …)

Function similar to , but use
to format the warning message. format is
an ASCII-encoded string.

New in version 3.2.

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

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

• SystemExit – возникает при выходе из программы с помощью sys.exit;
• KeyboardInterrupt – указывает на прерывание программы пользователем;
• GeneratorExit – появляется при вызове метода close для объекта generator;
• Exception – представляет совокупность обычных несистемных исключений.

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

Название	Характеристика
ArithmeticError	Порождается арифметическими ошибками (операции с плавающей точкой, переполнение числовой переменной, деление на ноль)
AssertionError	Возникает при ложном выражении в функции assert
AttributeError	Появляется в случаях, когда нужный атрибут объекта отсутствует
BufferError	Указывает на невозможность выполнения буферной операции
EOFError	Проявляется, когда функция не смогла прочитать конец файла
ImportError	Сообщает о неудачном импорте модуля либо атрибута
LookupError	Информирует про недействительный индекс или ключ в массиве
MemoryError	Возникает в ситуации, когда доступной памяти недостаточно
NameError	Указывает на ошибку при поиске переменной с нужным именем
NotImplementedError	Предупреждает о том, что абстрактные методы класса должны быть обязательно переопределены в классах-наследниках
OSError	Включает в себя системные ошибки (отсутствие доступа к нужному файлу или директории, проблемы с поиском процессов)
ReferenceError	Порождается попыткой доступа к атрибуту со слабой ссылкой
RuntimeError	Сообщает об исключении, которое не классифицируется
StopIteration	Возникает во время работы функции next при отсутствии элементов
SyntaxError	Представляет собой совокупность синтаксических ошибок
SystemError	Порождается внутренними ошибками системы
TypeError	Указывает на то, что операция не может быть выполнена с объектом
UnicodeError	Сообщает о неправильной кодировке символов в программе
ValueError	Возникает при получении некорректного значения для переменной
Warning	Обозначает предупреждение

Exceptions in Python

Python has many built-in exceptions that are raised when your program encounters an error (something in the program goes wrong).

When these exceptions occur, the Python interpreter stops the current process and passes it to the calling process until it is handled. If not handled, the program will crash.

For example, let us consider a program where we have a function that calls function , which in turn calls function . If an exception occurs in function but is not handled in , the exception passes to and then to .

If never handled, an error message is displayed and our program comes to a sudden unexpected halt.

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

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

Посмотрите на следующий пример, который запрашивает у пользователя ввод до тех пор, пока он не введет допустимое целое число, но позволяет пользователю прервать программу (с помощью Control-C или того, что поддерживает конкретная операционная система); обратите внимание, что сгенерированное пользователем прерывание возникает как исключение KeyboardInterrupt (docs.python.org/3/library/exceptions.html#KeyboardInterrupt) (клавиатурное прерывание)

Оператор try (docs.python.org/3/reference/compound_stmts.html#try) работает следующим образом.

• Сначала выполняется блок try (выражение(я) между ключевыми словами try (docs.python.org/3/reference/compound_stmts.html#try) и except (docs.python.org/3/reference/compound_stmts.html#except)).
• Если исключение не произошло, блок except пропускается и выполнение оператора try закончено.
• Если во время выполнения содержимого try возникает исключение, выражения ниже пропускаются. Затем, если тип возникшего исключения соответствует имени исключения после ключевого слова except, содержимое except выполняется, и затем выполнение продолжается после всего оператора try.
• Если происходит исключение, которое не соответствует имени исключения в строке except, оно передается на внешний оператор try; если обработчик не найден, то исключение становится необработанным и выполнение останавливается с сообщением, как показано выше.

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

Класс в блоке except совместим с исключением, если он является таким же классом или базовым классом такового (но не наоборот — блок except, перечисляющий производный класс, несовместим с базовым классом). Например, следующий код выведет B, C, D:

Заметьте, что если бы блоки исключений шли в обратном порядке (первым ), то было бы выведено B, B, B, так как сработало бы первое сопоставление блока except.

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

Используйте эту возможность с особой осторожностью, так как таким образом легко замаскировать действительные ошибки программирования! Такой вариант также может быть использован для вывода сообщения об ошибке, и затем повторной генерации исключения (позволяет вызывающему также обработать исключение):. Оператор try ..

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

Оператор try … except имеет еще опциональную ветку else, которая если присутствует, должны следовать после всех веток except. Это полезно для кода, который должен быть выполнен, если в ветке try не возникло никакого исключения. Например:

Использование ветки else лучше, чем добавление дополнительного кода в try, потому что помогает избежать случайного перехвата исключения, которое не было сгенерировано кодом, находящимся под «защитой» оператора try … except.

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

В ветке except после имени исключения можно указать переменную. Переменная привязана к экземпляру исключения с аргументами хранящимися в . Для удобства экземпляр исключения определяет __str__() (docs.python.org/3/reference/datamodel.html#object.__str__), так что аргументы можно вывести сразу, без того, чтобы ссылаться на . Также возможно проиллюстрировать (instantiate) исключение прежде, чем сгенерировать его и добавлять какие-либо атрибуты, как пожелаете.

Если у исключения есть аргументы, они выводятся как последняя часть (‘detail’ — подробность) сообщения для необработанных исключений.

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

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.

Ignored by the default warning filters, except in the module
(PEP 565). Enabling the shows
this warning.

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.

Ignored by the default warning filters. Enabling the shows this warning.

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.

Ignored by the default warning filters. Enabling the shows this warning.

exception

Base class for warnings related to Unicode.

exception

Base class for warnings related to and .

Traceback Examples¶

This simple example implements a basic read-eval-print loop, similar to (but
less useful than) the standard Python interactive interpreter loop. For a more
complete implementation of the interpreter loop, refer to the
module.

import sys, traceback

def run_user_code(envdir):
    source = input(">>> ")
    try
        exec(source, envdir)
    except Exception
        print("Exception in user code:")
        print("-"*60)
        traceback.print_exc(file=sys.stdout)
        print("-"*60)

envdir = {}
while True
    run_user_code(envdir)

The following example demonstrates the different ways to print and format the
exception and traceback:

import sys, traceback

def lumberjack():
    bright_side_of_death()

def bright_side_of_death():
    return tuple())
    print(formatted_lines-1])
    print("*** format_exception:")
    # exc_type below is ignored on 3.5 and later
    print(repr(traceback.format_exception(exc_type, exc_value,
                                          exc_traceback)))
    print("*** extract_tb:")
    print(repr(traceback.extract_tb(exc_traceback)))
    print("*** format_tb:")
    print(repr(traceback.format_tb(exc_traceback)))
    print("*** tb_lineno:", exc_traceback.tb_lineno)

The output for the example would look similar to this:

*** print_tb:
  File "<doctest...>", line 10, in <module>
    lumberjack()
*** print_exception:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_death()
IndexError: tuple index out of range
*** print_exc:
Traceback (most recent call last):
  File "<doctest...>", line 10, in <module>
    lumberjack()
  File "<doctest...>", line 4, in lumberjack
    bright_side_of_death()
IndexError: tuple index out of range
*** format_exc, first and last line:
Traceback (most recent call last):
IndexError: tuple index out of range
*** format_exception:
\n',
 'IndexError: tuple index out of range\n']
*** extract_tb:

*** format_tb:
\n']
*** tb_lineno: 10

The following example shows the different ways to print and format the stack:

>>> import traceback
>>> def another_function():
...     lumberstack()
...
>>> def lumberstack():
...     traceback.print_stack()
...     print(repr(traceback.extract_stack()))
...     print(repr(traceback.format_stack()))
...
>>> another_function()
  File "<doctest>", line 10, in <module>
    another_function()
  File "<doctest>", line 3, in another_function
    lumberstack()
  File "<doctest>", line 6, in lumberstack
    traceback.print_stack()

This last example demonstrates the final few formatting functions:

>>> import traceback
>>> traceback.format_list()

>>> an_error = IndexError('tuple index out of range')
>>> traceback.format_exception_only(type(an_error), an_error)

8.6. User-defined Exceptions¶

Programs may name their own exceptions by creating a new exception class (see
for more about Python classes). Exceptions should typically
be derived from the class, either directly or indirectly.

Exception classes can be defined which do anything any other class can do, but
are usually kept simple, often only offering a number of attributes that allow
information about the error to be extracted by handlers for the exception. When
creating a module that can raise several distinct errors, a common practice is
to create a base class for exceptions defined by that module, and subclass that
to create specific exception classes for different error conditions:

class Error(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(Error):
    """Exception raised for errors in the input.

    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.

    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """

    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

Most exceptions are defined with names that end in “Error”, similar to the
naming of the standard exceptions.