> **Источник:** https://python-all.ru/2.7/reference/simple_stmts.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# 6. Простые инструкции

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

```

simple_stmt ::=  expression_stmt
                 | assert_stmt
                 | assignment_stmt
                 | augmented_assignment_stmt
                 | pass_stmt
                 | del_stmt
                 | print_stmt
                 | return_stmt
                 | yield_stmt
                 | raise_stmt
                 | break_stmt
                 | continue_stmt
                 | import_stmt
                 | future_stmt
                 | global_stmt
                 | exec_stmt
```

## 6.1. Инструкции-выражения

Выражения-инструкции используются (в основном в интерактивном режиме) для вычисления и записи значения, или (обычно) для вызова процедуры (функции, не возвращающей значимого результата; в Python процедуры возвращают значение `None`). Другие способы использования выражений-инструкций допускаются и иногда полезны. Синтаксис выражения-инструкции таков:

```

expression_stmt ::=  expression_list
```

Инструкция-выражение вычисляет список выражений (который может быть одиночным выражением).

В интерактивном режиме, если значение не равно `None`, оно преобразуется в строку с помощью встроенной функции [`repr()`](https://python-all.ru/2.7/library/functions.html#repr) и результирующая строка записывается в стандартный вывод (см. раздел [Инструкция print](https://python-all.ru/2.7/reference/simple_stmts.html#print)) на отдельной строке. (Инструкции-выражения, возвращающие `None`, не записываются, поэтому вызовы процедур не вызывают вывода.)

## 6.2. Инструкции присваивания

Инструкции присваивания используются для (пере)привязки имён к значениям и изменения атрибутов или элементов изменяемых объектов:

```

assignment_stmt ::=  (target_list "=")+ (expression_list | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" target_list ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
```

(См. раздел [Primaries](https://python-all.ru/2.7/reference/expressions.html#primaries) для определения синтаксиса последних трёх символов.)

Инструкция присваивания вычисляет список выражений (помните, что это может быть одно выражение или список, разделённый запятыми, последний даёт кортеж) и присваивает единственный результирующий объект каждому из списков целей, слева направо.

Присваивание определяется рекурсивно в зависимости от формы цели (списка). Если цель является частью изменяемого объекта (ссылка на атрибут, подписка или срез), этот изменяемый объект должен в конечном итоге выполнить присваивание и решить, допустимо ли оно, и может возбудить исключение, если присваивание неприемлемо. Правила, соблюдаемые различными типами, и возбуждаемые исключения приведены в описании типов объектов (см. раздел [Стандартная иерархия типов](https://python-all.ru/2.7/reference/datamodel.html#types)).

Присваивание объекта списку целей рекурсивно определяется следующим образом.

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

Присваивание объекта одной цели рекурсивно определяется следующим образом.

- Если цель является идентификатором (именем):

  >

  - Если имя не встречается в инструкции [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global) в текущем блоке кода: имя связывается с объектом в текущем локальном пространстве имён.
  - В противном случае: имя связывается с объектом в текущем глобальном пространстве имён.

  Если имя уже было связано, оно переназначается. Это может привести к тому, что счётчик ссылок на объект, ранее связанный с этим именем, обнулится, что вызовет освобождение объекта и вызов его деструктора (если он есть).
- Если цель представляет собой список целей, заключённый в круглые или квадратные скобки: объект должен быть итерабельным объектом с тем же количеством элементов, что и целей в списке целей, и его элементы присваиваются слева направо соответствующим целям.
- Если цель является ссылкой на атрибут: вычисляется первичное выражение в ссылке. Оно должно давать объект с назначаемыми атрибутами; если это не так, возбуждается [`TypeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.TypeError). Затем этому объекту предлагается присвоить заданный объект указанному атрибуту; если он не может выполнить присваивание, он возбуждает исключение (обычно, но не обязательно [`AttributeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.AttributeError)).

  Примечание: Если объект является экземпляром класса и обращение к атрибуту происходит по обе стороны от оператора присваивания, то выражение в правой части `a.x` может получить доступ как к атрибуту экземпляра, так и (если атрибут экземпляра отсутствует) к атрибуту класса. Цель в левой части `a.x` всегда устанавливается как атрибут экземпляра, создавая его при необходимости. Таким образом, два вхождения `a.x` не обязательно ссылаются на один и тот же атрибут: если выражение в правой части ссылается на атрибут класса, левая часть создаёт новый атрибут экземпляра в качестве цели присваивания:

  ```python
  class Cls:
      x = 3             # переменная класса
  inst = Cls()
  inst.x = inst.x + 1   # записывает inst.x как 4, оставляя Cls.x равным 3
  ```

  Это описание не обязательно применимо к атрибутам-дескрипторам, таким как свойства, созданные с помощью [`property()`](https://python-all.ru/2.7/library/functions.html#property).
- Если целью является индексация: вычисляется первичное выражение в ссылке. Оно должно возвращать либо изменяемый объект-последовательность (например, список), либо объект-отображение (например, словарь). Затем вычисляется выражение индекса.

  Если первичное выражение является изменяемым объектом-последовательностью (например, список), индекс должен быть обычным целым числом. Если он отрицательный, к нему прибавляется длина последовательности. Результирующее значение должно быть неотрицательным целым, меньшим длины последовательности, и последовательность запрашивается для присваивания указанного объекта её элементу с этим индексом. Если индекс выходит за пределы, возникает [`IndexError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.IndexError) (присваивание индексированной последовательности не может добавить новые элементы в список).

  Если первичный объект является отображением (например, словарём), то индекс должен иметь тип, совместимый с типом ключа отображения, и отображению предлагается создать пару ключ/значение, которая сопоставляет индекс с присваиваемым объектом. Это может либо заменить существующую пару ключ/значение с тем же значением ключа, либо вставить новую пару ключ/значение (если ключа с таким значением не существовало).
- Если целью является срез: вычисляется первичное выражение в ссылке. Оно должно возвращать изменяемый объект-последовательность (например, список). Присваиваемый объект должен быть объектом-последовательностью того же типа. Затем вычисляются выражения нижней и верхней границы, если они присутствуют; по умолчанию используются ноль и длина последовательности. Границы должны вычисляться в (малые) целые числа. Если любая из границ отрицательна, к ней прибавляется длина последовательности. Полученные границы усекаются до диапазона от нуля до длины последовательности включительно. Наконец, объект-последовательность запрашивается для замены среза элементами присваиваемой последовательности. Длина среза может отличаться от длины присваиваемой последовательности, тем самым изменяя длину целевой последовательности, если объект это допускает.

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

ПРЕДУПРЕЖДЕНИЕ: Хотя определение присваивания подразумевает, что перекрытия между левой и правой частью «безопасны» (например, `a, b = b, a` меняет местами две переменные), перекрытия *внутри* набора присваиваемых переменных небезопасны! Например, следующая программа выводит `[0, 2]`:

```python
x = [0, 1]
i = 0
i, x[i] = 1, 2
print x
```

### 6.2.1. Составные операторы присваивания

Составное присваивание – это объединение в одном операторе бинарной операции и оператора присваивания:

```

augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="
```

(См. раздел [Primaries](https://python-all.ru/2.7/reference/expressions.html#primaries) для определения синтаксиса последних трёх символов.)

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

Выражение с составным присваиванием, такое как `x += 1`, можно переписать как `x = x + 1`, чтобы добиться похожего, но не полностью идентичного эффекта. В версии с составным присваиванием `x` вычисляется только один раз. Кроме того, когда это возможно, сама операция выполняется *на месте*, то есть вместо создания нового объекта и присваивания его цели изменяется старый объект.

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

Для целей, являющихся ссылками на атрибуты, действует то же [предостережение относительно атрибутов класса и экземпляра](https://python-all.ru/2.7/reference/simple_stmts.html#attr-target-note), что и для обычных присваиваний.

## 6.3. Инструкция [`assert`](https://python-all.ru/2.7/reference/simple_stmts.html#assert)

Операторы assert – это удобный способ вставить отладочные утверждения в программу:

```

assert_stmt ::=  "assert" expression ["," expression]
```

Простая форма, `assert expression`, эквивалентна

```python
if __debug__:
    if not expression: raise AssertionError
```

Расширенная форма, `assert expression1, expression2`, эквивалентна

```python
if __debug__:
    if not expression1: raise AssertionError(expression2)
```

Эти эквивалентности предполагают, что [`__debug__`](https://python-all.ru/2.7/library/constants.html#__debug__) и [`AssertionError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.AssertionError) ссылаются на встроенные переменные с этими именами. В текущей реализации встроенная переменная [`__debug__`](https://python-all.ru/2.7/library/constants.html#__debug__) равна `True` при обычных обстоятельствах и `False` при запросе оптимизации (параметр командной строки -O). Текущий генератор кода не создаёт код для инструкции assert, если оптимизация запрошена во время компиляции. Обратите внимание, что нет необходимости включать исходный код выражения, которое не удалось выполнить, в сообщение об ошибке; оно будет отображено как часть трассировки стека.

Присваивания [`__debug__`](https://python-all.ru/2.7/library/constants.html#__debug__) запрещены. Значение встроенной переменной определяется при запуске интерпретатора.

## 6.4. Инструкция [`pass`](https://python-all.ru/2.7/reference/simple_stmts.html#pass)

```

pass_stmt ::=  "pass"
```

[`pass`](https://python-all.ru/2.7/reference/simple_stmts.html#pass) – пустая операция; при её выполнении ничего не происходит. Она полезна в качестве заполнителя, когда синтаксически требуется оператор, но выполнять код не нужно, например:

```python
def f(arg): pass    # функция, которая пока ничего не делает

class C: pass       # класс без методов (пока)
```

## 6.5. Инструкция [`del`](https://python-all.ru/2.7/reference/simple_stmts.html#del)

```

del_stmt ::=  "del" target_list
```

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

Удаление списка целей рекурсивно удаляет каждую цель слева направо.

Удаление имени удаляет привязку этого имени из локального или глобального пространства имён в зависимости от того, встречается ли имя в инструкции [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global) в том же блоке кода. Если имя не связано, будет возбуждено исключение [`NameError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.NameError).

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

Удаление ссылок на атрибуты, подписок и срезов передаётся соответствующему первичному объекту; удаление среза в общем случае эквивалентно присваиванию пустого среза правильного типа (но даже это определяется объектом, из которого берётся срез).

## 6.6. Инструкция [`print`](https://python-all.ru/2.7/reference/simple_stmts.html#print)

```

print_stmt ::=  "print" ([expression ("," expression)* [","]]
                | ">>" expression [("," expression)+ [","]])
```

[`print`](https://python-all.ru/2.7/reference/simple_stmts.html#print) вычисляет каждое выражение по очереди и записывает полученный объект в стандартный вывод (см. ниже). Если объект не является строкой, он сначала преобразуется в строку по правилам преобразования строк. Затем записывается (полученная или исходная) строка. Пробел записывается перед каждым объектом (после преобразования) до его записи, если только система вывода не считает, что находится в начале строки. Это происходит, когда (1) в стандартный вывод ещё не было записано ни одного символа, (2) последним записанным в стандартный вывод символом является пробельный символ, кроме `' '`, или (3) последняя операция записи в стандартный вывод не была инструкцией [`print`](https://python-all.ru/2.7/reference/simple_stmts.html#print). (В некоторых случаях может быть функционально записать пустую строку в стандартный вывод по этой причине.)

> **Примечание**
>
> Объекты, которые ведут себя как файловые объекты, но не являются встроенными файловыми объектами, часто не полностью эмулируют этот аспект поведения файлового объекта, поэтому лучше на это не полагаться.

Символ `'\n'` записывается в конце, если только инструкция [`print`](https://python-all.ru/2.7/reference/simple_stmts.html#print) не заканчивается запятой. Это единственное действие, если инструкция содержит только ключевое слово [`print`](https://python-all.ru/2.7/reference/simple_stmts.html#print).

Стандартный вывод определяется как файловый объект с именем `stdout` во встроенном модуле [`sys`](https://python-all.ru/2.7/library/sys.html#module-sys). Если такого объекта не существует или у него нет метода `write()`, возбуждается исключение [`RuntimeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.RuntimeError).

[`print`](https://python-all.ru/2.7/reference/simple_stmts.html#print) также имеет расширенную форму, определяемую второй частью синтаксиса, описанного выше. Эта форма иногда называется «[`print`](https://python-all.ru/2.7/reference/simple_stmts.html#print) chevron». В этой форме первое выражение после `>>` должно вычисляться в «файлоподобный» объект, а именно объект, имеющий метод `write()`, как описано выше. С помощью этой расширенной формы последующие выражения выводятся в этот файловый объект. Если первое выражение вычисляется в `None`, то в качестве файла для вывода используется `sys.stdout`.

## 6.7. Инструкция [`return`](https://python-all.ru/2.7/reference/simple_stmts.html#return)

```

return_stmt ::=  "return" [expression_list]
```

[`return`](https://python-all.ru/2.7/reference/simple_stmts.html#return) может синтаксически встречаться только внутри определения функции, а не внутри определения вложенного класса.

Если указан список выражений, он вычисляется, иначе подставляется `None`.

[`return`](https://python-all.ru/2.7/reference/simple_stmts.html#return) завершает текущий вызов функции, возвращая список выражений (или `None`).

Когда [`return`](https://python-all.ru/2.7/reference/simple_stmts.html#return) передаёт управление из оператора [`try`](https://python-all.ru/2.7/reference/compound_stmts.html#try) с предложением [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally), это предложение [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally) выполняется перед фактическим выходом из функции.

В генераторной функции инструкция [`return`](https://python-all.ru/2.7/reference/simple_stmts.html#return) не может содержать [`expression_list`](https://python-all.ru/2.7/reference/expressions.html#grammar-token-expression-list). В этом контексте пустой [`return`](https://python-all.ru/2.7/reference/simple_stmts.html#return) указывает, что генератор завершён, и вызовет возбуждение [`StopIteration`](https://python-all.ru/2.7/library/exceptions.html#exceptions.StopIteration).

## 6.8. Инструкция [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield)

```

yield_stmt ::=  yield_expression
```

Инструкция [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) используется только при определении генераторной функции и только в теле генераторной функции. Использование инструкции [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) в определении функции достаточно, чтобы это определение создало генераторную функцию вместо обычной функции.

Когда генераторная функция вызывается, она возвращает итератор, известный как генераторный итератор или, чаще, просто генератор. Тело генераторной функции выполняется путём многократного вызова метода [`next()`](https://python-all.ru/2.7/reference/expressions.html#generator.next) генератора до тех пор, пока не будет возбуждено исключение.

Когда выполняется инструкция [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield), состояние генератора замораживается, и значение [`expression_list`](https://python-all.ru/2.7/reference/expressions.html#grammar-token-expression-list) возвращается вызывающему [`next()`](https://python-all.ru/2.7/reference/expressions.html#generator.next). Под «замораживанием» понимается сохранение всего локального состояния, включая текущие привязки локальных переменных, указатель инструкции и внутренний стек вычислений: сохраняется достаточно информации, чтобы при следующем вызове [`next()`](https://python-all.ru/2.7/reference/expressions.html#generator.next) функция могла продолжить выполнение точно так, как если бы инструкция [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) была просто ещё одним внешним вызовом.

Начиная с версии Python 2.5, инструкция [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) теперь допускается в предложении [`try`](https://python-all.ru/2.7/reference/compound_stmts.html#try) конструкции [`try`](https://python-all.ru/2.7/reference/compound_stmts.html#try) … [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally). Если генератор не возобновлён до его финализации (достижением нулевого счётчика ссылок или сборкой мусора), будет вызван метод `close()` генератор-итератора, позволяя выполнить все ожидающие предложения [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally).

Полные сведения о семантике [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) см. в разделе [Выражения yield](https://python-all.ru/2.7/reference/expressions.html#yieldexpr).

> **Примечание**
>
> В Python 2.2 инструкция [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) допускалась только при включённой возможности `generators`. Для включения этой возможности использовалась инструкция import `__future__`:
>
> ```python
> from __future__ import generators
> ```

> **См. также**
>
> **[**PEP 255**](https://python-all.ru/2.7/reference/simple_stmts.html) - Simple Generators**
>
> Предложение по добавлению генераторов и оператора [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) в Python.
>
> **[**PEP 342**](https://python-all.ru/2.7/reference/simple_stmts.html) - Coroutines via Enhanced Generators**
>
> Предложение, которое среди прочих улучшений генераторов предлагало разрешить появление [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) внутри блока [`try`](https://python-all.ru/2.7/reference/compound_stmts.html#try) … [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally).

## 6.9. Инструкция [`raise`](https://python-all.ru/2.7/reference/simple_stmts.html#raise)

```

raise_stmt ::=  "raise" [expression ["," expression ["," expression]]]
```

Если выражения отсутствуют, [`raise`](https://python-all.ru/2.7/reference/simple_stmts.html#raise) повторно возбуждает последнее исключение, которое было активно в текущей области видимости. Если в текущей области видимости нет активного исключения, возбуждается исключение [`TypeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.TypeError), указывающее на ошибку (при работе под IDLE вместо этого возбуждается исключение [`Queue.Empty`](https://python-all.ru/2.7/library/queue.html#Queue.Empty)).

В противном случае [`raise`](https://python-all.ru/2.7/reference/simple_stmts.html#raise) вычисляет выражения для получения трёх объектов, используя `None` в качестве значения пропущенных выражений. Первые два объекта используются для определения *типа* и *значения* исключения.

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

Если первый объект является классом, он становится типом исключения. Второй объект используется для определения значения исключения: если он является экземпляром этого класса, то экземпляр становится значением исключения. Если второй объект – кортеж, он используется как список аргументов для конструктора класса; если он равен `None`, используется пустой список аргументов, а любой другой объект рассматривается как одиночный аргумент конструктора. Экземпляр, созданный таким образом вызовом конструктора, используется как значение исключения.

Если присутствует третий объект и он не равен `None`, он должен быть объектом traceback (см. раздел [Стандартная иерархия типов](https://python-all.ru/2.7/reference/datamodel.html#types)), и он подставляется вместо текущего местоположения как место, где произошло исключение. Если третий объект присутствует и не является объектом traceback или `None`, возбуждается исключение [`TypeError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.TypeError). Форма [`raise`](https://python-all.ru/2.7/reference/simple_stmts.html#raise) с тремя выражениями полезна для прозрачного повторного возбуждения исключения в предложении except, но [`raise`](https://python-all.ru/2.7/reference/simple_stmts.html#raise) без выражений следует предпочитать, если повторно возбуждаемое исключение было последним активным исключением в текущей области видимости.

Дополнительную информацию об исключениях можно найти в разделе [Исключения](https://python-all.ru/2.7/reference/executionmodel.html#exceptions), а информацию об обработке исключений – в разделе [Оператор try](https://python-all.ru/2.7/reference/compound_stmts.html#try).

## 6.10. Инструкция [`break`](https://python-all.ru/2.7/reference/simple_stmts.html#break)

```

break_stmt ::=  "break"
```

[`break`](https://python-all.ru/2.7/reference/simple_stmts.html#break) может синтаксически находиться только внутри цикла [`for`](https://python-all.ru/2.7/reference/compound_stmts.html#for) или [`while`](https://python-all.ru/2.7/reference/compound_stmts.html#while), но не внутри определения функции или класса в этом цикле.

Он завершает ближайший охватывающий цикл, пропуская необязательное предложение [`else`](https://python-all.ru/2.7/reference/compound_stmts.html#else), если оно есть в цикле.

Если цикл [`for`](https://python-all.ru/2.7/reference/compound_stmts.html#for) завершается оператором [`break`](https://python-all.ru/2.7/reference/simple_stmts.html#break), то целевая переменная цикла сохраняет своё текущее значение.

Когда [`break`](https://python-all.ru/2.7/reference/simple_stmts.html#break) передаёт управление из оператора [`try`](https://python-all.ru/2.7/reference/compound_stmts.html#try) с предложением [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally), это предложение [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally) выполняется перед фактическим выходом из цикла.

## 6.11. Инструкция [`continue`](https://python-all.ru/2.7/reference/simple_stmts.html#continue)

```

continue_stmt ::=  "continue"
```

[`continue`](https://python-all.ru/2.7/reference/simple_stmts.html#continue) может встречаться только синтаксически вложенным в цикл [`for`](https://python-all.ru/2.7/reference/compound_stmts.html#for) или [`while`](https://python-all.ru/2.7/reference/compound_stmts.html#while), но не вложенным в определение функции или класса или предложение [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally) внутри этого цикла. Она продолжается со следующим витком ближайшего внешнего цикла.

Когда [`continue`](https://python-all.ru/2.7/reference/simple_stmts.html#continue) передаёт управление из оператора [`try`](https://python-all.ru/2.7/reference/compound_stmts.html#try) с предложением [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally), это предложение [`finally`](https://python-all.ru/2.7/reference/compound_stmts.html#finally) выполняется перед фактическим началом следующей итерации цикла.

## 6.12. Инструкция [`import`](https://python-all.ru/2.7/reference/simple_stmts.html#import)

```

import_stmt     ::=  "import" module ["as" name] ( "," module ["as" name] )*
                     | "from" relative_module "import" identifier ["as" name]
                     ( "," identifier ["as" name] )*
                     | "from" relative_module "import" "(" identifier ["as" name]
                     ( "," identifier ["as" name] )* [","] ")"
                     | "from" module "import" "*"
module          ::=  (identifier ".")* identifier
relative_module ::=  "."* module | "."+
name            ::=  identifier
```

Инструкции import выполняются в два шага: (1) найти модуль и инициализировать его при необходимости; (2) определить имя или имена в локальном пространстве имён (той области видимости, где встречается инструкция [`import`](https://python-all.ru/2.7/reference/simple_stmts.html#import)). Инструкция существует в двух формах, различающихся использованием ключевого слова [`from`](https://python-all.ru/2.7/reference/simple_stmts.html#from). Первая форма (без [`from`](https://python-all.ru/2.7/reference/simple_stmts.html#from)) повторяет эти шаги для каждого идентификатора в списке. Форма с [`from`](https://python-all.ru/2.7/reference/simple_stmts.html#from) выполняет шаг (1) один раз, а затем повторяет шаг (2) для каждого имени.

Чтобы понять, как выполняется шаг (1), необходимо сначала понять, как Python работает с иерархическими именами модулей. Для организации модулей и обеспечения иерархии в именовании Python вводит понятие пакетов. Пакет может содержать другие пакеты и модули, в то время как модули не могут содержать другие модули или пакеты. С точки зрения файловой системы пакеты – это каталоги, а модули – файлы.

После того как имя модуля известно (если не указано иное, термин «модуль» будет относиться как к пакетам, так и к модулям), можно начинать поиск модуля или пакета. Первым проверяется [`sys.modules`](https://python-all.ru/2.7/library/sys.html#sys.modules) – кэш всех ранее импортированных модулей. Если модуль найден там, то он используется на шаге (2) импорта.

Если модуль не найден в кэше, то выполняется поиск в [`sys.meta_path`](https://python-all.ru/2.7/library/sys.html#sys.meta_path) (спецификацию [`sys.meta_path`](https://python-all.ru/2.7/library/sys.html#sys.meta_path) можно найти в [**PEP 302**](https://python-all.ru/2.7/reference/simple_stmts.html)). Этот объект представляет собой список объектов [finder](https://python-all.ru/2.7/glossary.html#term-finder) (поисковиков), которые опрашиваются по порядку: знают ли они, как загрузить модуль, путём вызова их метода `find_module()` с именем модуля. Если модуль находится внутри пакета (что обозначается наличием точки в имени), то второй аргумент `find_module()` задаётся как значение атрибута `__path__` родительского пакета (всё до последней точки в имени импортируемого модуля). Если поисковик может найти модуль, он возвращает [загрузчик (loader)](https://python-all.ru/2.7/glossary.html#term-loader) (обсуждается далее) или возвращает `None`.

Если ни один из искателей на [`sys.meta_path`](https://python-all.ru/2.7/library/sys.html#sys.meta_path) не может найти модуль, то запрашиваются некоторые неявно определённые искатели. Реализации Python различаются тем, какие неявные мета-искатели путей определены. Однако все они определяют искатель, который обрабатывает [`sys.path_hooks`](https://python-all.ru/2.7/library/sys.html#sys.path_hooks), [`sys.path_importer_cache`](https://python-all.ru/2.7/library/sys.html#sys.path_importer_cache) и [`sys.path`](https://python-all.ru/2.7/library/sys.html#sys.path).

Неявный искатель ищет запрошенный модуль в «путях», заданных в одном из двух мест (пути не обязательно являются путями файловой системы). Если импортируемый модуль должен находиться внутри пакета, то в качестве источника путей используется второй аргумент, переданный в `find_module()`, `__path__` родительского пакета. Если модуль не находится в пакете, то в качестве источника путей используется [`sys.path`](https://python-all.ru/2.7/library/sys.html#sys.path).

Когда источник путей выбран, он перебирается для поиска искателя, который может обработать этот путь. Словарь по [`sys.path_importer_cache`](https://python-all.ru/2.7/library/sys.html#sys.path_importer_cache) кэширует искатели для путей, и проверяется наличие искателя. Если для пути нет кэшированного искателя, то [`sys.path_hooks`](https://python-all.ru/2.7/library/sys.html#sys.path_hooks) перебирается путём вызова каждого объекта из списка с единственным аргументом – путь; возвращается искатель или возбуждается [`ImportError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ImportError). Если искатель возвращён, он кэшируется в [`sys.path_importer_cache`](https://python-all.ru/2.7/library/sys.html#sys.path_importer_cache) и затем используется для этой записи пути. Если искатель не найден, но путь существует, то в [`sys.path_importer_cache`](https://python-all.ru/2.7/library/sys.html#sys.path_importer_cache) сохраняется значение `None`, означающее, что для данного пути следует использовать неявный искатель на основе файлов, который обрабатывает модули, хранящиеся как отдельные файлы. Если путь не существует, то в кэш для этого пути помещается искатель, который всегда возвращает `None`.

Если ни один искатель не может найти модуль, возбуждается [`ImportError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ImportError). В противном случае некоторый искатель возвращает загрузчик, чей метод `load_module()` вызывается с именем модуля для загрузки (см. [**PEP 302**](https://python-all.ru/2.7/reference/simple_stmts.html) для исходного определения загрузчиков). Загрузчик выполняет несколько обязанностей по отношению к загружаемому модулю. Во-первых, если модуль уже существует в [`sys.modules`](https://python-all.ru/2.7/library/sys.html#sys.modules) (что возможно, если загрузчик вызван вне механизма импорта), то для инициализации следует использовать этот модуль, а не новый. Но если модуль не существует в [`sys.modules`](https://python-all.ru/2.7/library/sys.html#sys.modules), то перед началом инициализации он должен быть добавлен в этот словарь. Если в процессе загрузки модуля произошла ошибка и он был добавлен в [`sys.modules`](https://python-all.ru/2.7/library/sys.html#sys.modules), его необходимо удалить из словаря. Если ошибка произошла, но модуль уже был в [`sys.modules`](https://python-all.ru/2.7/library/sys.html#sys.modules), он остаётся в словаре.

Загрузчик должен установить несколько атрибутов модуля. `__name__` должен быть установлен в имя модуля. `__file__` должен быть «путём» к файлу, если только модуль не встроенный (и, следовательно, указан в [`sys.builtin_module_names`](https://python-all.ru/2.7/library/sys.html#sys.builtin_module_names)), в этом случае атрибут не устанавливается. Если импортируется пакет, то `__path__` должен быть установлен в список путей, которые будут просматриваться при поиске модулей и пакетов, содержащихся внутри импортируемого пакета. `__package__` необязателен, но должен быть установлен в имя пакета, содержащего модуль или пакет (пустая строка используется для модуля, не содержащегося в пакете). `__loader__` также необязателен, но должен быть установлен в объект загрузчика, который загружает модуль.

Если во время загрузки происходит ошибка, загрузчик возбуждает [`ImportError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ImportError), если не распространяется какое-либо другое исключение. В противном случае загрузчик возвращает загруженный и инициализированный модуль.

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

Первая форма инструкции [`import`](https://python-all.ru/2.7/reference/simple_stmts.html#import) связывает имя модуля в локальном пространстве имён с объектом модуля, а затем переходит к импорту следующего идентификатора, если он есть. Если за именем модуля следует [`as`](https://python-all.ru/2.7/reference/compound_stmts.html#as), то имя после [`as`](https://python-all.ru/2.7/reference/compound_stmts.html#as) используется как локальное имя для модуля.

Форма [`from`](https://python-all.ru/2.7/reference/simple_stmts.html#from) не связывает имя модуля: она перебирает список идентификаторов, ищет каждый из них в модуле, найденном на шаге (1), и связывает имя в локальном пространстве имён с найденным объектом. Как и в первой форме [`import`](https://python-all.ru/2.7/reference/simple_stmts.html#import), можно указать альтернативное локальное имя, задав «[`as`](https://python-all.ru/2.7/reference/compound_stmts.html#as) localname». Если имя не найдено, возбуждается [`ImportError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.ImportError). Если список идентификаторов заменён звёздочкой (`'*'`), в локальном пространстве имён инструкции [`import`](https://python-all.ru/2.7/reference/simple_stmts.html#import) связываются все публичные имена, определённые в модуле.

*Публичные имена*, определённые модулем, определяются путём проверки пространства имён модуля на наличие переменной с именем `__all__`; если она определена, то должна быть последовательностью строк, которые являются именами, определёнными или импортированными этим модулем. Все имена, перечисленные в `__all__`, считаются публичными и должны существовать. Если `__all__` не определён, набор публичных имён включает все имена в пространстве имён модуля, которые не начинаются с символа подчёркивания (`'_'`). `__all__` должен содержать весь публичный API. Он предназначен для предотвращения случайного экспорта элементов, не являющихся частью API (таких как библиотечные модули, которые были импортированы и использованы внутри модуля).

Форма [`from`](https://python-all.ru/2.7/reference/simple_stmts.html#from) с `*` может встречаться только на уровне модуля. Если форма импорта со звёздочкой – `import *` – используется в функции, и функция содержит или является вложенным блоком со свободными переменными, компилятор возбудит [`SyntaxError`](https://python-all.ru/2.7/library/exceptions.html#exceptions.SyntaxError).

При указании, какой модуль импортировать, необязательно указывать абсолютное имя модуля. Если модуль или пакет содержится внутри другого пакета, можно сделать относительный импорт внутри того же самого верхнего пакета, не упоминая имя пакета. Используя ведущие точки в указанном модуле или пакете после [`from`](https://python-all.ru/2.7/reference/simple_stmts.html#from), можно указать, на сколько уровней подняться вверх по текущей иерархии пакетов, не задавая точных имён. Одна ведущая точка означает текущий пакет, в котором находится модуль, выполняющий импорт. Две точки – подняться на один уровень пакета вверх. Три точки – на два уровня вверх и т.д. Таким образом, если выполнить `from . import mod` из модуля в пакете `pkg`, то будет импортирован `pkg.mod`. Если выполнить `from ..subpkg2 import mod` из модуля `pkg.subpkg1`, то будет импортирован `pkg.subpkg2.mod`. Спецификация относительных импортов содержится в [**PEP 328**](https://python-all.ru/2.7/reference/simple_stmts.html).

[`importlib.import_module()`](https://python-all.ru/2.7/library/importlib.html#importlib.import_module) предоставляется для поддержки приложений, которые определяют, какие модули необходимо загружать динамически.

### 6.12.1. Future-операторы

*future statement* – это директива компилятору, указывающая, что конкретный модуль должен быть скомпилирован с использованием синтаксиса или семантики, которые будут доступны в определённом будущем выпуске Python. Инструкция future предназначена для облегчения перехода на будущие версии Python, вносящие несовместимые изменения в язык. Она позволяет использовать новые возможности на уровне отдельных модулей до выхода версии, в которой эта возможность станет стандартной.

```

future_statement ::=  "from" "__future__" "import" feature ["as" name]
                      ("," feature ["as" name])*
                      | "from" "__future__" "import" "(" feature ["as" name]
                      ("," feature ["as" name])* [","] ")"
feature          ::=  identifier
name             ::=  identifier
```

Инструкция future должна располагаться в начале модуля. До инструкции future могут находиться только:

- строка документации модуля (если есть),
- комментарии,
- пустые строки и
- другие инструкции future.

Возможности, распознаваемые Python 2.6: `unicode_literals`, `print_function`, `absolute_import`, `division`, `generators`, `nested_scopes` и `with_statement`. `generators`, `with_statement`, `nested_scopes` избыточны в Python версии 2.6 и выше, так как они всегда включены.

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

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

Непосредственная семантика времени выполнения такая же, как и для любой инструкции import: существует стандартный модуль [`__future__`](https://python-all.ru/2.7/library/__future__.html#module-__future__), описанный далее, и он будет импортирован обычным образом в момент выполнения инструкции future.

Интересная семантика времени выполнения зависит от конкретной возможности, включаемой инструкцией future.

Обратите внимание, что в этой инструкции нет ничего особенного:

```python
import __future__ [as name]
```

Это не инструкция future, а обычная инструкция import без особой семантики или синтаксических ограничений.

Код, скомпилированный инструкцией [`exec`](https://python-all.ru/2.7/reference/simple_stmts.html#exec) или вызовами встроенных функций [`compile()`](https://python-all.ru/2.7/library/functions.html#compile) и [`execfile()`](https://python-all.ru/2.7/library/functions.html#execfile), которые находятся в модуле `M`, содержащем future-инструкцию, по умолчанию будет использовать новый синтаксис или семантику, связанные с future-инструкцией. Начиная с Python 2.2 это можно контролировать с помощью необязательных аргументов [`compile()`](https://python-all.ru/2.7/library/functions.html#compile) – подробнее см. документацию этой функции.

Инструкция future, введённая в интерактивном приглашении интерпретатора, будет действовать до конца сеанса интерпретатора. Если интерпретатор запущен с опцией [`-i`](https://python-all.ru/2.7/using/cmdline.html#cmdoption-i), ему передано имя выполняемого скрипта, и скрипт содержит инструкцию future, то эта инструкция будет действовать в интерактивном сеансе, который запускается после выполнения скрипта.

> **См. также**
>
> **[**PEP 236**](https://python-all.ru/2.7/reference/simple_stmts.html) – Назад в \_\_future\_\_**
>
> Оригинальное предложение механизма \_\_future\_\_.

## 6.13. Инструкция [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global)

```

global_stmt ::=  "global" identifier ("," identifier)*
```

Инструкция [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global) – это объявление, которое действует на весь текущий блок кода. Она означает, что перечисленные идентификаторы должны интерпретироваться как глобальные. Невозможно было бы присвоить значение глобальной переменной без [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global), хотя свободные переменные могут ссылаться на глобальные, не будучи объявленными как global.

Имена, перечисленные в инструкции [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global), не должны использоваться в том же блоке кода текстуально перед этой инструкцией [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global).

Имена, перечисленные в инструкции [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global), не должны быть определены как формальные параметры или как цель управления цикла [`for`](https://python-all.ru/2.7/reference/compound_stmts.html#for), в определении [`class`](https://python-all.ru/2.7/reference/compound_stmts.html#class), определении функции или в инструкции [`import`](https://python-all.ru/2.7/reference/simple_stmts.html#import).

**CPython implementation detail:** Текущая реализация не применяет последние два ограничения, но программы не должны злоупотреблять этой свободой, поскольку будущие реализации могут начать их применять или незаметно изменить смысл программы.

**Примечание для программиста:** [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global) – это директива для парсера. Она применяется только к коду, который анализируется одновременно с инструкцией [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global). В частности, инструкция [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global), содержащаяся в инструкции [`exec`](https://python-all.ru/2.7/reference/simple_stmts.html#exec), не влияет на блок кода *, содержащий* инструкцию [`exec`](https://python-all.ru/2.7/reference/simple_stmts.html#exec), и код, содержащийся в инструкции [`exec`](https://python-all.ru/2.7/reference/simple_stmts.html#exec), не затрагивается инструкциями [`global`](https://python-all.ru/2.7/reference/simple_stmts.html#global) в коде, содержащем инструкцию [`exec`](https://python-all.ru/2.7/reference/simple_stmts.html#exec). То же самое относится к функциям [`eval()`](https://python-all.ru/2.7/library/functions.html#eval), [`execfile()`](https://python-all.ru/2.7/library/functions.html#execfile) и [`compile()`](https://python-all.ru/2.7/library/functions.html#compile).

## 6.14. Инструкция [`exec`](https://python-all.ru/2.7/reference/simple_stmts.html#exec)

```

exec_stmt ::=  "exec" or_expr ["in" expression ["," expression]]
```

Эта инструкция поддерживает динамическое выполнение кода Python. Первое выражение должно вычисляться в строку Unicode, строку в кодировке *Latin-1*, открытый файловый объект, объект кода или кортеж. Если это строка, она разбирается как набор инструкций Python, который затем выполняется (если не возникает синтаксическая ошибка). [1](https://python-all.ru/2.7/reference/simple_stmts.html#id3) Если это открытый файл, файл разбирается до конца и выполняется. Если это объект кода, он просто выполняется. О том, что означает кортеж, см. ниже. Во всех случаях ожидается, что выполняемый код является допустимым в качестве файлового ввода (см. раздел [File input](https://python-all.ru/2.7/reference/toplevel_components.html#file-input)). Имейте в виду, что инструкции [`return`](https://python-all.ru/2.7/reference/simple_stmts.html#return) и [`yield`](https://python-all.ru/2.7/reference/simple_stmts.html#yield) не могут использоваться вне определений функций, даже в контексте кода, переданного инструкции [`exec`](https://python-all.ru/2.7/reference/simple_stmts.html#exec).

Во всех случаях, если необязательные части опущены, код выполняется в текущей области видимости. Если указано только первое выражение после `in`, то это должен быть словарь, который будет использоваться как для глобальных, так и для локальных переменных. Если указаны два выражения, они используются соответственно для глобальных и локальных переменных. Если указано, *locals* может быть любым отображающим объектом. Помните, что на уровне модуля глобальные и локальные переменные – это один и тот же словарь. Если в качестве *globals* и *locals* указаны два отдельных объекта, код будет выполняться так, как если бы он был встроен в определение класса.

Первое выражение также может быть кортежем из 2 или 3 элементов. В этом случае необязательные части должны быть опущены. Форма `exec(expr, globals)` эквивалентна `exec expr in globals`, а форма `exec(expr, globals, locals)` эквивалентна `exec expr in globals, locals`. Кортежная форма `exec` обеспечивает совместимость с Python 3, где `exec` является функцией, а не инструкцией.

Изменено в версии 2.4: Ранее *locals* должен был быть словарём.

В качестве побочного эффекта реализация может вставлять в переданные словари дополнительные ключи, помимо тех, что соответствуют именам переменных, установленных выполняемым кодом. Например, текущая реализация может добавить ссылку на словарь встроенного модуля [`__builtin__`](https://python-all.ru/2.7/library/__builtin__.html#module-__builtin__) под ключом `__builtins__` (!).

**Советы программисту:** динамическое вычисление выражений поддерживается встроенной функцией [`eval()`](https://python-all.ru/2.7/library/functions.html#eval). Встроенные функции [`globals()`](https://python-all.ru/2.7/library/functions.html#globals) и [`locals()`](https://python-all.ru/2.7/library/functions.html#locals) возвращают текущий глобальный и локальный словари соответственно, что может быть полезно для передачи в [`exec`](https://python-all.ru/2.7/reference/simple_stmts.html#exec).

Сноски

**[1](https://python-all.ru/2.7/reference/simple_stmts.html#id2)**

Обратите внимание, что парсер принимает только соглашение о конце строки в стиле Unix. Если вы читаете код из файла, обязательно используйте режим [universal newlines](https://python-all.ru/2.7/glossary.html#term-universal-newlines) для преобразования перевода строк в стиле Windows или Mac.