Готовый перевод The Python Language Reference / Справочник по языку Python: 6. Simple statements

Внимание! Этот перевод, возможно, ещё не готов, так как модераторы установили для него статус «идёт перевод»

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

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

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

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

<code>expression_stmt ::= expression_list</code>

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

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

6.2. Инструкции назначения (связывания, присваивания)

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

(Смотри определения синтаксиса последних трёх обозначений в разделе «Primaries» . )

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

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

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

Если этот список целей фактически состоит из единственной цели, то данный объект назначается этой цели.

Если этот список целей является перечнем целей, разделённых запятыми, то данный объект (источник) должен быть итерируемым и иметь столько же элементов (сколько целей в списке целей), и эти элементы назначаются соответствующим по счёту (слева направо) целям. (Это правило стало менее ограниченным с версии Питона 1.5 (до этого объект источник обязан был быть кортежем) . Теперь, поскольку текстовые данные являются последовательностями, назначение вроде «a, b = "xy"» является допустимым, при условии, что текст имеет строго соответствующую длину.)

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

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

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

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

Если это имя не упоминается в текущем блоке кода в инструкциях «global» или «nonlocal» , то это имя связывается с данным объектом в текущей области имён (тоесть, создаётся локальная переменная с этим именем) .

Иначе это имя связывается в глобальной области имён с данным объектом или во внешней области имён, определённой «nonlocal» , с данным объектом соответственно.

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

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

Если эта цель является указанием (ссылкой) на атрибут, то первичное выражение этой ссылки интерпретируется, что в результате должно дать объект с атрибутами, допускающими назначение – иначе инициируется «TypeError» . Этому полученному объекту предлагается назначить объект-источник соответствующему (своему) атрибуту – если он не может выполнить это назначение, то инициирует исключение (обычно, но не обязательно – «AttributeError» ) .

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

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

Это не обязательно относится к атрибутам-дескрипторам, например, созданным с помощью «<code>property()</code>» .

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

Если первичное выражение является изменяемой последовательностью (например списком) , то выражение, определяющее индекс, должно давать в результате целое число. Если это число отрицательное, то к нему прибавляется длина данной последовательности. Получившееся в результате значение должно быть неотрицательным целым, меньшим, чем длина данной последовательности. Затем к данной последовательности следует запрос назначить объект-источник элементу с данным значением индекса. Если индекс выходит за границы, то вызывается исключение «<code>IndexError</code>» (назначение последовательности по индексу не может добавлять новый элемент к списку) .

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

Для объектов, определённых пользователем, вызывается метод «<code>__setitem__()</code>» с соответствующими аргументами.

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

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

Осторожно ! Хотя определение операции назначения подразумевает, что упоминание одного и того же объекта и в левой и в правой частях («перекрытие») является «безопасным» (например, «<code>a, b = b, a</code>» обменивает значения двух переменных) , «перекрытие» внутри перечисления переменных - целей назначения – не является «безопасным» ! Например, следующая программа печатает «<code>[0, 2]</code>» :

<code>x = [0, 1]
i = 0
i, x[i] = 1, 2
print(x)</code>

Смотрите также : PEP 3132 - Extended Iterable Unpacking
Спецификация свойства «<code>*target</code>» .

6.2.1. Расширенные инструкции назначения

Расширенное назначение объединяет в одной инструкции операцию над двумя операндами (т.н. «бинарную») и инструкцию назначения :

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

(Смотрите определение последних трёх знаков в разделе 5.3. «Primaries» )

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

Выражение расширенного назначения вроде «<code>x += 1</code>» можно переписать как «<code>x = x + 1</code>» , что даёт подобный, но не точно тот же эффект. В «расширенной» версии – «<code>x</code>» вычисляется только один раз. Также, когда это возможно, операция выполняется «на месте», тоесть, вместо создания нового объекта и потом назначения его цели – сразу используется «старый» объект.

С учётом указанных выше оговорок (о кортежах и множественных целях) – назначения у расширенных назначений обрабатываются так же, как и обычные. Также и (с исключением насчёт исполнения «на месте» ) двухоперандная операция у расширенных назначений обрабатывается так же, как и обычная.

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

6.3. Инструкция «assert»

