8. Составные инструкции¶Compound statements

8.1. Инструкция if¶The if statement

Инструкция if используется для условного выполнения:

if_stmt ::=  "if" expression ":" suite
             ( "elif" expression ":" suite )*
             ["else" ":" suite]

Она выбирает ровно один из блоков, вычисляя выражения по одному, пока одно из них не окажется истинным (см. раздел Булевы операции для определения истинности и ложности); затем этот блок выполняется (и никакая другая часть инструкции if не выполняется и не вычисляется). Если все выражения ложны, выполняется блок секции else, если она присутствует.

8.2. Инструкция while¶The while statement

Инструкция while используется для повторного выполнения, пока истинно выражение:

while_stmt ::=  "while" expression ":" suite
                ["else" ":" suite]

Цикл многократно проверяет выражение и, если оно истинно, выполняет первый блок; если выражение ложно (возможно, при первой проверке), выполняется блок секции else, если она присутствует, и цикл завершается.

Инструкция break, выполненная в первом блоке, завершает цикл без выполнения блока секции else. Инструкция continue, выполненная в первом блоке, пропускает оставшуюся часть блока и возвращается к проверке выражения.

8.3. Инструкция for¶The for statement

Инструкция for используется для перебора элементов последовательности (например, строки, кортежа или списка) или другого итерируемого объекта:

for_stmt ::=  "for" target_list "in" expression_list ":" suite
              ["else" ":" suite]

Список выражений вычисляется один раз; он должен возвращать итерируемый объект. Для результата expression_list создаётся итератор. Затем блок выполняется один раз для каждого элемента, полученного от итератора, в порядке возрастания индексов. Каждый элемент по очереди присваивается целевому списку с использованием стандартных правил присваивания (см. Assignment statements), после чего блок выполняется. Когда элементы заканчиваются (что происходит немедленно, если последовательность пуста или итератор возбуждает исключение StopIteration), выполняется блок в клаузе else, если она присутствует, и цикл завершается.

Выполнение инструкции break в первом блоке завершает цикл без выполнения блока клаузы else. Выполнение инструкции continue в первом блоке пропускает оставшуюся часть блока и продолжает со следующим элементом, или с клаузой else, если следующего элемента не было.

Блок может присваивать значения переменным в целевом списке; это не влияет на следующий присваиваемый элемент.

Имена в целевом списке не удаляются после завершения цикла, но если последовательность пуста, цикл вообще ничего не присвоит. Подсказка: встроенная функция range() возвращает итератор целых чисел, подходящий для имитации эффекта паскалевского for i := a to b do; например, list(range(3)) возвращает список [0, 1, 2].

for x in a[:]:
    if x < 0: a.remove(x)

8.4. Инструкция try¶The try statement

Инструкция try задаёт обработчики исключений и/или код очистки для группы инструкций:

try_stmt  ::=  try1_stmt | try2_stmt
try1_stmt ::=  "try" ":" suite
               ("except" [expression ["as" target]] ":" suite)+
               ["else" ":" suite]
               ["finally" ":" suite]
try2_stmt ::=  "try" ":" suite
               "finally" ":" suite

Секция(и) except задают один или несколько обработчиков исключений. Если в секции try не возникает исключений, ни один обработчик не выполняется. Когда в блоке try возникает исключение, начинается поиск обработчика исключения. Этот поиск последовательно проверяет секции except, пока не будет найдена подходящая исключению. Секция except без выражения, если присутствует, должна быть последней; она соответствует любому исключению. Для секции except с выражением это выражение вычисляется, и секция соответствует исключению, если полученный объект «совместим» с исключением. Объект совместим с исключением, если он является классом или базовым классом объекта исключения, или кортежем, содержащим элемент, совместимый с исключением.

Если ни одно предложение except не соответствует исключению, поиск обработчика исключений продолжается в окружающем коде и в стеке вызовов. [1]

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

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

Когда исключение было присвоено с помощью as target, оно очищается в конце секции except. Это эквивалентно

except E as N:
    foo

было преобразовано в

except E as N:
    try:
        foo
    finally:
        del N

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

Перед выполнением блока клаузы except подробности об исключении сохраняются в модуле sys и доступны через sys.exc_info(). sys.exc_info() возвращает кортеж из трёх элементов: класс исключения, экземпляр исключения и объект traceback (см. раздел Стандартная иерархия типов), указывающий на точку в программе, где произошло исключение. Значения sys.exc_info() восстанавливаются до предыдущих значений (до вызова) при возврате из функции, обработавшей исключение.

