8. Составные утверждения¶

8.1. Оператор if¶

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

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

Он выбирает точно один из наборов, вычисляя выражения одно за другим, пока одно из них не будет признано истинным (смотрите раздел Булевы операции для определения значений true и false); затем выполняется этот набор (и никакая другая часть инструкции 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 вычисляется один раз; оно должно привести к объекту iterable. Для этой итерируемой переменной создается объект iterator. Затем первый элемент, предоставленный итератором, назначается целевому списку с использованием стандартных правил назначения (см. Операторы присваивания), и набор выполняется. Это повторяется для каждого элемента, предоставленного итератором. Когда итератор исчерпан, выполняется набор в предложении 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 используется для завершения выполнения блока методами, определенными контекстным менеджером (см. раздел С помощью контекстных менеджеров заявлений). Это позволяет инкапсулировать общие шаблоны использования 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 с одним «item» выполняется следующим образом:

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

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

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

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

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

   Примечание

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

6. Набор выполнен.

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

   Если из набора данных был выполнен выход из-за исключения, а возвращаемое значение из метода __exit__() было ложным, исключение создается повторно. Если возвращаемое значение равно 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 являются soft keywords.

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

patterns       ::=  open_sequence_pattern | pattern
pattern        ::=  as_pattern | or_pattern
closed_pattern ::=  | literal_pattern
                    | capture_pattern
                    | wildcard_pattern
                    | value_pattern
                    | group_pattern
                    | sequence_pattern
                    | mapping_pattern
                    | class_pattern

or_pattern ::=  "|".closed_pattern+

as_pattern ::=  or_pattern "as" capture_pattern

literal_pattern ::=  signed_number
                     | signed_number "+" NUMBER
                     | signed_number "-" NUMBER
                     | strings
                     | "None"
                     | "True"
                     | "False"
                     | signed_number: NUMBER | "-" NUMBER

capture_pattern ::=  !'_' NAME

wildcard_pattern ::=  '_'

value_pattern ::=  attr
attr          ::=  name_or_attr "." NAME
name_or_attr  ::=  attr | NAME

group_pattern ::=  "(" pattern ")"

sequence_pattern       ::=  "[" [maybe_sequence_pattern] "]"
                            | "(" [open_sequence_pattern] ")"
open_sequence_pattern  ::=  maybe_star_pattern "," [maybe_sequence_pattern]
maybe_sequence_pattern ::=  ",".maybe_star_pattern+ ","?
maybe_star_pattern     ::=  star_pattern | pattern
star_pattern           ::=  "*" (capture_pattern | wildcard_pattern)

mapping_pattern     ::=  "{" [items_pattern] "}"
items_pattern       ::=  ",".key_value_pattern+ ","?
key_value_pattern   ::=  (literal_pattern | value_pattern) ":" pattern
                         | double_star_pattern
double_star_pattern ::=  "**" capture_pattern

class_pattern       ::=  name_or_attr "(" [pattern_arguments ","?] ")"
pattern_arguments   ::=  positional_patterns ["," keyword_patterns]
                         | keyword_patterns
positional_patterns ::=  ",".pattern+
keyword_patterns    ::=  ",".keyword_pattern+
keyword_pattern     ::=  NAME "=" pattern

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

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

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

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

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

примерно эквивалентно

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

за исключением того, что исходная функция временно не привязана к имени func.

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

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

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

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

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

Также возможно создавать анонимные функции (функции, не привязанные к имени) для немедленного использования в выражениях. При этом используются лямбда-выражения, описанные в разделе Лямбды. Обратите внимание, что лямбда-выражение является всего лишь сокращением для упрощенного определения функции; функция, определенная в инструкции «def», может быть передана другим способом или присвоена другому имени точно так же, как функция, определенная с помощью лямбда-выражения. Форма «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__ нового класса. Обратите внимание, что это является надежным только сразу после создания класса и только для классов, которые были определены с использованием синтаксиса определения.

Создание класса может быть сильно изменено с помощью metaclasses.

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

@f1(arg)
@f2
class Foo: pass

примерно эквивалентно

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

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

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

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)