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

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

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

expression_stmt ::=  expression_list

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

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

7.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

(См. раздел Первичные выражения с определениями синтаксиса для attributeref, subscription и slicing.)

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

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

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

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

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

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

  • Если имя не встречается в инструкции 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__() с соответствующими аргументами.

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

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

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i обновляется, затем обновляется x[i]
print(x)

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

7.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__ недопустимы. Значение встроенной переменной определяется при запуске интерпретатора.

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

pass_stmt ::=  "pass"

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

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

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

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

del_stmt ::=  "del" target_list

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

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

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

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

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

return_stmt ::=  "return" [expression_list]

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

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

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

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

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

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

yield_stmt ::=  yield_expression

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

yield <expr>
yield from <expr>

эквивалентны выражениям-операторам yield.

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

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

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

7.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

Аналогичный механизм работает неявно, если исключение возбуждается внутри обработчика исключений или блока finally: предыдущее исключение тогда прикрепляется как атрибут __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.

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

break_stmt ::=  "break"

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

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

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

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

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

continue_stmt ::=  "continue"

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

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

7.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

Базовая инструкция import (без предложения from) выполняется в два шага:

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

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

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

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

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

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

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

Примеры:

import foo                 # foo импортирован и привязан локально
import foo.bar.baz         # foo.bar.baz импортирован, foo привязан локально
import foo.bar.baz as fbb  # foo.bar.baz импортирован и привязан как fbb
from foo.bar import baz    # foo.bar.baz импортирован и привязан как baz
from foo import attr       # foo импортирован и foo.attr привязан как attr

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

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

Групповая форма импорта – from module 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]

7.12. Оператор global¶The global statement

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

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

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

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

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

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

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

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

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

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