Необязательная секция else выполняется, если и когда управление доходит до конца секции try. [2] Исключения в секции else не обрабатываются предшествующими секциями except.

Если присутствует finally, она задаёт обработчик «очистки». Выполняется секция try, включая любые секции except и else. Если в любой из секций возникает исключение и оно не обработано, исключение временно сохраняется. Выполняется секция finally. Если есть сохранённое исключение, оно повторно возбуждается в конце секции finally. Если секция finally возбуждает другое исключение, сохранённое исключение устанавливается как контекст нового исключения. Если секция finally выполняет инструкцию return или break, сохранённое исключение отбрасывается:

def f():
    try:
        1/0
    finally:
        return 42

>>> f()
42

Информация об исключении недоступна программе во время выполнения секции finally.

Когда инструкция return, break или continue выполняется в блоке try инструкции try...finally, секция finally также выполняется «на выходе». Инструкция continue недопустима в секции finally. (Причина – проблема в текущей реализации; это ограничение может быть снято в будущем.)

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

8.5. Инструкция with¶The with statement

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

with_stmt ::=  "with" with_item ("," with_item)* ":" suite
with_item ::=  expression ["as" target]

Выполнение оператора with с одним «элементом» происходит следующим образом:

1. Контекстное выражение (выражение, указанное в with_item) вычисляется для получения менеджера контекста.

2. Метод __exit__() менеджера контекста загружается для последующего использования.

3. Вызывается метод __enter__() менеджера контекста.

4. Если в оператор with включена цель, то возвращаемое значение __enter__() присваивается ей.

   Примечание

   Оператор with гарантирует, что если метод __enter__() завершается без ошибки, то __exit__() будет вызван всегда. Таким образом, если во время присваивания списку целей возникает ошибка, она обрабатывается так же, как ошибка внутри блока. См. шаг 6 ниже.

5. Выполняется блок.

6. Вызывается метод __exit__() менеджера контекста. Если из-за исключения был завершён блок, то тип, значение и traceback исключения передаются как аргументы в __exit__(). В противном случае передаются три аргумента None.

   Если блок был завершён из-за исключения и возвращаемое значение метода __exit__() равно false, исключение возбуждается заново. Если возвращаемое значение равно true, исключение подавляется, и выполнение продолжается с оператора, следующего за оператором with.

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

Если элементов несколько, менеджеры контекста обрабатываются так, как если бы было вложено несколько операторов with:

with A() as a, B() as b:
    suite

эквивалентна

with A() as a:
    with B() as b:
        suite

8.6. Определения функций¶Function definitions

Определение функции создаёт объект пользовательской функции (см. раздел Стандартная иерархия типов):

funcdef        ::=  [decorators] "def" funcname "(" [parameter_list] ")" ["->" expression] ":" suite
decorators     ::=  decorator+
decorator      ::=  "@" dotted_name ["(" [parameter_list [","]] ")"] NEWLINE
dotted_name    ::=  identifier ("." identifier)*
parameter_list ::=  (defparameter ",")*
                    ( "*" [parameter] ("," defparameter)* ["," "**" parameter]
                    | "**" parameter
                    | defparameter [","] )
parameter      ::=  identifier [":" expression]
defparameter   ::=  parameter ["=" expression]
funcname       ::=  identifier

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

Определение функции не выполняет тело функции; оно выполняется только при вызове функции. [3]

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

@f1(arg)
@f2
def func(): pass

эквивалентна

def func(): pass
func = f1(arg)(f2(func))

Когда один или несколько параметров имеют вид параметр = выражение, говорят, что функция имеет «значения параметров по умолчанию». Для параметра со значением по умолчанию соответствующий аргумент может быть опущен при вызове, и в этом случае подставляется значение параметра по умолчанию. Если параметр имеет значение по умолчанию, все последующие параметры до «*» также должны иметь значение по умолчанию – это синтаксическое ограничение, которое не отражено в грамматике.