Инструкция «<code>assert</code>» («подтверждение») – это удобный способ вставить в программу контроль (промежуточных результатов) для наладочных целей.

<code>assert_stmt ::= "assert" expression ["," expression]</code>

Для короткой формы – «<code>assert expression</code>» – эквивалентом является :

<code>if __debug__:
    if not expression: raise AssertionError</code>

А для расширенной формы – «<code>assert expression1, expression2</code>» – эквивалентом является :

<code>if __debug__:
if not expression1: raise AssertionError(expression2)</code>

Эти эквиваленты полагаются на встроенные переменные «<code>__debug__</code>» и «<code>AssertionError</code>» . В текущей реализации Питона встроенная переменная «<code>__debug__</code>» – по умолчанию имеет значение «<code>True</code>» , а «<code>False</code>» – в случае оптимизации командой «<code>-O</code>» . Нынешний генератор кода не генерирует никакого кода для инструкций «<code>assert</code>» , когда запрошена компиляция с оптимизацией. Заметьте, что необязательно вставлять исходный код выражения, вызвавшего ошибку, в сообщение об ошибке – оно и так будет показано, как часть «стека» .

Запись в переменную «<code>__debug__</code>» – недопустима. Значение для этой встроенной переменной определяется при запуске интерпретатора.

6.4. Инструкция «pass»

«<code>pass</code>» – это «пустой» оператор – при его исполнении ничего не происходит. Он полезен как заместитель, когда какое либо выражение необходимо по синтаксису, но там не нужно исполнять никакого кода. Например :

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

class C: pass       # a class with no methods (yet)</code>

6.5. Инструкция «del»

<code>del_stmt ::= "del" target_list</code>

Удаление определяется рекурсивно – очень похоже на то, как определяется назначение (смотрите п. 6.2.). Вместо расписывания деталей грамматики – далее даны только некоторые подсказки.

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

Удаление имени удаляет назначение этому имени из локальной или глобальной области имён, в зависимости от того, объявлено ли это имя в инструкции «<code>global</code>» в этом же самом блоке. Если данное имя не было назначенным (т.е. не было определено) , то инициируется исключение «<code>NameError</code>» .

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

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

6.6. Инструкция «return»

<code>return_stmt ::= "return" [expression_list]</code>

«<code>return</code>» может встречаться только синтаксически непосредственно внутри определения функции, но не внутри вложенных определений классов.

Если (в качестве параметров) дан список выражений, то он вычисляется – иначе подразумевается «<code>None</code>» .

«<code>return</code>» делает выход из текущего вызова функции с указанным списком выражений (или «<code>None</code>» ) в качестве возвращаемого этой функцией значения.

Когда «<code>return</code>» передаёт управление изнутри инструкции «<code>try</code>» имеющей ветвь «<code>finally</code>» , ветвь «<code>finally</code>» исполняется до фактического выхода из этой функции.

В функции-генераторе инструкция «<code>return</code>» не может иметь синтаксический элемент «<code>expression_list</code>» , тоесть вообще каких-либо аргументов. В этом контексте «<code>return</code>» без аргументов – является сигналом того, что генератор завершил работу, и приведёт к вызову «<code>StopIteration</code>» .

6.7. Инструкция «yield»

<code> yield_stmt ::= yield_expression</code>

Инструкция «<code>yield</code>» используется только при определении функций-генераторов и встречается только внутри такой функции. Использование инструкции «<code>yield</code>» в какой-либо функции – является однозначным сигналом, который приводит к тому, что данное определение вместо обычной функции создаёт функцию-генератор. При вызове функции-генератора – она возвращает итератор, также называемый : «итератор-генератор» , или просто : «генератор» . Тело функции-генератора исполняется посредством вызова функции «<code>next()</code>» , применённой к данному генератору, повторяясь до получения исключения.

