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

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

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

expression_stmt ::=  expression_list

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

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

Инструкции присваивания¶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).

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

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

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

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

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

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

ПРЕДУПРЕЖДЕНИЕ: Хотя определение присваивания подразумевает, что пересечения между левой и правой частью «безопасны» (например, 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                     ::=  "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="

class A:
    x = 3    # переменная класса
a = A()
a.x += 1     # записывает a.x как 4, оставляя A.x равным 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__ недопустимы. Значение встроенной переменной определяется при запуске интерпретатора.

Инструкция pass¶The pass statement

pass_stmt ::=  "pass"

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

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

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

Инструкция del¶The del statement

del_stmt ::=  "del" target_list

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

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

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

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

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

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

return_stmt ::=  "return" [expression_list]

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

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

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

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

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

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

yield_stmt ::=  yield_expression

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

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

Инструкция yield разрешена в блоке try конструкции try ... finally. Если генератор не будет возобновлён до его финализации (достижение нулевого счётчика ссылок или сборка мусора), будет вызван метод close() итератора генератора, что позволит выполнить незавершённые блоки finally.

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

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

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

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

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

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

raise RuntimeError("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.

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

break_stmt ::=  "break"

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

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

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

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

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

continue_stmt ::=  "continue"

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

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

Инструкция 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 выполняет шаг (1) один раз, а затем многократно выполняет шаг (2).

В этом контексте «инициализировать» встроенный или модуль расширения означает вызвать функцию инициализации, которую модуль должен предоставить для этой цели (в эталонной реализации имя функции получается добавлением строки «init» к имени модуля); «инициализировать» модуль, написанный на Python, означает выполнить тело модуля.

Система ведёт таблицу модулей, которые были или инициализируются, индексируемую по имени модуля. Эта таблица доступна как sys.modules. Когда имя модуля найдено в этой таблице, шаг (1) завершён. Если нет, начинается поиск определения модуля. Когда модуль найден, он загружается. Детали процесса поиска и загрузки модуля зависят от реализации и платформы. Обычно он включает поиск «встроенного» модуля с заданным именем, а затем поиск по списку путей, заданному как sys.path.

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

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

Первая форма инструкции import связывает имя модуля в локальном пространстве имён с объектом модуля, а затем переходит к импорту следующего идентификатора, если таковой имеется. Если за именем модуля следует as, то имя после as используется как локальное имя модуля.

Форма from не связывает имя модуля: она проходит по списку идентификаторов, ищет каждый из них в модуле, найденном на шаге (1), и связывает имя в локальном пространстве имён с найденным объектом. Как и в первой форме import, можно указать альтернативное локальное имя, задав «as локальное_имя». Если имя не найдено, возбуждается ImportError. Если список идентификаторов заменён звёздочкой ('*'), все публичные имена, определённые в модуле, связываются в локальном пространстве имён инструкции import.

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

Форма from с * может встречаться только в области видимости модуля. Если форма импорта со звёздочкой – import * – используется в функции, и функция содержит или является вложенным блоком со свободными переменными, компилятор возбудит SyntaxError.

Иерархические имена модулей: когда имя модуля содержит одну или несколько точек, путь поиска модуля строится иначе. Последовательность идентификаторов до последней точки используется для поиска «пакета»; последний идентификатор затем ищется внутри пакета. Пакет обычно представляет собой подкаталог каталога из sys.path, содержащий файл __init__.py.

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

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]

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

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

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

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

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

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

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

Оператор nonlocal ¶The nonlocal statement

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

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

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

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

Сноски