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

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" starred_list ":" suite
              ["else" ":" suite]

Выражение starred_list вычисляется один раз; оно должно возвращать итерируемый объект. Для этого итерируемого объекта создается итератор. Первый элемент, предоставляемый итератором, присваивается списку целей по стандартным правилам присваивания (см. Операторы присваивания), и выполняется блок. Это повторяется для каждого элемента, предоставляемого итератором. Когда итератор исчерпан, выполняется блок в определении 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 | try3_stmt
try1_stmt ::=  "try" ":" suite
               ("except" [expression ["as" identifier]] ":" suite)+
               ["else" ":" suite]
               ["finally" ":" suite]
try2_stmt ::=  "try" ":" suite
               ("except" "*" expression ["as" identifier] ":" suite)+
               ["else" ":" suite]
               ["finally" ":" suite]
try3_stmt ::=  "try" ":" suite
               "finally" ":" suite

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

except E as N:
    foo

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

>>> print(sys.exception())
None
>>> try:
...     raise TypeError
... except:
...     print(repr(sys.exception()))
...     try:
...          raise ValueError
...     except:
...         print(repr(sys.exception()))
...     print(repr(sys.exception()))
...
TypeError()
ValueError()
TypeError()
>>> print(sys.exception())
None

>>> try:
...     raise ExceptionGroup("eg",
...         [ValueError(1), TypeError(2), OSError(3), OSError(4)])
... except* TypeError as e:
...     print(f'caught {type(e)} with nested {e.exceptions}')
... except* OSError as e:
...     print(f'caught {type(e)} with nested {e.exceptions}')
...
caught <class 'ExceptionGroup'> with nested (TypeError(2),)
caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))
  + Exception Group Traceback (most recent call last):
  |   File "<stdin>", line 2, in <module>
  | ExceptionGroup: eg
  +-+---------------- 1 ----------------
    | ValueError: 1
    +------------------------------------

>>> try:
...     raise BlockingIOError
... except* BlockingIOError as e:
...     print(repr(e))
...
ExceptionGroup('', (BlockingIOError()))

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

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

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__() всегда будет вызван. Таким образом, если ошибка произойдет во время присваивания целевым объектам, она будет обработана так же, как и ошибка, возникшая внутри блока.

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

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

   Если выполнение блока было прервано исключением, и возвращаемое значение из метода __exit__() было false, исключение переиздается. Если возвращаемое значение было true, исключение подавляется, и выполнение продолжается со следующей за оператором 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 Затем создаётся объект класса, используя список наследования для базовых классов и сохранённое локальное пространство имён для словаря атрибутов. Имя класса привязывается к этому объекту класса в исходном локальном пространстве имён.

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

Создание класса можно значительно настроить, используя метаклассы.

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

@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)