Составные инструкции

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 "<doctest default[0]>", line 2, in <module>
  |     raise ExceptionGroup("eg",
  |         [ValueError(1), TypeError(2), OSError(3), OSError(4)])
  | ExceptionGroup: eg (1 sub-exception)
  +-+---------------- 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__() будет вызван в любом случае. Поэтому ошибка, возникшая при присваивании целевому списку, обрабатывается так же, как ошибка, возникшая внутри блока. См. шаг 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

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

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 [type_params] "(" [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   ::= "*" [star_parameter] ("," defparameter)* ["," [parameter_star_kwargs]]
                              | "*" ("," defparameter)+ ["," [parameter_star_kwargs]]
                              | parameter_star_kwargs
parameter_star_kwargs     ::= "**" parameter [","]
parameter                 ::= identifier [":" expression]
star_parameter            ::= identifier [":" ["*"] expression]
defparameter              ::= parameter ["=" expression]
funcname                  ::= identifier

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

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

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

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

примерно эквивалентен следующему

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

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

Список параметров типа можно указать в квадратных скобках между именем функции и открывающей скобкой списка её параметров. Это указывает статическим средствам проверки типов, что функция является обобщённой. Во время выполнения параметры типа можно получить из атрибута __type_params__ функции. Подробнее см. раздел Обобщённые функции.

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

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

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

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

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

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

classdef    ::= [decorators] "class" classname [type_params] [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))

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

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

Примечание для программистов: Переменные, определённые в определении класса, являются атрибутами класса; они общие для всех экземпляров. Атрибуты экземпляра можно задавать в методе с помощью 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)

8.10. Списки параметров типов

type_params  ::= "[" type_param ("," type_param)* "]"
type_param   ::= typevar | typevartuple | paramspec
typevar      ::= identifier (":" expression)? ("=" expression)?
typevartuple ::= "*" identifier ("=" expression)?
paramspec    ::= "**" identifier ("=" expression)?

Функции (в том числе корутины), классы и псевдонимы типов могут содержать список параметров типов:

def max[T](args: list[T]) -> T:
    ...

async def amax[T](args: list[T]) -> T:
    ...

class Bag[T]:
    def __iter__(self) -> Iterator[T]:
        ...

    def add(self, arg: T) -> None:
        ...

type ListOrSet[T] = list[T] | set[T]

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

Параметры типов объявляются в квадратных скобках ([]) сразу после имени функции, класса или псевдонима типа. Параметры типов доступны в области видимости обобщённого объекта, но не за её пределами. Поэтому после объявления def func[T](): pass имя T недоступно в области видимости модуля. Ниже семантика обобщённых объектов описана подробнее. Область видимости параметров типов моделируется специальной функцией (технически — областью видимости аннотаций), которая оборачивает создание обобщённого объекта.

У обобщённых функций, классов и псевдонимов типов есть атрибут __type_params__ со списком их параметров типов.

Параметры типов бывают трёх видов:

• typing.TypeVar, вводимые обычным именем (например, T). Семантически для средства проверки типов это обозначает один тип.
• typing.TypeVarTuple, вводимые именем с одной звёздочкой в начале (например, *Ts). Семантически это обозначает кортеж из произвольного числа типов.
• typing.ParamSpec, вводимые именем с двумя звёздочками в начале (например, **P). Семантически это обозначает параметры вызываемого объекта.

Объявления typing.TypeVar могут задавать границы и ограничения: после двоеточия (:) указывается выражение. Одно выражение после двоеточия задаёт границу (например, T: int). Семантически это означает, что typing.TypeVar может представлять только типы, являющиеся подтипами этой границы. Кортеж выражений в скобках после двоеточия задаёт набор ограничений (например, T: (str, bytes)). Каждый элемент кортежа должен быть типом (это также не проверяется во время выполнения). Переменные типов с ограничениями могут принимать только один из типов, перечисленных в наборе ограничений.

У typing.TypeVar, объявленных с использованием синтаксиса списка параметров типов, границы и ограничения не вычисляются при создании обобщённого объекта, а только при явном обращении к атрибутам __bound__ и __constraints__. Для этого границы или ограничения вычисляются в отдельной области видимости аннотаций.

У typing.TypeVarTuple и typing.ParamSpec не может быть границ или ограничений.

У всех трёх видов параметров типов также может быть значение по умолчанию, используемое, если параметр типа не указан явно. Оно задаётся одним знаком равенства (=), за которым следует выражение. Как и границы и ограничения переменных типов, значение по умолчанию не вычисляется при создании объекта, а только при обращении к атрибуту __default__ параметра типа. Для этого значение по умолчанию вычисляется в отдельной области видимости аннотаций. Если для параметра типа не указано значение по умолчанию, атрибуту __default__ присваивается специальный объект-сентинел typing.NoDefault.

В следующем примере показаны все допустимые варианты объявления параметров типов:

def overly_generic[
   SimpleTypeVar,
   TypeVarWithDefault = int,
   TypeVarWithBound: int,
   TypeVarWithConstraints: (str, bytes),
   *SimpleTypeVarTuple = (int, float),
   **SimpleParamSpec = (str, bytearray),
](
   a: SimpleTypeVar,
   b: TypeVarWithDefault,
   c: TypeVarWithBound,
   d: Callable[SimpleParamSpec, TypeVarWithConstraints],
   *e: SimpleTypeVarTuple,
): ...

def func[T](arg: T): ...

annotation-def TYPE_PARAMS_OF_func():
    T = typing.TypeVar("T")
    def func(arg: T): ...
    func.__type_params__ = (T,)
    return func
func = TYPE_PARAMS_OF_func()

@decorator
def func[T: int, *Ts, **P](*args: *Ts, arg: Callable[P, T] = some_default):
    ...

DEFAULT_OF_arg = some_default

annotation-def TYPE_PARAMS_OF_func():

    annotation-def BOUND_OF_T():
        return int
    # In reality, BOUND_OF_T() is evaluated only on demand.
    T = typing.TypeVar("T", bound=BOUND_OF_T())

    Ts = typing.TypeVarTuple("Ts")
    P = typing.ParamSpec("P")

    def func(*args: *Ts, arg: Callable[P, T] = DEFAULT_OF_arg):
        ...

    func.__type_params__ = (T, Ts, P)
    return func
func = decorator(TYPE_PARAMS_OF_func())

class Bag[T]: ...

annotation-def TYPE_PARAMS_OF_Bag():
    T = typing.TypeVar("T")
    class Bag(typing.Generic[T]):
        __type_params__ = (T,)
        ...
    return Bag
Bag = TYPE_PARAMS_OF_Bag()

@decorator
class Bag(Base[T], arg=T): ...

annotation-def TYPE_PARAMS_OF_Bag():
    T = typing.TypeVar("T")
    class Bag(Base[T], typing.Generic[T], arg=T):
        __type_params__ = (T,)
        ...
    return Bag
Bag = decorator(TYPE_PARAMS_OF_Bag())

type ListOrSet[T] = list[T] | set[T]

annotation-def TYPE_PARAMS_OF_ListOrSet():
    T = typing.TypeVar("T")

    annotation-def VALUE_OF_ListOrSet():
        return list[T] | set[T]
    # In reality, the value is lazily evaluated
    return typing.TypeAliasType("ListOrSet", VALUE_OF_ListOrSet(), type_params=(T,))
ListOrSet = TYPE_PARAMS_OF_ListOrSet()