Исключения

5. Ключевое слово raise в Python

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

Разберемся на примере операции деления:

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

Что будет, если то же самое добавить в блоки try-except? Добавим следующее в код. Если запустить его, ввести 1 и 0, будет следующий вывод:

Рассмотрим еще несколько примеров, прежде чем двигаться дальше:

a. Raise без определенного исключения в Python

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

b. Raise с аргументом в Python

Также можно указать аргумент к определенному исключению в . Делается это с помощью дополнительных деталей исключения.

Ошибки и исключения

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

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

>>> 1a = 10
File "<stdin>", line 1
1a = 10
^
SyntaxError: invalid syntax

В терминологии языка Python здесь возникло исключение, принадлежащее классу SyntaxError. Согласно документации Python синтаксические ошибки все-таки принято относить к ошибкам, а все остальные – к исключениям. В некоторых языках программирования не используется слово «исключение», а ошибки делят на синтаксические и семантические. Нарушение семантики обычно означает, что, хотя выражения написаны верно с точки зрения синтаксиса языка, программа не работает так, как от нее ожидалось. Для сравнения. Вы можете грамотным русским языком сказать несколько предложений, но по смыслу это будет белиберда, или вас поймут не так, как хотелось бы.

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

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

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

Последнюю строку сообщения можно перевести как «Ошибка имени: имя ‘b’ не определено».

Если исключение возникает при выполнении кода из файла, то вместо «line 1» будет указана строка, в которой оно возникло, например, «line 24». Вместо «<stdin>» будет указано имя файла, например, «test.py». В данном же случае обозначает стандартный поток ввода. По-умолчанию это поток ввода с клавиатуры. Строка 1 – потому что в интерактивном режиме каждое выражение интерпретируется отдельно, как обособленная программка. Если написать выражение, состоящее из нескольких строк, то линия возникновения ошибки может быть другой:

>>> a = 0
>>> if a == 0:
...    print(a)
...    print(a + b)
...
0
Traceback (most recent call last):
File "<stdin>", line 3, in <module>
NameError: name 'b' is not defined

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

>>> int("Hi")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() 
with base 10: 'Hi'
>>> 8 + "3"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) 
for +: 'int' and 'str'

В примере строку «Hi» нельзя преобразовать к целому числу. Возникает исключение ValueError, потому что функция int() не может преобразовать такое значение.

Число 8 и строка «3» принадлежат разным типам, операнд сложения между которыми не поддерживается. При попытке их сложить возникает исключение TypeError.

Деление на ноль вызывает исключение ZeroDivisionError:

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

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

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

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

RLock Objects¶

A reentrant lock is a synchronization primitive that may be acquired multiple
times by the same thread. Internally, it uses the concepts of “owning thread”
and “recursion level” in addition to the locked/unlocked state used by primitive
locks. In the locked state, some thread owns the lock; in the unlocked state,
no thread owns it.

To lock the lock, a thread calls its method; this
returns once the thread owns the lock. To unlock the lock, a thread calls
its method. /
call pairs may be nested; only the final (the
of the outermost pair) resets the lock to unlocked and
allows another thread blocked in to proceed.

Reentrant locks also support the .

Lock Objects¶

A primitive lock is a synchronization primitive that is not owned by a
particular thread when locked. In Python, it is currently the lowest level
synchronization primitive available, implemented directly by the
extension module.

A primitive lock is in one of two states, “locked” or “unlocked”. It is created
in the unlocked state. It has two basic methods, and
. When the state is unlocked,
changes the state to locked and returns immediately. When the state is locked,
blocks until a call to in another
thread changes it to unlocked, then the call resets it
to locked and returns. The method should only be
called in the locked state; it changes the state to unlocked and returns
immediately. If an attempt is made to release an unlocked lock, a
will be raised.

Locks also support the .

When more than one thread is blocked in waiting for the
state to turn to unlocked, only one thread proceeds when a
call resets the state to unlocked; which one of the waiting threads proceeds
is not defined, and may vary across implementations.

All methods are executed atomically.

7.3. The assert statement¶

Assert statements are a convenient way to insert debugging assertions into a
program:

assert_stmt ::=  "assert"  

The simple form, , is equivalent to

if __debug__
    if not expression raise AssertionError

The extended form, , is equivalent to

if __debug__
    if not expression1 raise AssertionError(expression2)

These equivalences assume that and refer to
the built-in variables with those names. In the current implementation, the
built-in variable is under normal circumstances,
when optimization is requested (command line option ). The current
code generator emits no code for an assert statement when optimization is
requested at compile time. Note that it is unnecessary to include the source
code for the expression that failed in the error message; it will be displayed
as part of the stack trace.

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

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

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

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

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