Когда исполняется инструкция «<code>yield</code>» – состояние содержащей её функции-генератора замораживается, а значение аргументов «<code>yield</code>» («<code>expression_list</code>») возвращается в место вызова функции «<code>next()</code>» . Под “замораживается” подразумевается то, что всё локальное состояние сохраняется, включая текущие связывания (значения) локальных переменных, указатель на инструкцию (с которой продолжать) и внутренний стек вычислений. Тоесть сохраняется исчерпывающая информация для того, чтобы, когда в следующий раз будет вызвана инструкция «<code>next()</code>» , функция-генератор могла продолжаться точно также, как если бы вместо инструкции «<code>yield</code>» был какой-либо вызов внешней функции.

Инструкция «<code>yield</code>» допустима в ветви «<code>try</code>» конструкции «<code>try ... finally</code>» . Если данный генератор не был завершён до его “деструкции” (вследствие достижения ноля счётчиком ссылок или действием “сборщика мусора”) , то будет вызван метод «<code>close()</code>» данного генератора, что позволяет исполниться незавершённым ветвям «<code>finally</code>» .

Смотрите также :

PEP 0255 - Simple Generators

Предложение о добавлении в Питон генераторов и инструкции «<code>yield</code>» .

PEP 0342 - Coroutines via Enhanced Generators

Предложение, которое помимо других улучшений генератора, предполагает разрешение инструкции «<code>yield</code>» внутри блока «<code>try ... finally</code>» .

6.8. Инструкция «<code>raise</code>»

<code>raise_stmt ::= "raise" [expression ["from" expression]]</code>

Если не заданы выражения, то «raise» перевызывает последнее исключение, которое было активно в текущей области. А если в текущей области нет активных исключений, то вызывается исключение «TypeError» , сигнализирующее о неопределённой ошибке (при работе под «IDLE» вызывается исключение «queue.Empty» ) .

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

Типом данного исключения является класс экземпляра данного исключения, а значением является сам этот экземпляр.

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

<code>raise Exception("foo occurred").with_traceback(tracebackobj)</code>

Часть после ключевого слова «<code>from</code>» используется для связывания исключений : если это второе выражение задано, оно должно быть ещё одним классом или экземпляром исключения – этот объект будет присоединён к вызываемому (основному) исключению как изменяемый атрибут «<code>__cause__</code>» . Если вызванное исключение не обработано, то будут напечатаны оба исключения :

<code>>>> 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</code>

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

<code>>>> 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</code>

Дополнительную информацию об исключениях смотрите в разделе “Exceptions” , а об обработке исключений – в разделе “The try statement” .

6.9. Инструкция «break»

break_stmt ::= "break"

«break» может встречаться только находясь синтаксически внутри цикла «for» или «while» , но не внутри определения функции или класса, находящегося внутри этого цикла.

Эта инструкция прекращает ближайший объемлющий цикл, пропуская его ветвь «else» , если она есть.

Если цикл «for» прекращён инструкцией «break», то переменная-цель со значением текущего элемента перебираемого множества – сохраняет своё значение.

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

6.10. Инструкция «<code>continue</code>»

<code>continue_stmt ::= "continue"</code>

«<code>continue</code>» может встречаться только находясь синтаксически внутри цикла «<code>for</code>» или «<code>while</code>» , но не внутри определения функции или класса или внутри ветви «<code>finally</code>», находящихся внутри этого цикла. Эта инструкция продолжает выполнение ближайшего объемлющего цикла с нового прохода.

Когда «<code>continue</code>» исполняется внутри инструкции «<code>try</code>» , имеющей ветвь «<code>finally</code>» , то эта ветвь выполняется раньше нового прохода цикла.

6.11. Инструкция «<code>import</code>»

<code>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</code>

Инструкции «<code>import</code>» исполняются в два шага:
1: находится модуль, и, если необходимо, инициализируется;
2: определяется имя (или имена) в данной локальной области имён (тоесть, в той, где находится данная инструкция «<code>import</code>» ) .
Инструкция бывает двух видов : с ключевым словом «<code>from</code>» и без. Форма без «<code>from</code>» повторяет указанные два шага для каждого идентификатора в списке. Форма с «<code>from</code>» исполняет шаг 1 однократно, а затем исполняет шаг 2 многократно. Подробнее об реализации шага 1 смотрите в модуле «<code>importlib</code>» .

