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

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

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

expression_stmt ::=  expression_list

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

В интерактивном режиме, если значение не равно None, оно преобразуется в строку с помощью встроенной функции repr() и результирующая строка записывается в стандартный вывод (см. раздел Инструкция print) на отдельной строке. (Инструкции-выражения, возвращающие 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

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

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

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

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

• Если список целей состоит из одной цели: объект присваивается этой цели.

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

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

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

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

  • В противном случае: имя связывается с объектом в текущем глобальном пространстве имён.

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

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

• Если цель является ссылкой на атрибут: вычисляется первичное выражение в ссылке. Оно должно давать объект с назначаемыми атрибутами; если это не так, возбуждается 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 (присваивание индексированной последовательности не может добавить новые элементы в список).

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

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

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

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

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

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.

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

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

6.6. Инструкция print¶The print statement

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

print вычисляет каждое выражение по очереди и записывает полученный объект в стандартный вывод (см. ниже). Если объект не является строкой, он сначала преобразуется в строку по правилам преобразования строк. Затем записывается (полученная или исходная) строка. Пробел записывается перед каждым объектом (после преобразования) до его записи, если только система вывода не считает, что находится в начале строки. Это происходит, когда (1) в стандартный вывод ещё не было записано ни одного символа, (2) последним записанным в стандартный вывод символом является пробельный символ, кроме ' ', или (3) последняя операция записи в стандартный вывод не была инструкцией print. (В некоторых случаях может быть функционально записать пустую строку в стандартный вывод по этой причине.)

Символ '\n' записывается в конце, если только инструкция print не заканчивается запятой. Это единственное действие, если инструкция содержит только ключевое слово print.

Стандартный вывод определяется как файловый объект с именем stdout во встроенном модуле sys. Если такого объекта не существует или у него нет метода write(), возбуждается исключение RuntimeError.

print также имеет расширенную форму, определяемую второй частью синтаксиса, описанного выше. Эта форма иногда называется «print chevron». В этой форме первое выражение после >> должно вычисляться в «файлоподобный» объект, а именно объект, имеющий метод write(), как описано выше. С помощью этой расширенной формы последующие выражения выводятся в этот файловый объект. Если первое выражение вычисляется в None, то в качестве файла для вывода используется sys.stdout.

6.7. Инструкция return¶The return statement

return_stmt ::=  "return" [expression_list]

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

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

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

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

В генераторной функции инструкция return не может содержать expression_list. В этом контексте пустой return указывает, что генератор завершён, и вызовет возбуждение StopIteration.

6.8. Инструкция yield¶The yield statement

yield_stmt ::=  yield_expression

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

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

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

Начиная с версии Python 2.5, инструкция yield теперь допускается в предложении try конструкции try … finally. Если генератор не возобновлён до его финализации (достижением нулевого счётчика ссылок или сборкой мусора), будет вызван метод close() генератор-итератора, позволяя выполнить все ожидающие предложения finally.

Полные сведения о семантике yield см. в разделе Выражения yield.

from __future__ import generators

6.9. Инструкция raise¶The raise statement

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

Если выражения отсутствуют, raise повторно возбуждает последнее исключение, которое было активно в текущей области видимости. Если в текущей области видимости нет активного исключения, возбуждается исключение TypeError, указывающее на ошибку (при работе под IDLE вместо этого возбуждается исключение Queue.Empty).

В противном случае raise вычисляет выражения для получения трёх объектов, используя None в качестве значения пропущенных выражений. Первые два объекта используются для определения типа и значения исключения.

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

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

Если присутствует третий объект и он не равен None, он должен быть объектом traceback (см. раздел Стандартная иерархия типов), и он подставляется вместо текущего местоположения как место, где произошло исключение. Если третий объект присутствует и не является объектом traceback или None, возбуждается исключение TypeError. Форма raise с тремя выражениями полезна для прозрачного повторного возбуждения исключения в предложении except, но raise без выражений следует предпочитать, если повторно возбуждаемое исключение было последним активным исключением в текущей области видимости.

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

6.10. Инструкция break¶The break statement

break_stmt ::=  "break"

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

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

Если цикл for завершается оператором break, то целевая переменная цикла сохраняет своё текущее значение.

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

6.11. Инструкция continue¶The continue statement

continue_stmt ::=  "continue"

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

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

6.12. Инструкция 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

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

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

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

Если модуль не найден в кэше, то выполняется поиск в 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 localname». Если имя не найдено, возбуждается 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() предоставляется для поддержки приложений, которые определяют, какие модули необходимо загружать динамически.

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

import __future__ [as name]

6.13. Инструкция global¶The global statement

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

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

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

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

Примечание для программиста: global – это директива для парсера. Она применяется только к коду, который анализируется одновременно с инструкцией global. В частности, инструкция global, содержащаяся в инструкции exec, не влияет на блок кода , содержащий инструкцию exec, и код, содержащийся в инструкции exec, не затрагивается инструкциями global в коде, содержащем инструкцию exec. То же самое относится к функциям eval(), execfile() и compile().

6.14. Инструкция exec¶The exec statement

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

Эта инструкция поддерживает динамическое выполнение кода Python. Первое выражение должно вычисляться в строку Unicode, строку в кодировке Latin-1, открытый файловый объект, объект кода или кортеж. Если это строка, она разбирается как набор инструкций Python, который затем выполняется (если не возникает синтаксическая ошибка). 1 Если это открытый файл, файл разбирается до конца и выполняется. Если это объект кода, он просто выполняется. О том, что означает кортеж, см. ниже. Во всех случаях ожидается, что выполняемый код является допустимым в качестве файлового ввода (см. раздел File input). Имейте в виду, что инструкции return и yield не могут использоваться вне определений функций, даже в контексте кода, переданного инструкции exec.

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

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

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

Советы программисту: динамическое вычисление выражений поддерживается встроенной функцией eval(). Встроенные функции globals() и locals() возвращают текущий глобальный и локальный словари соответственно, что может быть полезно для передачи в exec.

Сноски

1

Обратите внимание, что парсер принимает только соглашение о конце строки в стиле Unix. Если вы читаете код из файла, обязательно используйте режим universal newlines для преобразования перевода строк в стиле Windows или Mac.