try:
   # do something
   pass

except ValueError:
   # handle ValueError exception
   pass

except (TypeError, ZeroDivisionError):
   # handle multiple exceptions
   # TypeError and ZeroDivisionError
   pass

except:
   # handle all other exceptions
   pass

8.2. Исключения

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

В последней строке сообщения об ошибке указывается, что произошло. Исключения бывают разных типов, тип выводится как часть сообщения: типами в примере являются ZeroDivisionError (docs.python.org/3/library/exceptions.html#ZeroDivisionError), NameError (docs.python.org/3/library/exceptions.html#NameError) и TypeError (docs.python.org/3/library/exceptions.html#TypeError). Название случившегося исключения выводится как название типа встроенного исключения. Это верно для всех встроенных исключений, но не обязательно для пользовательских исключений (хотя это полезное соглашение). Имена стандартных исключений представляют собой встроенные идентификаторы (не зарезервированные ключевые слова).

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

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

Встроенные исключения (docs.python.org/3/library/exceptions.html#bltin-exceptions) перечисляет встроенные исключения и их значения.

Примеры использования менеджеров контекста:

@contextmanager
def locked(lock):
    lock.acquire()
    try
        yield
    finally
        lock.release()

Использование:

with locked(myLock):
    # Здесь код выполняется с удержанным myLock. 
    # lock.release() гарантированно будет выполнен, когда блок
    # будет завершен (даже по необработанному исключению).

Шаблон для открытия файла, который обеспечивает закрытие файла при завершении блока:

@contextmanager
def opened(filename, mode="r"):
    f = open(filename, mode)
    try
        yield f
    finally
        f.close()

Использование:

with opened("/etc/passwd") as f
    for line in f
        print line.rstrip()

Временно перенаправить стандартный вывод для однопоточных программ:

@contextmanager
def stdout_redirected(new_stdout):
    save_stdout = sys.stdout
    sys.stdout = new_stdout
    try
        yield None
    finally
        sys.stdout = save_stdout

Использование:

with opened(filename, "w") as f
    with stdout_redirected(f):
        print "Hello world"

Вариант с функцией , который также возвращает условие ошибки:

@contextmanager
def opened_w_error(filename, mode="r"):
    try
        f = open(filename, mode)
    except IOError, err
        yield None, err
    else
        try
            yield f, None
        finally
            f.close()

Использование:

Exception Objects¶

* ( *ex)

Return value: New reference.

Return the traceback associated with the exception as a new reference, as
accessible from Python through . If there is no
traceback associated, this returns .

int ( *ex,  *tb)

Set the traceback associated with the exception to tb. Use to
clear it.

* ( *ex)

Return value: New reference.

Return the context (another exception instance during whose handling ex was
raised) associated with the exception as a new reference, as accessible from
Python through . If there is no context associated, this
returns .

void ( *ex,  *ctx)

Set the context associated with the exception to ctx. Use to clear
it. There is no type check to make sure that ctx is an exception instance.
This steals a reference to ctx.

* ( *ex)

Return value: New reference.

Return the cause (either an exception instance, or ,
set by ) associated with the exception as a new
reference, as accessible from Python through .

1 Без глобальных и локальных параметров

В предыдущем примере мы просто выполнили некоторый набор инструкций в Python, передав аргумент объекта методу . Но мы не видели имена в текущей области.

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

from math import *

exec("print(pow(2, 5))")

exec("print(dir())")

Выход:

32.0

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

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

Упрощенное создание менеджеров контекста.

Поддержка упрощенного создания менеджеров контекста предоставляется модулем .

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

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

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

3. Блоки try/except

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Barrier Objects¶

New in version 3.2.

This class provides a simple synchronization primitive for use by a fixed number
of threads that need to wait for each other. Each of the threads tries to pass
the barrier by calling the method and will block until
all of the threads have made their calls. At this point,
the threads are released simultaneously.

The barrier can be reused any number of times for the same number of threads.

As an example, here is a simple way to synchronize a client and server thread:

b = Barrier(2, timeout=5)

def server():
    start_server()
    b.wait()
    while True
        connection = accept_connection()
        process_server_connection(connection)

def client():
    b.wait()
    while True
        connection = make_connection()
        process_client_connection(connection)

class (parties, action=None, timeout=None)

Create a barrier object for parties number of threads. An action, when
provided, is a callable to be called by one of the threads when they are
released. timeout is the default timeout value if none is specified for
the method.

(timeout=None)

Pass the barrier. When all the threads party to the barrier have called
this function, they are all released simultaneously. If a timeout is
provided, it is used in preference to any that was supplied to the class
constructor.

The return value is an integer in the range 0 to parties – 1, different
for each thread. This can be used to select a thread to do some special
housekeeping, e.g.:

i = barrier.wait()
if i == 
    # Only one thread needs to print this
    print("passed the barrier")

If an action was provided to the constructor, one of the threads will
have called it prior to being released. Should this call raise an error,
the barrier is put into the broken state.

If the call times out, the barrier is put into the broken state.

This method may raise a exception if the
barrier is broken or reset while a thread is waiting.

()

Return the barrier to the default, empty state. Any threads waiting on it
will receive the exception.

Note that using this function may require some external
synchronization if there are other threads whose state is unknown. If a
barrier is broken it may be better to just leave it and create a new one.

()

Put the barrier into a broken state. This causes any active or future
calls to to fail with the . Use
this for example if one of the threads needs to abort, to avoid deadlocking the
application.

It may be preferable to simply create the barrier with a sensible
timeout value to automatically guard against one of the threads going
awry.

The number of threads required to pass the barrier.

The number of threads currently waiting in the barrier.

A boolean that is if the barrier is in the broken state.

7.7. The yield statement¶

yield_stmt ::=  

A statement is semantically equivalent to a . The yield statement can be used to omit the parentheses
that would otherwise be required in the equivalent yield expression
statement. For example, the yield statements

yield <expr>
yield from <expr>

are equivalent to the yield expression statements

(yield <expr>)
(yield from <expr>)

Yield expressions and statements are only used when defining a
function, and are only used in the body of the generator function. Using yield
in a function definition is sufficient to cause that definition to create a
generator function instead of a normal function.

Содержимое ответа

Мы можем читать содержимое ответа сервера. Рассмотрим тайм-лайн GitHub снова:

>>> import requests
>>> r = requests.get('https://api.github.com/events') 
>>> r.text 
u'[{"repository":{"open_issues":0,"url":"https://github.com/...

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

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

>>> r.encoding
'utf-8' 
>>> r.encoding = 'ISO-8859-1' 

Если вы измените кодировку, Requests будет использовать новое значение всякий раз, когда вы будете использовать . Вы можете сделать это в любой ситуации, где нужна более специализированная логика работы с кодировкой содержимого ответа. Например, в HTML и XML есть возможность задавать кодировку прямо в теле документа. В подобных ситуациях вы должны использовать , чтобы найти кодировку, а затем установить . Это позволит вам использовать с правильной кодировкой.

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

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. Например:

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting

Unicode Exception Objects¶

The following functions are used to create and modify Unicode exceptions from C.

* (const char *encoding, const char *object, Py_ssize_t length, Py_ssize_t start, Py_ssize_t end, const char *reason)

Return value: New reference.

Create a object with the attributes encoding,
object, length, start, end and reason. encoding and reason are
UTF-8 encoded strings.

* (const char *encoding, const  *object, Py_ssize_t length, Py_ssize_t start, Py_ssize_t end, const char *reason)

Return value: New reference.

Create a object with the attributes encoding,
object, length, start, end and reason. encoding and reason are
UTF-8 encoded strings.

Deprecated since version 3.3: 3.11

is deprecated since Python 3.3. Please migrate to
.

* (const  *object, Py_ssize_t length, Py_ssize_t start, Py_ssize_t end, const char *reason)

Return value: New reference.

Create a object with the attributes object,
length, start, end and reason. reason is a UTF-8 encoded string.

Deprecated since version 3.3: 3.11

is deprecated since Python 3.3. Please migrate to
.

* ( *exc)

* ( *exc)

Return value: New reference.

Return the encoding attribute of the given exception object.

* ( *exc)

* ( *exc)

* ( *exc)

Return value: New reference.

Return the object attribute of the given exception object.

int ( *exc, Py_ssize_t *start)

int ( *exc, Py_ssize_t *start)

int ( *exc, Py_ssize_t *start)

Get the start attribute of the given exception object and place it into
*start. start must not be . Return on success, on
failure.

int ( *exc, Py_ssize_t start)

int ( *exc, Py_ssize_t start)

int ( *exc, Py_ssize_t start)

Set the start attribute of the given exception object to start. Return
on success, on failure.

int ( *exc, Py_ssize_t *end)

int ( *exc, Py_ssize_t *end)

int ( *exc, Py_ssize_t *end)

Get the end attribute of the given exception object and place it into
*end. end must not be . Return on success, on
failure.

int ( *exc, Py_ssize_t end)

int ( *exc, Py_ssize_t end)

int ( *exc, Py_ssize_t end)

Set the end attribute of the given exception object to end. Return
on success, on failure.

* ( *exc)

* ( *exc)

* ( *exc)

Return value: New reference.

Return the reason attribute of the given exception object.

Summing Up

After seeing the difference between syntax errors and exceptions, you learned about various ways to raise, catch, and handle exceptions in Python. In this article, you saw the following options:

• allows you to throw an exception at any time.
• enables you to verify if a certain condition is met and throw an exception if it isn’t.
• In the clause, all statements are executed until an exception is encountered.
• is used to catch and handle the exception(s) that are encountered in the try clause.
• lets you code sections that should run only when no exceptions are encountered in the try clause.
• enables you to execute sections of code that should always run, with or without any previously encountered exceptions.

Free PDF Download: Python 3 Cheat Sheet

8.5. 예외 연쇄¶

The statement allows an optional which enables
chaining exceptions. For example:

# exc must be exception instance or None.
raise RuntimeError from exc

이것은 예외를 변환할 때 유용할 수 있습니다. 예를 들면:

>>> def func():
...     raise IOError
...
>>> try
...     func()
... except IOError as exc
...     raise RuntimeError('Failed to open database') from exc
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "<stdin>", line 2, in func
OSError

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

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Failed to open database

Exception chaining happens automatically when an exception is raised inside an
or section. Exception chaining can be
disabled by using idiom:

>>> try
...     open('database.sqlite')
... except IOError
...     raise RuntimeError from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError

7.11. The import statement¶

import_stmt     ::=  "import"   (","  )*
                     | "from"  "import"  
                     (","  )*
                     | "from"  "import" "("  
                     (","  )*  ")"
                     | "from"  "import" "*"
module          ::=  ( ".")* 
relative_module ::=  "."*  | "."+

The basic import statement (no clause) is executed in two
steps:

1. find a module, loading and initializing it if necessary

2. define a name or names in the local namespace for the scope where
   the statement occurs.

When the statement contains multiple clauses (separated by
commas) the two steps are carried out separately for each clause, just
as though the clauses had been separated out into individual import
statements.

The details of the first step, finding and loading modules are described in
greater detail in the section on the ,
which also describes the various types of packages and modules that can
be imported, as well as all the hooks that can be used to customize
the import system. Note that failures in this step may indicate either
that the module could not be located, or that an error occurred while
initializing the module, which includes execution of the module’s code.

If the requested module is retrieved successfully, it will be made
available in the local namespace in one of three ways:

• If the module name is followed by , then the name
  following is bound directly to the imported module.

• If no other name is specified, and the module being imported is a top
  level module, the module’s name is bound in the local namespace as a
  reference to the imported module

• If the module being imported is not a top level module, then the name
  of the top level package that contains the module is bound in the local
  namespace as a reference to the top level package. The imported module
  must be accessed using its full qualified name rather than directly

The form uses a slightly more complex process:

1. find the module specified in the clause, loading and
   initializing it if necessary;

2. for each of the identifiers specified in the clauses:

   1. check if the imported module has an attribute by that name

   2. if not, attempt to import a submodule with that name and then
      check the imported module again for that attribute

   3. if the attribute is not found, is raised.

   4. otherwise, a reference to that value is stored in the local namespace,
      using the name in the clause if it is present,
      otherwise using the attribute name

Examples:

import foo                 # foo imported and bound locally
import foo.bar.baz         # foo.bar.baz imported, foo bound locally
import foo.bar.baz as fbb  # foo.bar.baz imported and bound as fbb
from foo.bar import baz    # foo.bar.baz imported and bound as baz
from foo import attr       # foo imported and foo.attr bound as attr

If the list of identifiers is replaced by a star (), all public
names defined in the module are bound in the local namespace for the scope
where the statement occurs.

The public names defined by a module are determined by checking the module’s
namespace for a variable named ; if defined, it must be a sequence
of strings which are names defined or imported by that module. The names
given in are all considered public and are required to exist. If
is not defined, the set of public names includes all names found
in the module’s namespace which do not begin with an underscore character
(). should contain the entire public API. It is intended
to avoid accidentally exporting items that are not part of the API (such as
library modules which were imported and used within the module).

The wild card form of import — — is only allowed at
the module level. Attempting to use it in class or function definitions will
raise a .

When specifying what module to import you do not have to specify the absolute
name of the module. When a module or package is contained within another
package it is possible to make a relative import within the same top package
without having to mention the package name. By using leading dots in the
specified module or package after you can specify how high to
traverse up the current package hierarchy without specifying exact names. One
leading dot means the current package where the module making the import
exists. Two dots means up one package level. Three dots is up two levels, etc.
So if you execute from a module in the package
then you will end up importing . If you execute from within you will import .
The specification for relative imports is contained in
the section.

is provided to support applications that
determine dynamically the modules to be loaded.

Raises an with arguments , , , , .