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

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

simple_stmt ::=  expression_stmt
                 | assert_stmt
                 | assignment_stmt
                 | augmented_assignment_stmt
                 | annotated_assignment_stmt
                 | pass_stmt
                 | del_stmt
                 | return_stmt
                 | yield_stmt
                 | raise_stmt
                 | break_stmt
                 | continue_stmt
                 | import_stmt
                 | future_stmt
                 | global_stmt
                 | nonlocal_stmt

7.1. Выражение инструкции

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

expression_stmt ::=  starred_expression

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

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

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

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

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

(См. в разделе Праймериз для определения синтаксиса attributeref и slicing subscription.

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

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

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

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

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

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

    • Если имя отсутствует в global или nonlocal инструкция в текущем блоке код: имя привязано к объекту в текущем пространстве имен локальная.
    • В противном случае имя привязывается к объекту в глобальном пространстве имен или внешнему пространству имен, определяемому nonlocal соответственно.

    Имя отскакивает, если оно уже было привязано. Это может привести к тому, что счетчик ссылок для объекта, ранее привязанного к имени, достигнет нуля, что приведет к отмене распределения объекта и вызову его деструктора (если он его имеет).

  • Если цель является ссылкой на атрибут, вычисляется основное выражение в ссылке. Он должен давать объект с присваиваемыми атрибутами; если это не так, TypeError поднимается. Затем этому объекту предлагается назначить назначенный объект данному атрибуту; если он не может выполнить назначение, он вызывает исключение (обычно, но не обязательно AttributeError).

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

    class Cls:
        x = 3             # class variable
    inst = Cls()
    inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
    

    Это описание не обязательно относится к дескрипторным признакам, таким как свойства, созданные с property().

  • Если целевой объект является подпиской, вычисляется основное выражение в ссылке. Он должен давать либо объект изменяемой последовательности (например, список), либо объект сопоставления (например, словарь). Затем вычисляется выражение нижнего индекса.

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

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

    Для определенных пользователями объектов __setitem__() метод называют с соответствующими аргументами.

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

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

Хотя определение назначения подразумевает, что наложения между левой стороной и правой стороной „одновременны“ (например, a, b = b, a обменивает две переменные), within наложений, коллекция назначенных - к переменным происходит слева направо, иногда приводя к беспорядку. Например, следующая программа печатает [0, 2]:

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)

См.также

PEP 3132 - расширенная итерабельная распаковка
Спецификация для функции *target.

7.2.1. Расширенные инструкции присваивания

Дополненное назначение - это комбинация в одном операторе двоичной операции и оператора назначения:

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

