Составные операторы

8.1. Оператор if

Оператор if используется для условного выполнения:

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

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

8.2. Оператор while

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

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

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

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

8.3. Оператор for

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

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

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

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

Цикл for производит присваивания переменных в списке целей. Это перезаписывает все предыдущие присваивания этих переменных, включая те, которые были сделаны в теле цикла for:

for i in range(10):
    print(i)
    i = 5             # this will not affect the for-loop
                      # because i will be overwritten with the next
                      # index in the range

Имена в списке целей не удаляются по завершении цикла, но если последовательность пустая, им не будет присвоено значение циклом. Подсказка: встроенный тип range() представляет неизменяемые арифметические последовательности целых чисел. Например, при итерации range(3) последовательно получаются 0, 1 и 2.

8.4. Оператор try

Оператор try определяет обработчики исключений и/или код очистки для группы операторов:

try_stmt  ::=  try1_stmt | try2_stmt
try1_stmt ::=  "try" ":" suite
               ("except" [expression ["as" identifier]] ":" 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() возвращает кортеж из 3 элементов: класс исключения, экземпляр исключения и объект отслеживания стека (см. раздел Стандартная иерархия типов), определяющий точку в программе, где возникло исключение. Детали об исключении, полученные с помощью sys.exc_info(), восстанавливаются до их предыдущих значений при выходе из обработчика исключений:

>>> print(sys.exc_info())
(None, None, None)
>>> try:
...     raise TypeError
... except:
...     print(sys.exc_info())
...     try:
...          raise ValueError
...     except:
...         print(sys.exc_info())
...     print(sys.exc_info())
...
(<class 'TypeError'>, TypeError(), <traceback object at 0x10efad080>)
(<class 'ValueError'>, ValueError(), <traceback object at 0x10efad040>)
(<class 'TypeError'>, TypeError(), <traceback object at 0x10efad080>)
>>> print(sys.exc_info())
(None, None, None)

Необязательный оператор else выполняется, если поток управления покидает оператор try, не возникло исключение, и не был выполнен оператор return, continue или break. Исключения в блоке else не обрабатываются предшествующими операторами except.

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

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

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

Когда в блоке оператора try оператора try…finally выполняется оператор return, break или continue, также выполняется оператор finally «по пути выхода».

Значение возврата функции определяется последним выполненным оператором return. Поскольку оператор finally всегда выполняется, оператор return , выполненный в блоке finally , всегда будет последним выполненным:

>>> def foo():
...     try:
...         return 'try'
...     finally:
...         return 'finally'
...
>>> foo()
'finally'

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

8.5. Оператор with

Оператор with используется для обертывания выполнения блока методами, определенными менеджером контекста (см. раздел Менеджеры контекста оператора With). Это позволяет упаковать распространенные шаблоны try…except…finally для удобного повторного использования.

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

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

1. Вычисляется выражение контекста (выражение, заданное в with_item), чтобы получить менеджер контекста.
2. Загружается метод __enter__() менеджера контекста для последующего использования.
3. Загружается метод __exit__() менеджера контекста для последующего использования.
4. Вызывается метод __enter__() менеджера контекста.

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

   Примечание

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

6. Выполняется блок кода.

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

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

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

Следующий код:

with EXPRESSION as TARGET:
    SUITE

семантически эквивалентен:

manager = (EXPRESSION)
enter = type(manager).__enter__
exit = type(manager).__exit__
value = enter(manager)
hit_except = False

try:
    TARGET = value
    SUITE
except:
    hit_except = True
    if not exit(manager, *sys.exc_info()):
        raise
finally:
    if not hit_except:
        exit(manager, None, None, None)

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

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

семантически эквивалентен:

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

Также можно писать менеджеры контекста с несколькими элементами на нескольких строках, если элементы заключены в скобки. Например:

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

8.6. Оператор match

Оператор match используется для сопоставления шаблонов. Синтаксис:

match_stmt   ::=  'match' subject_expr ":" NEWLINE INDENT case_block+ DEDENT
subject_expr ::=  star_named_expression "," star_named_expressions?
                  | named_expression
case_block   ::=  'case' patterns [guard] ":" block

Сопоставление шаблонов принимает шаблон в качестве входных данных (после case) и значение субъекта (после match). Шаблон (который может содержать подшаблоны) сопоставляется со значением субъекта. Результаты:

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

Ключевые слова match и case являются мягкими ключевыми словами.

>>> flag = False
>>> match (100, 200):
...    case (100, 300):  # Mismatch: 200 != 300
...        print('Case 1')
...    case (100, 200) if flag:  # Successful match, but guard fails
...        print('Case 2')
...    case (100, y):  # Matches and binds y to 200
...        print(f'Case 3, y: {y}')
...    case _:  # Pattern not attempted
...        print('Case 4, I match anything!')
...
Case 3, y: 200

guard ::=  "if" named_expression

8.7. Определения функций

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

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

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

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

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

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

приблизительно эквивалентен

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

за исключением того, что исходная функция временно не привязана к имени 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» являются именованными параметрами и могут передаваться только с помощью именованных аргументов. Параметры до «/» являются параметрами только для позиции и могут передаваться только с помощью позиционных аргументов.

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

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

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

8.8. Определения классов

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

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

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

class Foo:
    pass

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

class Foo(object):
    pass

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

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

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

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

@f1(arg)
@f2
class Foo: pass

приблизительно эквивалентно

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

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

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

8.9. Корутины

async_funcdef ::=  [decorators] "async" "def" funcname "(" [parameter_list] ")"
                   ["->" expression] ":" suite

async def func(param1, param2):
    do_stuff()
    await some_coroutine()

async_for_stmt ::=  "async" for_stmt

async for TARGET in ITER:
    SUITE
else:
    SUITE2

iter = (ITER)
iter = type(iter).__aiter__(iter)
running = True

while running:
    try:
        TARGET = await type(iter).__anext__(iter)
    except StopAsyncIteration:
        running = False
    else:
        SUITE
else:
    SUITE2

async_with_stmt ::=  "async" with_stmt

async with EXPRESSION as TARGET:
    SUITE

manager = (EXPRESSION)
aenter = type(manager).__aenter__
aexit = type(manager).__aexit__
value = await aenter(manager)
hit_except = False

try:
    TARGET = value
    SUITE
except:
    hit_except = True
    if not await aexit(manager, *sys.exc_info()):
        raise
finally:
    if not hit_except:
        await aexit(manager, None, None, None)