Для понимания того, что происходит на первом шаге, нужно понимать, как Питон управляется с иерархическим именованием модулей. Для удобства организации модулей и возможности иерархического именования в Питоне есть своя концепция пакетов. Пакет может содержать другие пакеты и модули, тогда как модули не могут содержать ни других модулей ни пакетов. С точки зрения файловой системы – пакеты являются директориями (“каталогами”, “папками”) , а модули являются файлами. Оригинальная <a href="http://www.python.org/doc/essays/packages.html">спецификация пакетов</a> ещё доступна для чтения, хотя незначительные детали изменились со времени её написания.

Когда имя модуля становится известно (когда не указано иное – термин “модуль” будет подразумевать как модули, так и пакеты) – начинается поиск этого модуля или пакета. Сначала проверяется «<code>sys.modules</code>» – это кэш всех модулей, которые уже́ были импортированы. Если искомый модуль там найден, то он и используется на шаге 2 импортирования.

Если модуль не найден в кэше, то производится поиск в «<code>sys.meta_path</code>» (спецификацию «<code>sys.meta_path</code>» можно посмотреть в “PEP 302” ) . Этот объект является списком объектов <a href="http://docs.python.org/py3k/glossary.html#term-finder">“finder”</a> , которые запрашиваются по порядку на предмет того, знают ли они как загружать данный модуль, посредством вызова их метода «<code>find_module()</code>» с именем данного модуля. Если оказывается, что данный модуль содержится внутри пакета (как следует из наличия точки в имени) , то второй аргумент у «<code>find_module()</code>» представляет собой значение атрибута «<code>__path__</code>» из родительского пакета (всё вплоть до последней точки в имени данного импортируемого модуля) . Если “finder” может найти модуль, то он возвращает “загрузчик” (будет рассмотрено далее) , иначе возвращает «<code>None</code>» .

Если ни один из “finder” в «<code>sys.meta_path</code>» не оказался способен найти модуль, тогда запрашиваются какие-либо не явно определённые “finder” . Реализации Питона различаются в том, каким неявным путём определяются “finder” . Однако, одно, что все они определяют – то, что контролирует «<code>sys.path_hooks</code>» , «<code>sys.path_importer_cache</code>» , «<code>sys.path</code>» .

6.11.1. Инструкция “future”

Инструкция “future” является особым случаем инструкции «<code>import</code>» и является указанием компилятору о том, что данный модуль нужно компилировать, используя синтаксис либо семантику, которые будут доступны в указанной будущей версии Питона. Инструкция “future” нацелена на облегчение миграции на новые версии Питона, в которых будут введены несовместимые изменения. Это позволяет использовать новые возможности (для этого потребуется установить соответствующие модули) до версии языка, в которой они станут стандартными.

<code>future_statement ::=  "from" "__future__" "import" feature ["as" name]
                      ("," feature ["as" name])*
                      | "from" "__future__" "import" "(" feature ["as" name]
                      ("," feature ["as" name])* [","] ")"
feature          ::=  identifier
name             ::=  identifier</code>

Инструкция “future” должна располагаться перед кодом модуля. До неё могут быть только следующие строки :

строка документации модуля (если есть) ,

коментарии,

пустые строки,

другие инструкции “future” .

Питон 3.0 знает следующие свойства : «<code>absolute_import</code>» , «<code>division</code>» , «<code>generators</code>» , «<code>unicode_literals</code>» , «<code>print_function</code>» , «<code>nested_scopes</code>» , «<code>with_statement</code>» . Но все они уже устарели, поскольку уже́ встроены в язык и всегда доступны, и сохранены только для обратной совместимости.

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

Компилятор знает, какие имена будущих свойств определены в конкретной данной версии и инициирует ошибку этапа компилирования, если инструкция “future” содержит свойство, которое ему не известно.

За исключением указанного выше – на этапе исполнения имеет тот же смысл, что и любое выражение «<code>import</code>» , тоесть : имеется стандартный модуль «<code>__future__</code>» (описано далее) , и он будет импортирован обычным образом в момент исполнения соответствующей инструкции “future” .

Влияние на выполнение программы сильно зависит от того, какие свойства задействованы.

Заметьте, что следующая инструкция не интерпретируется как-либо исключительно :

<code>import __future__ [as name]</code>

