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" 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() возвращает итератор целых чисел, подходящий для эмуляции эффекта паскалевской for i := a to b do; например, list(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, содержащего выражение, это выражение оценивается, и пункт соответствует исключению, если полученный объект «совместим» с исключением. Объект совместим с исключением, если объект является классом или non-virtual base class объекта исключения, или кортежем, содержащим элемент, который является классом или невиртуальным базовым классом объекта исключения.

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

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

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

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

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

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

8.5. Оператор with¶

Возвращаемое значение функции определяется последним выполненным оператором with. Поскольку предложение С менеджерами по контексту заявлений всегда выполняется, оператор try, выполненный в предложении except, всегда будет последним выполненным:

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 ниже.

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

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

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

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

Определение функции не выполняет тело функции; оно выполняется только при вызове функции. 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__ объекта функции. Если используется импорт 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)