(Определения синтаксиса последних трех символов см. в разделе Праймериз.

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

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

В отличие от обычных назначений, дополненные назначения вычисляют левую сторону before оценивая правую сторону. Например, a[i] += f(x) сначала ищет a[i], затем оценивает f(x) и выполняет добавление, и, наконец, записывает результат обратно в a[i].

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

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

7.2.2. Аннотируемые операторы присваивания

Назначение аннотации - комбинация, в единственном заявлении, переменной или аннотации признака и дополнительного назначения statement:

annotated_assignment_stmt ::=  augtarget ":" expression
                               ["=" (starred_expression | yield_expression)]

Различие от нормального Инструкции присваивания - то, что только единая цель позволена.

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

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

Если имя аннотируется в объеме функции, то это имя - локальная для этого область видимости. Аннотации никогда не вычисляются и не сохраняются в функции области видимости.

Если присутствует правая сторона, аннотированное назначение выполняет фактическое назначение перед оценкой аннотаций (где применимо). Если правая сторона отсутствует для цели выражения, то интерпретатор вычисляет цель, за исключением последнего вызова __setitem__() или __setattr__().

См.также

PEP 526 - Синтаксис для аннотаций переменных
предложение, в котором добавлен синтаксис для аннотирования типов переменных (включая переменные класс и переменные сущность), вместо их выражения в комментариях.
PEP 484 - Подсказки типа
Предложение, добавившее модуль typing для предоставления стандартного синтаксиса для аннотаций типов, которые могут быть используемый в инструментах статического анализа и IDE.

Изменено в версии 3.8: Теперь аннотированные назначения позволяют использовать те же выражения в правой части, что и регулярные назначения. Ранее некоторые выражения (например, выражения кортежа без скобок) вызывали синтаксическую ошибку.

7.3. Инструкция assert

Assert инструкции - удобный способ вставить утверждения отладки в программу:

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

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

if __debug__:
    if not expression: raise AssertionError

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

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

Эти эквивалентности предполагают, что __debug__ и AssertionError относятся к встроенным переменным с этими именами. В текущем внедрении встроенный переменный __debug__ - True при нормальных обстоятельствах, False, когда оптимизацию запрошенный (параметр командной строки -O). Текущий код генератор испускает № код для утверждения инструкция, когда оптимизацию запрошенный во время компиляции. Обратите внимание, что нет необходимости включать исходный код для выражения, которое не удалось включить в сообщение об ошибке; он будет отображаться как часть трассировки стека.

Назначения __debug__ недопустимы. Значение встроенной переменной определяется при запуске интерпретатор.

7.4. Инструкция pass

pass_stmt ::=  "pass"

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

def f(arg): pass    # a function that does nothing (yet)

class C: pass       # a class with no methods (yet)

7.5. Инструкция del

del_stmt ::=  "del" target_list

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

Удаление целевого списка рекурсивно удаляет каждый целевой объект слева направо.

Удаление имени удаляет биндинг того имени от локальная или глобального пространства имен, в зависимости от того, происходит ли имя в global инструкция в том же блоке код. Если имя не привязано, возникает исключение NameError.

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

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

7.6. Инструкция return

return_stmt ::=  "return" [expression_list]

return может иметь место только в синтаксически вложенном виде в определении функции, а не во вложенном определении класс.

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

return оставляет текущий вызов функции со списком выражений (или None) в качестве возвращаемого значения.

Когда return передает управление из try инструкция с предложением finally, это предложение finally выполняется перед тем, как действительно покинуть функцию.

В функции генератор return инструкция указывает, что генератор сделан и заставит StopIteration быть поднятым. Возвращенная стоимость (если таковые имеются) является используемый как аргументом, чтобы построить StopIteration и становится признаком StopIteration.value.

В асинхронной функции генератор пустое return инструкция указывает на то, что асинхронное генератор выполнено и вызовет появление StopAsyncIteration. Непустой return инструкция - синтаксическая ошибка в асинхронной функции генератор.

7.7. Инструкция yield

yield_stmt ::=  yield_expression

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

yield <expr>
yield from <expr>

эквивалентны выражению выхода инструкции:

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

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

Для полного изложения семантики yield обратитесь к разделу Выражение Yield.

7.8. Инструкция raise

raise_stmt ::=  "raise" [expression ["from" expression]]

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

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

type исключения - класс экземпляра исключения, value - сам сущность.

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

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

Пункт from - используемый для объединения в цепочку исключения: если дали, второй expression должен быть другим исключением класс или случай, который будет тогда присоединен к поднятому исключению, поскольку __cause__ приписывают (который перезаписываем). Если вызванное исключение не обрабатывается, будут напечатаны оба исключения:

>>> try:
...     print(1 / 0)
... except Exception as exc:
...     raise RuntimeError("Something bad happened") from exc
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ZeroDivisionError: division by zero

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

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

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

>>> try:
...     print(1 / 0)
... except:
...     raise RuntimeError("Something bad happened")
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

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

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

>>> try:
...     print(1 / 0)
... except:
...     raise RuntimeError("Something bad happened") from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened

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

Изменено в версии 3.3: None теперь разрешено как Y в raise X from Y.

Добавлено в версии 3.3: Атрибут __suppress_context__ для подавления автоматического отображения исключения контекст.

7.9. Инструкция break

break_stmt ::=  "break"

break может быть только синтаксически вложен в цикл for или while, но не вложен в функцию или определение класс внутри этого цикла.

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

Если петля for закончена break, цель контроля за петлей держит свою текущую стоимость.

Когда break передает управление из try инструкция с предложением finally, это предложение finally выполняется перед тем, как действительно выйти из цикла.

7.10. Инструкция continue

continue_stmt ::=  "continue"

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

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

7.11. Инструкция import

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

Основной импорт инструкция (не клаузула from) выполнен в двух steps:

  1. найти модуль, загрузить и инициализировать его при необходимости
  2. определите имя или имена в пространстве имен локальная для область видимости, где происходит import инструкция.

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

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

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

  • Если за именем модуля следует имя as, то имя, следующее за именем as, привязывается непосредственно к импортированному модулю.
  • Если другое имя не указано, а импортируемый модуль является модулем верхнего уровня, имя модуля связано в пространстве имен локальная как ссылка на импортированный модуль
  • если импортируемый модуль является not модуль высшего уровня, затем имя пакета верхнего уровня, содержащего модуль, связывается в пространстве имен локальная как ссылка на пакет верхнего уровня. К импортированному модулю необходимо обращаться с полным именем, а не напрямую

Форма from использует несколько более сложный процесс:

  1. найдите модуль, указанный в предложении from, загрузив и инициализируя его при необходимости;
  2. для каждого из идентификаторов, указанных в import предложениях:
    1. проверьте, имеет ли импортированный модуль атрибут по этому имени.
    2. если нет, попробуйте импортировать подмодуль с таким именем, а затем снова проверьте импортированный модуль на наличие этого атрибута.
    3. если атрибут не найден, ImportError поднимается.
    4. в противном случае ссылка на это значение сохраняется в пространстве имен локальная с использованием имени в предложении as, если оно присутствует, в противном случае с использованием имени атрибута

Примеры:

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

Если список идентификаторов заменен звездой ('*'), все имена public, определенные в модуле, привязываются в пространстве имен локальная для область видимости, где происходит import инструкция.

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

Подстановочная форма импорта — from module import * — разрешена только на уровне модуля. Попытка использовать его в определениях класс или функций вызовет SyntaxError.

При указании модуля для импорта не требуется указывать абсолютное имя модуля. Когда модуль или пакет содержится в другом пакете, можно выполнить относительный импорт в том же самом верхнем пакете без указания имени пакета. Используя начальные точки в указанном модуле или пакете после from, можно указать, насколько высоко проходить по текущей иерархии пакета без указания точных имен. Одна ведущая точка означает текущий пакет, в котором существует модуль, выполняющий импорт. Две точки означают один уровень упаковки. Три точки вверх два уровня и т.д. Таким образом, если вы выполняете from . import mod из модуля в пакете pkg, вы закончите импорт pkg.mod. Если вы выполните from ..subpkg2 import mod из pkg.subpkg1, то вы импортируете pkg.subpkg2.mod. Спецификация относительного импорта содержится в разделе Импорт относительно пакета.

importlib.import_module() предоставляется для поддержки приложений, которые динамически определяют загружаемые модули.

Raises an auditing event import with arguments module, filename, sys.path, sys.meta_path, sys.path_hooks.

7.11.1. Инструкции футуры

future statement - это директива компилятору о том, что конкретный модуль должен быть скомпилирован с использованием синтаксиса или семантики, которые будут доступны в указанном будущем выпуске Python, где функция становится стандартной.

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

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

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

  • модуль докстринг (при наличии),
  • комментарии,
  • пустые строки и
  • другие футуры инструкции.

Единственная функция в Python 3.7, требующая использования будущего инструкция - annotations.

Все исторические возможности будущего инструкция по-прежнему распознаются Python 3. В список включены absolute_import, division, generators, generator_stop, unicode_literals, print_function, nested_scopes и with_statement. Все они являются избыточными, поскольку они всегда включены и поддерживаются только для обратной совместимости.

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

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

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

Интересная семантика во время выполнения зависит от определенной опции, активированной будущим инструкция.

Отметим, что ничего особенного в заявлении нет:

import __future__ [as name]

Это не будущее Инструкция; это - обычный импорт инструкция без специальной семантики или ограничений синтаксиса.

Код, скомпилированный вызовами встроенных функций exec() и compile(), которые происходят в модуле M, содержащем будущий инструкция, по умолчанию будет использовать новый синтаксис или семантику, связанную с будущим инструкция. Этим могут управлять дополнительные аргументы compile() —, см. документацию той функции для деталей.

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

См.также

PEP 236 - Вернуться к __future__
Первоначальное предложение по механизму __future__.

7.12. Инструкция global

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

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

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

Имена, перечисленные в global инструкция, не должны быть определены как формальные параметры или в целевом элементе управления for цикла, определении class, определении функции, операторе import или аннотации переменной.

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

Примечание программиста: global является директивой для парсер.
Это сгибает только к код, разобранному в то же время, что и global инструкция. n особый, global инструкция, содержавшийся в строка или код bject, поставляемом встроенной функции exec(), не затрагивает замок код containing вызов функции, и код, содержавшийся в таком строка, является naffected global инструкции в код, содержащем функцию все. То же самое относится к функциям eval() и compile().

7.13. Инструкция nonlocal

nonlocal_stmt ::=  "nonlocal" identifier ("," identifier)*

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

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

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

См.также

PEP 3104 - доступ к именам во внешней области видимости
Спецификация для nonlocal инструкции.