Содержание страницы
6. Простые инструкции¶Simple statements
Простые инструкции размещаются в одной логической строке. Несколько простых инструкций могут находиться на одной строке, разделённые точкой с запятой. Синтаксис для простых инструкций:
simple_stmt ::= expression_stmt | assert_stmt | assignment_stmt | augmented_assignment_stmt | pass_stmt | del_stmt | return_stmt | yield_stmt | raise_stmt | break_stmt | continue_stmt | import_stmt | global_stmt | nonlocal_stmt
6.1. Инструкции-выражения¶Expression statements
Инструкции-выражения используются (в основном в интерактивном режиме) для вычисления и вывода значения или (обычно) для вызова процедуры (функции, которая не возвращает значимого результата; в Python процедуры возвращают значение None). Другие применения инструкций-выражений допустимы и иногда полезны. Синтаксис инструкции-выражения:
expression_stmt ::= expression_list
Инструкция-выражение вычисляет список выражений (который может быть одиночным выражением).
В интерактивном режиме, если значение не равно None, оно преобразуется в строку с помощью встроенной функции repr(), и полученная строка выводится на стандартный вывод на отдельной строке (за исключением случая, когда результат равен None, так что вызовы процедур не вызывают никакого вывода).
6.2. Инструкции присваивания¶Assignment statements
Инструкции присваивания используются для (пере)привязки имён к значениям и изменения атрибутов или элементов изменяемых объектов:
assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression) target_list ::= target ("," target)* [","] target ::= identifier | "(" target_list ")" | "[" target_list "]" | attributeref | subscription | slicing | "*" target
(См. раздел Primaries для определения синтаксиса последних трёх символов.)
Инструкция присваивания вычисляет список выражений (помните, что это может быть одно выражение или список, разделённый запятыми, последний даёт кортеж) и присваивает единственный результирующий объект каждому из списков целей, слева направо.
Присваивание определяется рекурсивно в зависимости от формы цели (списка). Если цель является частью изменяемого объекта (ссылка на атрибут, подписка или срез), этот изменяемый объект должен в конечном итоге выполнить присваивание и решить, допустимо ли оно, и может возбудить исключение, если присваивание неприемлемо. Правила, соблюдаемые различными типами, и возбуждаемые исключения приведены в описании типов объектов (см. раздел Стандартная иерархия типов).
Присваивание объекта списку целей, возможно заключённому в круглые или квадратные скобки, рекурсивно определяется следующим образом.
- Если список целей состоит из одной цели: объект присваивается этой цели.
- Если список целей представляет собой разделённый запятыми список целей: объект должен быть итерабельным объектом с тем же количеством элементов, что и целей в списке целей, и элементы присваиваются слева направо соответствующим целям.
- Если список целей содержит одну цель с префиксом-звёздочкой, называемую «звёздной» целью: объект должен быть последовательностью, содержащей как минимум столько же элементов, сколько целей в списке целей, минус один. Первые элементы последовательности присваиваются слева направо целям, находящимся перед звёздной целью. Последние элементы последовательности присваиваются целям, находящимся после звёздной цели. Затем список оставшихся элементов последовательности присваивается звёздной цели (список может быть пустым).
- Иначе: объект должен быть последовательностью с тем же количеством элементов, что и целей в списке целей, и элементы присваиваются слева направо соответствующим целям.
Присваивание объекта одной цели рекурсивно определяется следующим образом.
Если цель является идентификатором (именем):
- Если имя не встречается в инструкции global или nonlocal в текущем блоке кода: имя привязывается к объекту в текущем локальном пространстве имён.
- Иначе: имя привязывается к объекту в глобальном пространстве имён или во внешнем пространстве имён, определяемом инструкцией nonlocal, соответственно.
Имя перепривязывается, если оно уже было привязано. Это может привести к тому, что счётчик ссылок на объект, ранее привязанный к имени, достигнет нуля, что вызовет освобождение объекта и вызов его деструктора (если он есть).
Если цель представляет собой список целей, заключённый в круглые или квадратные скобки: объект должен быть итерабельным объектом с тем же количеством элементов, что и целей в списке целей, и его элементы присваиваются слева направо соответствующим целям.
Если цель является ссылкой на атрибут: вычисляется первичное выражение в ссылке. Оно должно дать объект с присваиваемыми атрибутами; если это не так, возбуждается TypeError. Затем этому объекту даётся указание присвоить присваиваемый объект данному атрибуту; если он не может выполнить присваивание, он возбуждает исключение (обычно, но не обязательно AttributeError).
Примечание: Если объект является экземпляром класса и ссылка на атрибут встречается по обе стороны оператора присваивания, выражение в правой части, a.x, может обращаться как к атрибуту экземпляра, так и (если атрибут экземпляра отсутствует) к атрибуту класса. Цель в левой части a.x всегда устанавливается как атрибут экземпляра, при необходимости создавая его. Таким образом, два вхождения a.x не обязательно ссылаются на один и тот же атрибут: если выражение в правой части ссылается на атрибут класса, левая часть создаёт новый атрибут экземпляра в качестве цели присваивания:
class Cls: x = 3 # переменная класса inst = Cls() inst.x = inst.x + 1 # записывает inst.x как 4, оставляя Cls.x равным 3
Это описание не обязательно применимо к атрибутам-дескрипторам, таким как свойства, созданные с помощью property().
Если цель – подписка: вычисляется первичное выражение в ссылке. Оно должно дать либо изменяемый последовательный объект (например, список), либо отображающий объект (например, словарь). Затем вычисляется выражение индекса.
Если первичным является изменяемый объект-последовательность (например, список), индекс должен давать целое число. Если он отрицательный, к нему добавляется длина последовательности. Результирующее значение должно быть неотрицательным целым числом, меньшим длины последовательности, и последовательности даётся указание присвоить присваиваемый объект её элементу с этим индексом. Если индекс выходит за пределы диапазона, возбуждается IndexError (присваивание индексированной последовательности не может добавить новые элементы в список).
Если первичный объект является отображением (например, словарём), то индекс должен иметь тип, совместимый с типом ключа отображения, и отображению предлагается создать пару ключ/значение, которая сопоставляет индекс с присваиваемым объектом. Это может либо заменить существующую пару ключ/значение с тем же значением ключа, либо вставить новую пару ключ/значение (если ключа с таким значением не существовало).
Для пользовательских объектов вызывается метод __setitem__() с соответствующими аргументами.
Если целью является срез: вычисляется первичное выражение в ссылке. Оно должно возвращать изменяемый последовательный объект (например, список). Присваиваемый объект должен быть последовательным объектом того же типа. Затем вычисляются выражения нижней и верхней границы, если они присутствуют; по умолчанию используются ноль и длина последовательности. Границы должны вычисляться как целые числа. Если какая-либо граница отрицательна, к ней прибавляется длина последовательности. Полученные границы обрезаются, чтобы находиться в диапазоне от нуля до длины последовательности включительно. Наконец, объект последовательности запрашивается на замену среза элементами присваиваемой последовательности. Длина среза может отличаться от длины присваиваемой последовательности, тем самым изменяя длину целевой последовательности, если объект это допускает.
Особенность реализации CPython: В текущей реализации синтаксис целей считается таким же, как для выражений, и недопустимый синтаксис отбрасывается на этапе генерации кода, что приводит к менее подробным сообщениям об ошибках.
ПРЕДУПРЕЖДЕНИЕ: Хотя определение присваивания подразумевает, что пересечения между левой и правой частью «безопасны» (например, a, b = b, a меняет местами две переменные), пересечения внутри набора переменных, которым присваивается, небезопасны! Например, следующая программа выводит [0, 2]:
x = [0, 1]
i = 0
i, x[i] = 1, 2
print(x)
См. также
- PEP 3132 - Расширенная распаковка итерируемых объектов
- Спецификация для возможности *target.
6.2.1. Составные инструкции присваивания¶Augmented assignment statements
Составное присваивание – это объединение в одном операторе бинарной операции и оператора присваивания:
augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression) augtarget ::= identifier | attributeref | subscription | slicing augop ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**=" | ">>=" | "<<=" | "&=" | "^=" | "|="
(См. раздел Primaries для определения синтаксиса последних трёх символов.)
Составное присваивание вычисляет цель (которая, в отличие от обычных операторов присваивания, не может быть распаковкой) и список выражений, выполняет бинарную операцию, соответствующую типу присваивания, над двумя операндами и присваивает результат исходной цели. Цель вычисляется только один раз.
Составное присваивание вида x += 1 можно переписать как x = x + 1, чтобы получить похожий, но не совсем эквивалентный эффект. В составном варианте x вычисляется только один раз. Кроме того, когда это возможно, сама операция выполняется на месте, то есть вместо создания нового объекта и присваивания его цели старый объект изменяется.
За исключением присваивания кортежам и нескольким целям в одном операторе, присваивание, выполняемое составными операторами присваивания, обрабатывается так же, как и обычные присваивания. Аналогично, за исключением возможного поведения на месте, бинарная операция, выполняемая составным присваиванием, совпадает с обычными бинарными операциями.
Для целей, являющихся ссылками на атрибуты, действует то же предостережение относительно атрибутов класса и экземпляра, что и для обычных присваиваний.
6.3. Инструкция assert¶The assert statement
Операторы 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). Текущий генератор кода не генерирует никакого кода для инструкции assert, если оптимизация запрошена во время компиляции. Обратите внимание, что нет необходимости включать исходный код выражения, которое не сработало, в сообщение об ошибке; он будет отображён как часть трассировки стека.
Присваивания __debug__ недопустимы. Значение встроенной переменной определяется при запуске интерпретатора.
6.4. Инструкция pass¶The pass statement
pass_stmt ::= "pass"
pass – это пустая операция: при её выполнении ничего не происходит. Она полезна в качестве заполнителя, когда синтаксически требуется инструкция, но никакой код выполнять не нужно, например:
def f(arg): pass # функция, которая пока ничего не делает
class C: pass # класс без методов (пока)
6.5. Инструкция del¶The del statement
del_stmt ::= "del" target_list
Удаление рекурсивно определяется очень похоже на то, как определяется присваивание. Вместо подробного изложения приведём несколько подсказок.
Удаление списка целей рекурсивно удаляет каждую цель слева направо.
Удаление имени удаляет привязку этого имени из локального или глобального пространства имён в зависимости от того, встречается ли имя в инструкции global в том же блоке кода. Если имя не привязано, будет возбуждено исключение NameError.
Удаление ссылок на атрибуты, подписок и срезов передаётся соответствующему первичному объекту; удаление среза в общем случае эквивалентно присваиванию пустого среза правильного типа (но даже это определяется объектом, из которого берётся срез).
Изменено в версии 3.2: Ранее было недопустимо удалять имя из локального пространства имён, если оно является свободной переменной во вложенном блоке.
6.6. Инструкция return¶The return statement
return_stmt ::= "return" [expression_list]
return может синтаксически встречаться только внутри определения функции, а не внутри вложенного определения класса.
Если список выражений присутствует, он вычисляется, иначе подставляется None.
return завершает текущий вызов функции, возвращая список выражений (или None) в качестве возвращаемого значения.
Когда return передаёт управление из инструкции try с блоком finally, этот блок finally выполняется перед тем, как функция действительно завершится.
В генераторной функции инструкция return не может содержать expression_list. В этом контексте пустой return означает, что генератор завершён, и будет вызвано исключение StopIteration.
6.7. Инструкция yield¶The yield statement
yield_stmt ::= yield_expression
Инструкция yield используется только при определении генераторной функции и только в её теле. Использование инструкции yield в определении функции достаточно, чтобы это определение создавало генераторную функцию, а не обычную. Когда генераторная функция вызывается, она возвращает итератор, известный как итератор генератора или, чаще, генератор. Тело генераторной функции выполняется путём многократного вызова функции next() на генераторе до тех пор, пока не будет вызвано исключение.
Когда выполняется инструкция yield, состояние генератора замораживается, и значение expression_list возвращается вызывающей стороне next(). Под «заморожено» подразумевается, что сохраняется всё локальное состояние, включая текущие привязки локальных переменных, указатель инструкции и внутренний стек вычислений: сохраняется достаточно информации, чтобы при следующем вызове next() функция могла продолжить выполнение так, как будто инструкция yield была просто очередным внешним вызовом.
Инструкция yield разрешена в блоке try конструкции try ... finally. Если генератор не будет возобновлён до его финализации (достижение нулевого счётчика ссылок или сборка мусора), будет вызван метод close() итератора генератора, что позволит выполнить незавершённые блоки finally.
6.8. Инструкция raise¶The raise statement
raise_stmt ::= "raise" [expression ["from" expression]]
Если выражения отсутствуют, raise повторно возбуждает последнее исключение, которое было активно в текущей области видимости. Если в текущей области нет активного исключения, возбуждается исключение RuntimeError, указывающее на ошибку.
В противном случае raise вычисляет первое выражение как объект исключения. Оно должно быть подклассом или экземпляром BaseException. Если это класс, экземпляр исключения будет получен при необходимости путём инстанцирования класса без аргументов.
Типом исключения является класс экземпляра исключения, значением – сам экземпляр.
Объект traceback обычно создаётся автоматически при возбуждении исключения и прикрепляется к нему как атрибут __traceback__, который доступен для записи. Можно создать исключение и установить свой собственный traceback за один шаг с помощью метода исключения with_traceback() (который возвращает тот же экземпляр исключения, установив его traceback равным аргументу), например:
raise Exception("foo occurred").with_traceback(tracebackobj)
Предложение from используется для связывания исключений: если оно указано, второе выражение должно быть другим классом или экземпляром исключения, которое затем будет прикреплено к возбуждённому исключению как атрибут __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: int division or modulo 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
Аналогичный механизм работает неявно, если исключение возбуждено внутри обработчика исключений: предыдущее исключение затем присоединяется как атрибут __context__ нового исключения:
>>> try:
... print(1 / 0)
... except:
... raise RuntimeError("Something bad happened")
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
ZeroDivisionError: int division or modulo 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
Дополнительную информацию об исключениях можно найти в разделе Исключения, а информацию об обработке исключений – в разделе Оператор try.
6.9. Инструкция break¶The break statement
break_stmt ::= "break"
break может находиться только синтаксически вложенным в цикл for или while, но не внутри определения функции или класса внутри этого цикла.
Он завершает ближайший охватывающий цикл, пропуская необязательное предложение else, если у цикла оно есть.
Если цикл for прерывается break, целевая переменная цикла сохраняет своё текущее значение.
Когда break передаёт управление из инструкции try с блоком finally, этот блок finally выполняется перед тем, как действительно выйти из цикла.
6.10. Инструкция continue¶The continue statement
continue_stmt ::= "continue"
continue может находиться только синтаксически вложенным в цикл for или while, но не внутри определения функции или класса, а также не внутри блока finally внутри этого цикла. Он переходит к следующей итерации ближайшего охватывающего цикла.
Когда continue передаёт управление из инструкции try с блоком finally, этот блок finally выполняется перед началом следующей итерации цикла.
6.11. Инструкция import¶The import statement
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
Инструкции импорта выполняются в два этапа: (1) найти модуль и инициализировать его при необходимости; (2) определить имя или имена в локальном пространстве имён (в той области видимости, где встречается инструкция import). Инструкция бывает двух форм, различающихся использованием ключевого слова from. Первая форма (без from) повторяет эти шаги для каждого идентификатора в списке. Форма с from выполняет шаг (1) один раз, а затем многократно выполняет шаг (2). Эталонную реализацию шага (1) см. в модуле importlib.
Чтобы понять, как выполняется шаг (1), нужно сначала разобраться, как Python обрабатывает иерархические имена модулей. Для организации модулей и создания иерархии в именах в Python существует понятие пакетов. Пакет может содержать другие пакеты и модули, тогда как модули не могут содержать другие модули или пакеты. С точки зрения файловой системы, пакеты – это каталоги, а модули – файлы. Оригинальную спецификацию пакетов всё ещё можно прочитать, хотя с момента написания этого документа в неё были внесены небольшие изменения.
Как только имя модуля становится известно (если не указано иное, термин «модуль» будет относиться и к пакетам, и к модулям), можно начинать поиск модуля или пакета. Первым проверяется sys.modules – кеш всех модулей, импортированных ранее. Если модуль найден там, он используется на шаге (2) импорта, если только None не находится в sys.modules, в этом случае вызывается ImportError.
Если модуль не найден в кеше, то ищется sys.meta_path (спецификацию sys.meta_path можно найти в PEP 302). Этот объект представляет собой список объектов finder, которые опрашиваются по порядку на предмет того, могут ли они загрузить модуль, путём вызова их метода find_module() с именем модуля. Если модуль находится внутри пакета (обозначается наличием точки в имени), то вторым аргументом find_module() передаётся значение атрибута __path__ родительского пакета (всё, что до последней точки в имени импортируемого модуля). Если искатель может найти модуль, он возвращает loader (обсуждается далее) или возвращает None.
Если ни один из искателей в sys.meta_path не может найти модуль, то опрашиваются некоторые неявно определённые искатели. Реализации Python различаются тем, какие неявные искатели мета-пути определены. Однако все они определяют один и тот же искатель, который обрабатывает sys.path_hooks, sys.path_importer_cache и sys.path.
Неявный искатель ищет запрошенный модуль в «путях», указанных в одном из двух мест («пути» не обязательно должны быть путями файловой системы). Если импортируемый модуль должен находиться внутри пакета, то вторым аргументом, передаваемым в find_module(), используется __path__ родительского пакета в качестве источника путей. Если модуль не содержится в пакете, то sys.path используется как источник путей.
Как только источник путей выбран, он перебирается для поиска искателя, который может обработать этот путь. Словарь sys.path_importer_cache кеширует искатели для путей и проверяется на наличие искателя. Если для пути нет кешированного искателя, то выполняется поиск в sys.path_hooks путём вызова каждого объекта в списке с единственным аргументом – путём; при этом возвращается искатель или вызывается ImportError. Если искатель возвращён, то он кешируется в sys.path_importer_cache и затем используется для этой записи пути. Если искатель не найден, но путь существует, то в sys.path_importer_cache сохраняется значение None, чтобы показать, что для этого пути следует использовать неявный искатель, основанный на файловой системе, который обрабатывает модули, хранящиеся в виде отдельных файлов. Если путь не существует, то в кеш для этого пути помещается искатель, который всегда возвращает None.
Если ни один искатель не может найти модуль, то вызывается ImportError. В противном случае какой-то искатель возвращает загрузчик, для которого вызывается метод load_module() с именем модуля для загрузки (см. PEP 302 для оригинального определения загрузчиков). Загрузчик имеет несколько обязанностей по отношению к загружаемому модулю. Во-первых, если модуль уже существует в sys.modules (такое возможно, если загрузчик вызывается вне механизма импорта), то он должен использовать этот модуль для инициализации, а не новый модуль. Но если модуль не существует в sys.modules, то он должен быть добавлен в этот словарь до начала инициализации. Если во время загрузки модуля происходит ошибка, и он был добавлен в sys.modules, он должен быть удалён из словаря. Если ошибка происходит, но модуль уже был в sys.modules, он остаётся в словаре.
Загрузчик должен установить несколько атрибутов модуля. __name__ должен быть установлен в имя модуля. __file__ должен быть «путём» к файлу, если только модуль не встроенный (и, следовательно, указан в sys.builtin_module_names); в этом случае атрибут не устанавливается. Если импортируется пакет, то __path__ должен быть установлен в список путей для поиска модулей и пакетов, содержащихся внутри импортируемого пакета. __package__ необязателен, но должен быть установлен в имя пакета, содержащего модуль или пакет (пустая строка используется для модуля, не содержащегося в пакете). __loader__ также необязателен, но должен быть установлен в объект загрузчика, который загружает модуль.
Если во время загрузки происходит ошибка, загрузчик вызывает ImportError, если какое-либо другое исключение уже не распространяется. В противном случае загрузчик возвращает загруженный и инициализированный модуль.
Когда шаг (1) завершается без вызова исключения, можно приступать к шагу (2).
Первая форма инструкции import связывает имя модуля в локальном пространстве имён с объектом модуля, а затем переходит к импорту следующего идентификатора, если таковой имеется. Если за именем модуля следует as, то имя после as используется как локальное имя модуля.
Форма from не связывает имя модуля: она перебирает список идентификаторов, ищет каждый из них в модуле, найденном на шаге (1), и связывает имя в локальном пространстве имён с найденным объектом. Как и в первой форме import, можно указать альтернативное локальное имя, задав “as локальное_имя”. Если имя не найдено, ImportError возбуждается. Если список идентификаторов заменить звёздочкой ('*'), то все общедоступные имена, определённые в модуле, связываются в локальном пространстве имён оператора import.
Общедоступные имена, определённые модулем, определяются путём проверки пространства имён модуля на наличие переменной с именем __all__; если она определена, то должна быть последовательностью строк, которые являются именами, определёнными или импортированными этим модулем. Имена, указанные в __all__, считаются общедоступными и должны существовать. Если __all__ не определён, то набор общедоступных имён включает все имена из пространства имён модуля, которые не начинаются с символа подчёркивания ('_'). __all__ должен содержать весь общедоступный API. Это предназначено для предотвращения случайного экспорта элементов, не входящих в API (например, библиотечных модулей, которые были импортированы и использованы внутри модуля).
Форма from с * может встречаться только в области видимости модуля. Форма импорта с подстановочным знаком – import * – разрешена только на уровне модуля. Попытка использовать её в определениях класса или функции вызовет SyntaxError.
Указывая, какой модуль импортировать, не обязательно задавать абсолютное имя модуля. Если модуль или пакет находится внутри другого пакета, можно сделать относительный импорт в пределах того же самого верхнего пакета, не указывая имя пакета. Используя ведущие точки в имени модуля или пакета после from, можно задать, на сколько уровней подняться вверх по иерархии текущего пакета, не указывая точные имена. Одна ведущая точка означает текущий пакет, в котором находится модуль, выполняющий импорт. Две точки – подняться на один уровень пакета. Три точки – на два уровня и так далее. Так, если выполнить from . import mod из модуля в пакете pkg, то в итоге будет импортирован pkg.mod. Если выполнить from ..subpkg2 import mod внутри pkg.subpkg1, то будет импортирован pkg.subpkg2.mod. Спецификация относительных импортов содержится в PEP 328.
importlib.import_module() предоставляется для поддержки приложений, которые determine which modules need to be loaded dynamically.
6.11.1. Операторы future¶Future statements
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 3.0: absolute_import, division, generators, unicode_literals, print_function, nested_scopes и with_statement. Все они избыточны, поскольку всегда включены, и сохранены только для обратной совместимости.
Инструкция future распознаётся и обрабатывается особым образом на этапе компиляции: изменения семантики ключевых конструкций часто реализуются путём генерации другого кода. Может даже случиться так, что новая возможность вводит новый несовместимый синтаксис (например, новое зарезервированное слово), и тогда компилятору может потребоваться разбирать модуль иначе. Такие решения нельзя откладывать до выполнения.
Для любого конкретного выпуска компилятор знает, какие имена возможностей определены, и выдаёт ошибку на этапе компиляции, если инструкция future содержит неизвестную ему возможность.
Непосредственная семантика выполнения та же, что и для любого оператора import: существует стандартный модуль __future__, описанный далее, и он будет импортирован обычным образом в момент выполнения future-оператора.
Интересная семантика времени выполнения зависит от конкретной возможности, включаемой инструкцией future.
Обратите внимание, что в этой инструкции нет ничего особенного:
import __future__ [as name]
Это не инструкция future, а обычная инструкция import без особой семантики или синтаксических ограничений.
Код, скомпилированный вызовами встроенных функций exec() и compile(), которые встречаются в модуле M, содержащем future-оператор, по умолчанию будет использовать новый синтаксис или семантику, связанную с этим future-оператором. Это можно контролировать с помощью необязательных аргументов compile() – подробнее см. документацию этой функции.
Future-оператор, введённый в интерактивном режиме интерпретатора, вступит в силу на оставшуюся часть сеанса интерпретатора. Если интерпретатор запущен с флагом -i, ему передано имя скрипта для выполнения, и скрипт содержит future-оператор, то этот оператор будет действовать в интерактивном сеансе, запущенном после выполнения скрипта.
См. также
- PEP 236 – Назад в __future__
- Оригинальное предложение механизма __future__.
6.12. Оператор global¶The global statement
global_stmt ::= "global" identifier ("," identifier)*
Оператор global – это объявление, действующее на весь текущий блок кода. Оно означает, что перечисленные идентификаторы следует интерпретировать как глобальные. Без global было бы невозможно присваивать значения глобальным переменным, хотя свободные переменные могут ссылаться на глобальные, не будучи объявленными глобальными.
Имена, перечисленные в операторе global, не должны использоваться в том же блоке кода текстуально до этого оператора global.
Имена, перечисленные в операторе global, не должны быть определены как формальные параметры или как цель управления циклом в for, или в определении class, определения функции, или в операторе import.
CPython implementation detail: Текущая реализация не применяет последние два ограничения, но программы не должны злоупотреблять этой свободой, поскольку будущие реализации могут начать их применять или незаметно изменить смысл программы.
Замечание для программистов: global – это директива для парсера. Она применяется только к коду, который анализируется одновременно с оператором global. В частности, оператор global, содержащийся в строке или объекте кода, переданном встроенной функции exec(), не влияет на блок кода, содержащий вызов функции, и код, содержащийся в такой строке, не подвержен влиянию операторов global в коде, содержащем вызов функции. То же самое касается функций eval() и compile().
6.13. Оператор nonlocal¶The nonlocal statement
nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*
Инструкция nonlocal заставляет перечисленные идентификаторы ссылаться на ранее связанные переменные в ближайшей объемлющей области видимости. Это важно, потому что поведение по умолчанию для связывания заключается в поиске сначала в локальном пространстве имён. Инструкция позволяет инкапсулированному коду переназначать переменные за пределами локальной области видимости, помимо глобальной (модульной) области.
Имена, перечисленные в инструкции nonlocal, в отличие от имён, перечисленных в инструкции global, должны ссылаться на уже существующие связывания в объемлющей области видимости (область, в которой должно быть создано новое связывание, не может быть однозначно определена).
Имена, перечисленные в операторе nonlocal, не должны конфликтовать с уже существующими привязками в локальной области.