Значения параметров по умолчанию вычисляются во время выполнения определения функции. Это означает, что выражение вычисляется один раз, когда функция определяется, и одно и то же «предварительно вычисленное» значение используется при каждом вызове. Это особенно важно понимать, когда параметр по умолчанию является изменяемым объектом, например списком или словарём: если функция изменяет объект (например, добавляя элемент в список), значение по умолчанию фактически изменяется. Обычно это не то, что предполагалось. Один из способов обойти это – использовать None в качестве значения по умолчанию и явно проверять его в теле функции, например:

def whats_on_the_telly(penguin=None):
    if penguin is None:
        penguin = []
    penguin.append("property of the zoo")
    return penguin

Семантика вызова функций подробно описана в разделе Вызовы. При вызове функции значения присваиваются всем параметрам, перечисленным в списке параметров, либо из позиционных аргументов, либо из именованных аргументов, либо из значений по умолчанию. Если присутствует форма «*identifier», она инициализируется кортежем, принимающим все лишние позиционные параметры, по умолчанию – пустой кортеж. Если присутствует форма «**identifier», она инициализируется новым словарём, принимающим все лишние именованные аргументы, по умолчанию – новый пустой словарь. Параметры после «*» или «*identifier» являются только именованными параметрами и могут передаваться только с помощью именованных аргументов.

Параметры могут иметь аннотации вида «: выражение», следующие за именем параметра. Любой параметр может иметь аннотацию, даже параметры вида *identifier или **identifier. Функции могут иметь аннотацию возврата вида «-> выражение» после списка параметров. Эти аннотации могут быть любым допустимым выражением Python и вычисляются при выполнении определения функции. Аннотации могут вычисляться в порядке, отличном от их расположения в исходном коде. Наличие аннотаций не меняет семантику функции. Значения аннотаций доступны как значения словаря, ключами которого являются имена параметров, в атрибуте __annotations__ объекта функции.

Также можно создавать анонимные функции (функции, не привязанные к имени) для немедленного использования в выражениях. Для этого используются лямбда-выражения, описанные в разделе Лямбды. Обратите внимание, что лямбда-выражение – это всего лишь сокращение для упрощённого определения функции; функция, определённая в операторе «def», может передаваться или присваиваться другому имени так же, как функция, определённая лямбда-выражением. Форма «def» на самом деле более мощная, поскольку допускает выполнение нескольких операторов и аннотаций.

Примечание программиста: Функции являются объектами первого класса. Оператор «def», выполненный внутри определения функции, определяет локальную функцию, которую можно вернуть или передать. Свободные переменные, используемые во вложенной функции, могут обращаться к локальным переменным функции, содержащей оператор def. Подробнее см. раздел Именование и связывание.

8.7. Определения классов¶Class definitions

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

classdef    ::=  [decorators] "class" classname [inheritance] ":" suite
inheritance ::=  "(" [parameter_list] ")"
classname   ::=  identifier

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

class Foo:
    pass

эквивалентна

class Foo(object):
    pass

Затем тело класса выполняется в новом фрейме выполнения (см. Naming and binding), используя только что созданное локальное пространство имён и исходное глобальное пространство имён. (Обычно тело содержит в основном определения функций.) Когда выполнение тела класса завершается, его фрейм выполнения отбрасывается, но локальное пространство имён сохраняется. [4] Затем создаётся объект класса с использованием списка наследования для базовых классов и сохранённого локального пространства имён для словаря атрибутов. Имя класса привязывается к этому объекту класса в исходном локальном пространстве имён.

Создание класса можно сильно настраивать с помощью метаклассов.

Классы также могут быть декорированы: так же, как и при декорировании функций,

@f1(arg)
@f2
class Foo: pass

эквивалентна

class Foo: pass
Foo = f1(arg)(f2(Foo))

Правила вычисления выражений декораторов те же, что и для декораторов функций. Результатом должен быть объект класса, который затем связывается с именем класса.

Примечание программиста: Переменные, определённые в определении класса, являются атрибутами класса; они разделяются экземплярами. Атрибуты экземпляра можно установить в методе с помощью self.name = value. Как атрибуты класса, так и атрибуты экземпляра доступны через запись «self.name», и при таком доступе атрибут экземпляра скрывает атрибут класса с тем же именем. Атрибуты класса могут использоваться как значения по умолчанию для атрибутов экземпляра, но использование изменяемых значений может привести к неожиданным результатам. Дескрипторы можно использовать для создания переменных экземпляра с различными деталями реализации.

Сноски