Это не инструкция “future” – это обычная инструкция «<code>import</code>» без каких-либо исключительных смысла или синтаксиса.

Код, компилируемый посредством встроенных функций «<code>exec()</code>» и «<code>compile()</code>» , вызываемых из модуля, содержащего инструкцию “future” , по-умолчанию испытывает эффект этой инструкции – интерпретируется с соответствующими новыми синтаксисом и смыслом. Для «<code>compile()</code>» этот эффект можно контролировать через необязательный аргумент (подробности смотрите в документации по данной функции) .

Инструкция “future” , введённая на запрос интерактивного интерпретатора, будет оказывать эффект до конца работы интерпретатора. Если интерпретатор был запущен с опцией «<code>-i</code>» и именем скрипта, и этот скрипт содержит инструкцию “future” , то она будет в силе и после перехода к интерактивной сессии после завершения скрипта.

Смотрите также :
<a href="http://www.python.org/dev/peps/pep-0236">PEP 236</a> - “Back to the __future__”
Исходное предложение по механизму «<code>__future__</code>» .

6.12. Инструкция «<code>global</code>»

<code>global_stmt ::= "global" identifier ("," identifier)*</code>

Действие инструкции «<code>global</code>» распространяется на весь текущий блок кода. Она указывает, что перечисленные в ней идентификаторы должны интерпретироваться как глобальные. Может оказаться невозможным получить доступ к некой глобальной переменной без инструкции «<code>global</code>» , но переменные, не связанные в данной области имён, обращаются к глобальным переменным – не будучи объявленными как глобальные.

Идентификаторы, перечисленные в инструкции «<code>global</code>» не должны использоваться в том же блоке кода выше по тексту, чем эта инструкция.

Идентификаторы, перечисленные в инструкции «<code>global</code>» не должны объявляться как параметры в определении функции, или как “цель” в конструкции цикла «<code>for</code>» , или в определениях класса или функции, или в инструкции «<code>import</code>» .

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

Замечание для программистов : «<code>global</code>» – это указание, предназначенное анализатору текста (парсеру) . Оно относится только к коду, обрабатываемому одновременно с этой инструкцией «<code>global</code>» . В норме – инструкция «<code>global</code>» , содержащаяся в строке или в объекте-коде, передаваемых во встроенную функцию «<code>exec()</code>» , не влияет на блок кода, в котором этот вызов функции содержится. И обратно, код, содержащийся в такого рода тексте, не испытывает действия инструкции «<code>global</code>» , находящейся в коде, из которого сделан вызов этой функции с текстом. То же относится и к функциям «<code>eval()</code>» и «<code>compile()</code>» .

6.13. Инструкция «<code>nonlocal</code>»

<code>nonlocal_stmt ::= "nonlocal" identifier ("," identifier)*</code>

Инструкция «<code>nonlocal</code>» приводит к тому, что перечисленные в ней идентификаторы будут указывать на объекты, на которые они указывали в ближайшей внешней области имён. Это принципиально отличается от поведения связывания по-умолчанию, при котором сначала происходит поиск в локальной области имён. Эта инструкция позволяет изолированному (инкапсулированному) коду возвращать связывание переменных, существовавшее у них за пределами данной локальной области имён помимо того, что относится к глобальной (на уровне модуля) области имён.

Имена, перечисленные в инструкции «<code>nonlocal</code>» , в отличие от тех, что перечислены в инструкции «<code>global</code>» , обязаны указывать на уже́ существующие назначения в непосредственно объемлющей области имён (та область, в которой новые связывания могли бы быть созданы, не может быть установлена однозначно) .

Среди имён, перечисленных в инструкции «<code>nonlocal</code>» не должно быть тех, что уже́ существуют в этой локальной области имён.

Смотрите также :

<a href="http://www.python.org/dev/peps/pep-3104">PEP 3104</a> - Access to Names in Outer Scopes (Доступ к именам во внешних областях имён)

Спецификация инструкции «<code>nonlocal</code>» .

Внимание! Этот перевод, возможно, ещё не готов.
Его статус: идёт перевод

Переведено на Нотабеноиде
http://notabenoid.org/book/5672/17132

Переводчики: Hittih

Настройки

Готово:

92.30% КП = 1.0