> **Источник:** https://python-all.ru/3.14/library/ast.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# `ast` – Абстрактные синтаксические деревья

**Исходный код:** [Lib/ast.py](https://python-all.ru/src/3.14/Lib/ast.py)

---

Модуль `ast` помогает приложениям Python обрабатывать деревья абстрактного синтаксиса языка Python. Абстрактный синтаксис может меняться от версии к версии; с помощью этого модуля можно программно узнать, как выглядит текущая грамматика.

Абстрактное синтаксическое дерево можно создать, передав [`ast.PyCF_ONLY_AST`](https://python-all.ru/3.14/library/ast.html#ast.PyCF_ONLY_AST) в качестве флага встроенной функции [`compile()`](https://python-all.ru/3.14/library/functions.html#compile) или используя вспомогательную функцию [`parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse) из этого модуля. Результатом будет дерево объектов, классы которых наследуют от [`ast.AST`](https://python-all.ru/3.14/library/ast.html#ast.AST). Абстрактное синтаксическое дерево можно скомпилировать в объект кода Python с помощью встроенной функции `compile()`.

## Абстрактная грамматика

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

```asdl
-- Встроенные типы ASDL:
-- идентификатор, целое, строка, константа

module Python
{
    mod = Module(stmt* body, type_ignore* type_ignores)
        | Interactive(stmt* body)
        | Expression(expr body)
        | FunctionType(expr* argtypes, expr returns)

    stmt = FunctionDef(identifier name, arguments args,
                       stmt* body, expr* decorator_list, expr? returns,
                       string? type_comment, type_param* type_params)
          | AsyncFunctionDef(identifier name, arguments args,
                             stmt* body, expr* decorator_list, expr? returns,
                             string? type_comment, type_param* type_params)

          | ClassDef(identifier name,
             expr* bases,
             keyword* keywords,
             stmt* body,
             expr* decorator_list,
             type_param* type_params)
          | Return(expr? value)

          | Delete(expr* targets)
          | Assign(expr* targets, expr value, string? type_comment)
          | TypeAlias(expr name, type_param* type_params, expr value)
          | AugAssign(expr target, operator op, expr value)
          -- 'simple' указывает, что аннотируется простое имя без скобок
          | AnnAssign(expr target, expr annotation, expr? value, int simple)

          -- используется 'orelse', так как else – ключевое слово в целевых языках
          | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
          | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
          | While(expr test, stmt* body, stmt* orelse)
          | If(expr test, stmt* body, stmt* orelse)
          | With(withitem* items, stmt* body, string? type_comment)
          | AsyncWith(withitem* items, stmt* body, string? type_comment)

          | Match(expr subject, match_case* cases)

          | Raise(expr? exc, expr? cause)
          | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
          | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
          | Assert(expr test, expr? msg)

          | Import(alias* names)
          | ImportFrom(identifier? module, alias* names, int? level)

          | Global(identifier* names)
          | Nonlocal(identifier* names)
          | Expr(expr value)
          | Pass | Break | Continue

          -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером
          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

          -- BoolOp() может использовать left и right?
    expr = BoolOp(boolop op, expr* values)
         | NamedExpr(expr target, expr value)
         | BinOp(expr left, operator op, expr right)
         | UnaryOp(unaryop op, expr operand)
         | Lambda(arguments args, expr body)
         | IfExp(expr test, expr body, expr orelse)
         | Dict(expr?* keys, expr* values)
         | Set(expr* elts)
         | ListComp(expr elt, comprehension* generators)
         | SetComp(expr elt, comprehension* generators)
         | DictComp(expr key, expr value, comprehension* generators)
         | GeneratorExp(expr elt, comprehension* generators)
         -- грамматика ограничивает, где могут встречаться выражения yield
         | Await(expr value)
         | Yield(expr? value)
         | YieldFrom(expr value)
         -- нужны последовательности для сравнения, чтобы различать
         -- x < 4 < 3 and (x < 4) < 3
         | Compare(expr left, cmpop* ops, expr* comparators)
         | Call(expr func, expr* args, keyword* keywords)
         | FormattedValue(expr value, int conversion, expr? format_spec)
         | Interpolation(expr value, constant str, int conversion, expr? format_spec)
         | JoinedStr(expr* values)
         | TemplateStr(expr* values)
         | Constant(constant value, string? kind)

         -- следующее выражение может появляться в контексте присваивания
         | Attribute(expr value, identifier attr, expr_context ctx)
         | Subscript(expr value, expr slice, expr_context ctx)
         | Starred(expr value, expr_context ctx)
         | Name(identifier id, expr_context ctx)
         | List(expr* elts, expr_context ctx)
         | Tuple(expr* elts, expr_context ctx)

         -- может встречаться только в Subscript
         | Slice(expr? lower, expr? upper, expr? step)

          -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером
          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    expr_context = Load | Store | Del

    boolop = And | Or

    operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift
                 | RShift | BitOr | BitXor | BitAnd | FloorDiv

    unaryop = Invert | Not | UAdd | USub

    cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn

    comprehension = (expr target, expr iter, expr* ifs, int is_async)

    excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)
                    attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,
                 expr?* kw_defaults, arg? kwarg, expr* defaults)

    arg = (identifier arg, expr? annotation, string? type_comment)
           attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    -- ключевые аргументы, переданные вызову (идентификатор NULL для **kwargs)
    keyword = (identifier? arg, expr value)
               attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    -- имя импорта с необязательным псевдонимом 'as'
    alias = (identifier name, identifier? asname)
             attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    withitem = (expr context_expr, expr? optional_vars)

    match_case = (pattern pattern, expr? guard, stmt* body)

    pattern = MatchValue(expr value)
            | MatchSingleton(constant value)
            | MatchSequence(pattern* patterns)
            | MatchMapping(expr* keys, pattern* patterns, identifier? rest)
            | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)

            | MatchStar(identifier? name)
            -- необязательный параметр "rest" MatchMapping обрабатывает захват дополнительных ключей отображения

            | MatchAs(pattern? pattern, identifier? name)
            | MatchOr(pattern* patterns)

             attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)

    type_ignore = TypeIgnore(int lineno, string tag)

    type_param = TypeVar(identifier name, expr? bound, expr? default_value)
               | ParamSpec(identifier name, expr? default_value)
               | TypeVarTuple(identifier name, expr? default_value)
               attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)
}
```

## Классы узлов

#### `class ast.AST`

Это базовый класс для всех узлов AST. Реальные классы узлов унаследованы из файла `Parser/Python.asdl`, который воспроизведён [выше](https://python-all.ru/3.14/library/ast.html#abstract-grammar). Они определены в C-модуле `_ast` и повторно экспортируются в `ast`.

Для каждого символа левой части абстрактной грамматики определён один класс (например, `ast.stmt` или `ast.expr`). Кроме того, для каждого конструктора правой части определён один класс; эти классы наследуют от классов для деревьев левой части. Например, [`ast.BinOp`](https://python-all.ru/3.14/library/ast.html#ast.BinOp) наследует от `ast.expr`. Для продукционных правил с альтернативами (так называемых «сумм») класс левой части является абстрактным: создаются только экземпляры конкретных узлов-конструкторов.

#### `_fields`

Каждый конкретный класс имеет атрибут `_fields`, который содержит имена всех дочерних узлов.

Каждый экземпляр конкретного класса имеет по одному атрибуту для каждого дочернего узла, тип которого определён в грамматике. Например, экземпляры [`ast.BinOp`](https://python-all.ru/3.14/library/ast.html#ast.BinOp) имеют атрибут `left` типа `ast.expr`.

Если эти атрибуты помечены как необязательные в грамматике (с помощью вопросительного знака), значением может быть `None`. Если атрибуты могут иметь ноль или более значений (помечены звёздочкой), значения представляются в виде списков Python. Все возможные атрибуты должны присутствовать и иметь корректные значения при компиляции AST с помощью [`compile()`](https://python-all.ru/3.14/library/functions.html#compile).

#### `_field_types`

Атрибут `_field_types` каждого конкретного класса представляет собой словарь, отображающий имена полей (как указано в [`_fields`](https://python-all.ru/3.14/library/ast.html#ast.AST._fields)) в их типы.

```pycon
>>> ast.TypeVar._field_types
{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr | None}
```

Добавлено в версии 3.13.

#### `lineno`

#### `col_offset`

#### `end_lineno`

#### `end_col_offset`

Экземпляры подклассов `ast.expr` и `ast.stmt` имеют атрибуты [`lineno`](https://python-all.ru/3.14/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.14/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.14/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.14/library/ast.html#ast.AST.end_col_offset). Атрибуты `lineno` и `end_lineno` – это номер первой и последней строки исходного текста (нумерация с 1, то есть первая строка – строка 1), а `col_offset` и `end_col_offset` – соответствующие смещения в байтах UTF-8 от первого и последнего токенов, породивших узел. Смещение UTF-8 записывается, потому что парсер использует UTF-8 внутри.

Обратите внимание, что конечные позиции не требуются компилятором и поэтому являются необязательными. Смещение конца находится *после* последнего символа, например, можно получить фрагмент исходного кода узла выражения из одной строки с помощью `source_line[node.col_offset : node.end_col_offset]`.

Конструктор класса `ast.T` разбирает свои аргументы следующим образом:

- Если есть позиционные аргументы, их должно быть столько же, сколько элементов в `T._fields`; они будут присвоены как атрибуты с этими именами.
- Если есть ключевые аргументы, они установят атрибуты с теми же именами в указанные значения.

Например, чтобы создать и заполнить узел [`ast.UnaryOp`](https://python-all.ru/3.14/library/ast.html#ast.UnaryOp), можно использовать

```python
node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),
                   lineno=0, col_offset=0)
```

Если поле, которое является необязательным в грамматике, опущено в конструкторе, оно по умолчанию равно `None`. Если опущено поле-список, оно по умолчанию равно пустому списку. Если опущено поле типа `ast.expr_context`, оно по умолчанию равно [`Load()`](https://python-all.ru/3.14/library/ast.html#ast.Load). Если опущено любое другое поле, возбуждается [`DeprecationWarning`](https://python-all.ru/3.14/library/exceptions.html#DeprecationWarning) и узел AST не будет иметь этого поля. В Python 3.15 это условие будет вызывать ошибку.

Изменено в версии 3.8: Класс [`ast.Constant`](https://python-all.ru/3.14/library/ast.html#ast.Constant) теперь используется для всех констант.

Изменено в версии 3.9: Простые индексы представляются своим значением, расширенные срезы представляются кортежами.

Изменено в версии 3.13: Конструкторы узлов AST были изменены, чтобы предоставлять разумные значения по умолчанию для пропущенных полей: необязательные поля теперь по умолчанию равны `None`, поля-списки по умолчанию равны пустому списку, а поля типа `ast.expr_context` по умолчанию равны [`Load()`](https://python-all.ru/3.14/library/ast.html#ast.Load). Ранее пропущенные атрибуты отсутствовали у сконструированных узлов (при обращении к ним возбуждалось [`AttributeError`](https://python-all.ru/3.14/library/exceptions.html#AttributeError)).

Изменено в версии 3.14: В выводе [`__repr__()`](https://python-all.ru/3.14/reference/datamodel.html#object.__repr__) узлов [`AST`](https://python-all.ru/3.14/library/ast.html#ast.AST) теперь содержатся значения полей узла.

Устарело с версии 3.8, удалено в версии 3.14: В предыдущих версиях Python были доступны классы AST `ast.Num`, `ast.Str`, `ast.Bytes`, `ast.NameConstant` и `ast.Ellipsis`, которые объявлялись устаревшими в Python 3.8. Эти классы были удалены в Python 3.14, а их функциональность заменена на [`ast.Constant`](https://python-all.ru/3.14/library/ast.html#ast.Constant).

Устарело с версии 3.9: Старые классы `ast.Index` и `ast.ExtSlice` всё ещё доступны, но будут удалены в будущих выпусках Python. При этом при их создании будет возвращён экземпляр другого класса.

Устарело с версии 3.13, будет удалено в версии 3.15: В предыдущих версиях Python допускалось создание узлов AST с отсутствующими обязательными полями. Кроме того, конструкторы узлов AST принимали произвольные ключевые аргументы, которые устанавливались как атрибуты узла AST, даже если они не соответствовали ни одному из полей узла AST. Это поведение устарело и будет удалено в Python 3.15.

> **Примечание**
>
> Описания конкретных классов узлов, приведённые здесь, изначально были адаптированы из замечательного проекта [Green Tree Snakes](https://python-all.ru/3.14/library/ast.html) и всех его участников.

### Корневые узлы

#### `class ast.Module(body, type_ignores)`

A Python module, as with [file input](https://python-all.ru/3.14/reference/toplevel_components.html#file-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse) in the default `"exec"` *mode*.

`body` is a [`list`](https://python-all.ru/3.14/library/stdtypes.html#list) of the module’s [Statements](https://python-all.ru/3.14/library/ast.html#ast-statements).

`type_ignores` – это список [`list`](https://python-all.ru/3.14/library/stdtypes.html#list) комментариев об игнорировании типов в модуле; подробнее см. в [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse).

```pycon
>>> print(ast.dump(ast.parse('x = 1'), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Name(id='x', ctx=Store())],
            value=Constant(value=1))])
```

#### `class ast.Expression(body)`

A single Python [expression input](https://python-all.ru/3.14/reference/toplevel_components.html#expression-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse) when *mode* is `"eval"`.

`body` is a single node, one of the [expression types](https://python-all.ru/3.14/library/ast.html#ast-expressions).

```pycon
>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))
Expression(
    body=Constant(value=123))
```

#### `class ast.Interactive(body)`

A single [interactive input](https://python-all.ru/3.14/reference/toplevel_components.html#interactive), like in [Interactive Mode](https://python-all.ru/3.14/tutorial/appendix.html#tut-interac). Node type generated by [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse) when *mode* is `"single"`.

`body` is a [`list`](https://python-all.ru/3.14/library/stdtypes.html#list) of [statement nodes](https://python-all.ru/3.14/library/ast.html#ast-statements).

```pycon
>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))
Interactive(
    body=[
        Assign(
            targets=[
                Name(id='x', ctx=Store())],
            value=Constant(value=1)),
        Assign(
            targets=[
                Name(id='y', ctx=Store())],
            value=Constant(value=2))])
```

#### `class ast.FunctionType(argtypes, returns)`

A representation of an old-style type comments for functions, as Python versions prior to 3.5 didn’t support [**PEP 484**](https://python-all.ru/3.14/library/ast.html) annotations. Node type generated by [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse) when *mode* is `"func_type"`.

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

```python
def sum_two_number(a, b):
    # type: (int, int) -> int
    return a + b
```

`argtypes` is a [`list`](https://python-all.ru/3.14/library/stdtypes.html#list) of [expression nodes](https://python-all.ru/3.14/library/ast.html#ast-expressions).

`returns` is a single [expression node](https://python-all.ru/3.14/library/ast.html#ast-expressions).

```pycon
>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))
FunctionType(
    argtypes=[
        Name(id='int', ctx=Load()),
        Name(id='str', ctx=Load())],
    returns=Subscript(
        value=Name(id='List', ctx=Load()),
        slice=Name(id='int', ctx=Load()),
        ctx=Load()))
```

Добавлено в версии 3.8.

### Литералы

#### `class ast.Constant(value, kind)`

Постоянное значение. Атрибут `value` `Constant` литерала содержит представляемый объект Python. Представленными значениями могут быть экземпляры [`str`](https://python-all.ru/3.14/library/stdtypes.html#str), [`bytes`](https://python-all.ru/3.14/library/stdtypes.html#bytes), [`int`](https://python-all.ru/3.14/library/functions.html#int), [`float`](https://python-all.ru/3.14/library/functions.html#float), [`complex`](https://python-all.ru/3.14/library/functions.html#complex) и [`bool`](https://python-all.ru/3.14/library/functions.html#bool), а также константы [`None`](https://python-all.ru/3.14/library/constants.html#None) и [`Ellipsis`](https://python-all.ru/3.14/library/constants.html#Ellipsis).

Атрибут `kind` – необязательная строка. Для строковых литералов с префиксом `u` значение `kind` устанавливается в `'u'`. Для всех остальных констант `kind` равно `None`.

```pycon
>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))
Expression(
    body=Constant(value=123))
>>> print(ast.dump(ast.parse("u'hello'", mode='eval'), indent=4))
Expression(
    body=Constant(value='hello', kind='u'))
```

#### `class ast.FormattedValue(value, conversion, format_spec)`

Узел, представляющий одно поле форматирования в f-строке. Если строка содержит только одно поле форматирования и больше ничего, узел может быть изолированным; в противном случае он встречается внутри [`JoinedStr`](https://python-all.ru/3.14/library/ast.html#ast.JoinedStr).

- `value` – это любой узел выражения (например, литерал, переменная или вызов функции).
- `conversion` – целое число:

  - -1: без форматирования
  - 97 (`ord('a')`): форматирование `!a` [`ASCII`](https://python-all.ru/3.14/library/functions.html#ascii)
  - 114 (`ord('r')`): форматирование `!r` [`repr()`](https://python-all.ru/3.14/library/functions.html#repr)
  - 115 (`ord('s')`): форматирование `!s` [`string`](https://python-all.ru/3.14/library/stdtypes.html#str)
- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.14/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно.

#### `class ast.JoinedStr(values)`

F-строка, содержащая последовательность [`FormattedValue`](https://python-all.ru/3.14/library/ast.html#ast.FormattedValue) и [`Constant`](https://python-all.ru/3.14/library/ast.html#ast.Constant) узлов.

```pycon
>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))
Expression(
    body=JoinedStr(
        values=[
            Constant(value='sin('),
            FormattedValue(
                value=Name(id='a', ctx=Load()),
                conversion=-1),
            Constant(value=') is '),
            FormattedValue(
                value=Call(
                    func=Name(id='sin', ctx=Load()),
                    args=[
                        Name(id='a', ctx=Load())]),
                conversion=-1,
                format_spec=JoinedStr(
                    values=[
                        Constant(value='.3')]))]))
```

#### `class ast.TemplateStr(values, /)`

Добавлено в версии 3.14.

Узел, представляющий литерал шаблонной строки, содержащий последовательность [`Interpolation`](https://python-all.ru/3.14/library/ast.html#ast.Interpolation) и [`Constant`](https://python-all.ru/3.14/library/ast.html#ast.Constant) узлов. Эти узлы могут быть в любом порядке и не обязаны чередоваться.

```pycon
>>> expr = ast.parse('t"{name} finished {place:ordinal}"', mode='eval')
>>> print(ast.dump(expr, indent=4))
Expression(
    body=TemplateStr(
        values=[
            Interpolation(
                value=Name(id='name', ctx=Load()),
                str='name',
                conversion=-1),
            Constant(value=' finished '),
            Interpolation(
                value=Name(id='place', ctx=Load()),
                str='place',
                conversion=-1,
                format_spec=JoinedStr(
                    values=[
                        Constant(value='ordinal')]))]))
```

#### `class ast.Interpolation(value, str, conversion, format_spec=None)`

Добавлено в версии 3.14.

Узел, представляющий одно поле интерполяции в литерале шаблонной строки.

- `value` – любой узел выражения (например, литерал, переменная или вызов функции). Это имеет то же значение, что и `FormattedValue.value`.
- `str` – константа, содержащая текст выражения интерполяции.

  Если `str` установлен в `None`, то `value` используется для генерации кода при вызове [`ast.unparse()`](https://python-all.ru/3.14/library/ast.html#ast.unparse). Это больше не гарантирует, что сгенерированный код идентичен исходному, и предназначено для генерации кода.
- `conversion` – целое число:

  - -1: без преобразования
  - 97 (`ord('a')`): преобразование `!a` [`ASCII`](https://python-all.ru/3.14/library/functions.html#ascii)
  - 114 (`ord('r')`): преобразование `!r` [`repr()`](https://python-all.ru/3.14/library/functions.html#repr)
  - 115 (`ord('s')`): преобразование `!s` [`string`](https://python-all.ru/3.14/library/stdtypes.html#str)

  Это имеет то же значение, что и `FormattedValue.conversion`.
- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.14/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно. Это имеет то же значение, что и `FormattedValue.format_spec`.

#### `class ast.List(elts, ctx)`

#### `class ast.Tuple(elts, ctx)`

Список или кортеж. `elts` содержит список узлов, представляющих элементы. `ctx` равен [`Store`](https://python-all.ru/3.14/library/ast.html#ast.Store), если контейнер является целью присваивания (т.е. `(x,y)=something`), и [`Load`](https://python-all.ru/3.14/library/ast.html#ast.Load) в противном случае.

```pycon
>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))
Expression(
    body=List(
        elts=[
            Constant(value=1),
            Constant(value=2),
            Constant(value=3)],
        ctx=Load()))
>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))
Expression(
    body=Tuple(
        elts=[
            Constant(value=1),
            Constant(value=2),
            Constant(value=3)],
        ctx=Load()))
```

#### `class ast.Set(elts)`

Множество. `elts` содержит список узлов, представляющих элементы множества.

```pycon
>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))
Expression(
    body=Set(
        elts=[
            Constant(value=1),
            Constant(value=2),
            Constant(value=3)]))
```

#### `class ast.Dict(keys, values)`

Словарь. `keys` и `values` содержат списки узлов, представляющих ключи и значения соответственно, в соответствующем порядке (то, что было бы возвращено при вызове `dictionary.keys()` и `dictionary.values()`).

При распаковке словаря с помощью литералов словаря выражение, которое нужно раскрыть, помещается в список `values`, а `None` – на соответствующую позицию в `keys`.

```pycon
>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))
Expression(
    body=Dict(
        keys=[
            Constant(value='a'),
            None],
        values=[
            Constant(value=1),
            Name(id='d', ctx=Load())]))
```

### Переменные

#### `class ast.Name(id, ctx)`

Имя переменной. `id` содержит имя в виде строки, а `ctx` – один из следующих типов.

#### `class ast.Load`

#### `class ast.Store`

#### `class ast.Del`

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

```pycon
>>> print(ast.dump(ast.parse('a'), indent=4))
Module(
    body=[
        Expr(
            value=Name(id='a', ctx=Load()))])

>>> print(ast.dump(ast.parse('a = 1'), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Name(id='a', ctx=Store())],
            value=Constant(value=1))])

>>> print(ast.dump(ast.parse('del a'), indent=4))
Module(
    body=[
        Delete(
            targets=[
                Name(id='a', ctx=Del())])])
```

#### `class ast.Starred(value, ctx)`

Ссылка на переменную `*var`. В `value` хранится переменная, обычно узел [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name). Этот тип необходимо использовать при построении узла [`Call`](https://python-all.ru/3.14/library/ast.html#ast.Call) с помощью `*args`.

```pycon
>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Tuple(
                    elts=[
                        Name(id='a', ctx=Store()),
                        Starred(
                            value=Name(id='b', ctx=Store()),
                            ctx=Store())],
                    ctx=Store())],
            value=Name(id='it', ctx=Load()))])
```

### Выражения

#### `class ast.Expr(value)`

Когда выражение, например вызов функции, выступает в роли самостоятельного оператора и его возвращаемое значение не используется и не сохраняется, оно помещается в этот контейнер. `value` содержит один из остальных узлов этого раздела: узел [`Constant`](https://python-all.ru/3.14/library/ast.html#ast.Constant), узел [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name), [`Lambda`](https://python-all.ru/3.14/library/ast.html#ast.Lambda), [`Yield`](https://python-all.ru/3.14/library/ast.html#ast.Yield) или [`YieldFrom`](https://python-all.ru/3.14/library/ast.html#ast.YieldFrom).

```pycon
>>> print(ast.dump(ast.parse('-a'), indent=4))
Module(
    body=[
        Expr(
            value=UnaryOp(
                op=USub(),
                operand=Name(id='a', ctx=Load())))])
```

#### `class ast.UnaryOp(op, operand)`

Унарная операция. `op` – оператор, а `operand` – любой узел выражения.

#### `class ast.UAdd`

#### `class ast.USub`

#### `class ast.Not`

#### `class ast.Invert`

Токены унарных операторов. `Not` – ключевое слово `not`, `Invert` – оператор `~`.

```pycon
>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))
Expression(
    body=UnaryOp(
        op=Not(),
        operand=Name(id='x', ctx=Load())))
```

#### `class ast.BinOp(left, op, right)`

Бинарная операция (например, сложение или деление). `op` – оператор, а `left` и `right` – любые узлы выражений.

```pycon
>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))
Expression(
    body=BinOp(
        left=Name(id='x', ctx=Load()),
        op=Add(),
        right=Name(id='y', ctx=Load())))
```

#### `class ast.Add`

#### `class ast.Sub`

#### `class ast.Mult`

#### `class ast.Div`

#### `class ast.FloorDiv`

#### `class ast.Mod`

#### `class ast.Pow`

#### `class ast.LShift`

#### `class ast.RShift`

#### `class ast.BitOr`

#### `class ast.BitXor`

#### `class ast.BitAnd`

#### `class ast.MatMult`

Токены бинарных операторов.

#### `class ast.BoolOp(op, values)`

Логическая операция – 'or' или 'and'. `op` – это [`Or`](https://python-all.ru/3.14/library/ast.html#ast.Or) или [`And`](https://python-all.ru/3.14/library/ast.html#ast.And). `values` – участвующие значения. Последовательные операции с одним и тем же оператором, например `a or b or c`, сводятся в один узел с несколькими значениями.

Это не включает `not`, который является [`UnaryOp`](https://python-all.ru/3.14/library/ast.html#ast.UnaryOp).

```pycon
>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))
Expression(
    body=BoolOp(
        op=Or(),
        values=[
            Name(id='x', ctx=Load()),
            Name(id='y', ctx=Load())]))
```

#### `class ast.And`

#### `class ast.Or`

Токены логических операторов.

#### `class ast.Compare(left, ops, comparators)`

Сравнение двух или более значений. `left` – первое значение в сравнении, `ops` – список операторов, а `comparators` – список значений после первого элемента сравнения.

```pycon
>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))
Expression(
    body=Compare(
        left=Constant(value=1),
        ops=[
            LtE(),
            Lt()],
        comparators=[
            Name(id='a', ctx=Load()),
            Constant(value=10)]))
```

#### `class ast.Eq`

#### `class ast.NotEq`

#### `class ast.Lt`

#### `class ast.LtE`

#### `class ast.Gt`

#### `class ast.GtE`

#### `class ast.Is`

#### `class ast.IsNot`

#### `class ast.In`

#### `class ast.NotIn`

Токены операторов сравнения.

#### `class ast.Call(func, args, keywords)`

Вызов функции. `func` – это функция; обычно это объект [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name) или [`Attribute`](https://python-all.ru/3.14/library/ast.html#ast.Attribute). Об аргументах:

- `args` содержит список аргументов, переданных по позиции.
- `keywords` содержит список объектов [`keyword`](https://python-all.ru/3.14/library/ast.html#ast.keyword), представляющих аргументы, переданные по ключевому слову.

Аргументы `args` и `keywords` необязательны и по умолчанию равны пустым спискам.

```pycon
>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))
Expression(
    body=Call(
        func=Name(id='func', ctx=Load()),
        args=[
            Name(id='a', ctx=Load()),
            Starred(
                value=Name(id='d', ctx=Load()),
                ctx=Load())],
        keywords=[
            keyword(
                arg='b',
                value=Name(id='c', ctx=Load())),
            keyword(
                value=Name(id='e', ctx=Load()))]))
```

#### `class ast.keyword(arg, value)`

Именованный аргумент вызова функции или определения класса. `arg` – это необработанная строка с именем параметра, `value` – узел, который нужно передать.

#### `class ast.IfExp(test, body, orelse)`

Выражение, например `a if b else c`. Каждое поле содержит один узел, поэтому в следующем примере все три являются узлами [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name).

```pycon
>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))
Expression(
    body=IfExp(
        test=Name(id='b', ctx=Load()),
        body=Name(id='a', ctx=Load()),
        orelse=Name(id='c', ctx=Load())))
```

#### `class ast.Attribute(value, attr, ctx)`

Доступ к атрибуту, например `d.keys`. `value` – это узел, обычно [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name). `attr` – это строка с именем атрибута, а `ctx` – [`Load`](https://python-all.ru/3.14/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.14/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.14/library/ast.html#ast.Del) в зависимости от того, как используется атрибут.

```pycon
>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))
Expression(
    body=Attribute(
        value=Name(id='snake', ctx=Load()),
        attr='colour',
        ctx=Load()))
```

#### `class ast.NamedExpr(target, value)`

Именованное выражение. Этот узел AST создаётся оператором присваивания (также известным как оператор «морж»). В отличие от узла [`Assign`](https://python-all.ru/3.14/library/ast.html#ast.Assign), где первый аргумент может быть несколькими узлами, в данном случае и `target`, и `value` должны быть одиночными узлами.

```pycon
>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))
Expression(
    body=NamedExpr(
        target=Name(id='x', ctx=Store()),
        value=Constant(value=4)))
```

Добавлено в версии 3.8.

#### Индексирование

#### `class ast.Subscript(value, slice, ctx)`

Индексация, такая как `l[1]`. `value` – индексируемый объект (обычно последовательность или отображение). `slice` – это индекс, срез или ключ. Оно может быть [`Tuple`](https://python-all.ru/3.14/library/ast.html#ast.Tuple) и содержать [`Slice`](https://python-all.ru/3.14/library/ast.html#ast.Slice). `ctx` является [`Load`](https://python-all.ru/3.14/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.14/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.14/library/ast.html#ast.Del) в зависимости от выполняемого действия при индексации.

```pycon
>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))
Expression(
    body=Subscript(
        value=Name(id='l', ctx=Load()),
        slice=Tuple(
            elts=[
                Slice(
                    lower=Constant(value=1),
                    upper=Constant(value=2)),
                Constant(value=3)],
            ctx=Load()),
        ctx=Load()))
```

#### `class ast.Slice(lower, upper, step)`

Обычный срез (в виде `lower:upper` или `lower:upper:step`). Может встречаться только внутри поля *slice* узла [`Subscript`](https://python-all.ru/3.14/library/ast.html#ast.Subscript), либо напрямую, либо как элемент [`Tuple`](https://python-all.ru/3.14/library/ast.html#ast.Tuple).

```pycon
>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))
Expression(
    body=Subscript(
        value=Name(id='l', ctx=Load()),
        slice=Slice(
            lower=Constant(value=1),
            upper=Constant(value=2)),
        ctx=Load()))
```

#### Генераторы коллекций

#### `class ast.ListComp(elt, generators)`

#### `class ast.SetComp(elt, generators)`

#### `class ast.GeneratorExp(elt, generators)`

#### `class ast.DictComp(key, value, generators)`

Генераторы списков и множеств, генераторные выражения и генераторы словарей. `elt` (или `key` и `value`) – это один узел, представляющий часть, которая будет вычисляться для каждого элемента.

`generators` – это список узлов [`comprehension`](https://python-all.ru/3.14/library/ast.html#ast.comprehension).

```pycon
>>> print(ast.dump(
...     ast.parse('[x for x in numbers]', mode='eval'),
...     indent=4,
... ))
Expression(
    body=ListComp(
        elt=Name(id='x', ctx=Load()),
        generators=[
            comprehension(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers', ctx=Load()),
                is_async=0)]))
>>> print(ast.dump(
...     ast.parse('{x: x**2 for x in numbers}', mode='eval'),
...     indent=4,
... ))
Expression(
    body=DictComp(
        key=Name(id='x', ctx=Load()),
        value=BinOp(
            left=Name(id='x', ctx=Load()),
            op=Pow(),
            right=Constant(value=2)),
        generators=[
            comprehension(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers', ctx=Load()),
                is_async=0)]))
>>> print(ast.dump(
...     ast.parse('{x for x in numbers}', mode='eval'),
...     indent=4,
... ))
Expression(
    body=SetComp(
        elt=Name(id='x', ctx=Load()),
        generators=[
            comprehension(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers', ctx=Load()),
                is_async=0)]))
```

#### `class ast.comprehension(target, iter, ifs, is_async)`

Одно предложение `for` в генераторе коллекции. `target` – это ссылка, используемая для каждого элемента (обычно узел [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name) или [`Tuple`](https://python-all.ru/3.14/library/ast.html#ast.Tuple)). `iter` – объект, по которому выполняется итерация. `ifs` – список проверочных выражений: каждое предложение `for` может содержать несколько `ifs`.

`is_async` указывает, что генератор коллекции является асинхронным (использует `async for` вместо `for`). Значение – целое число (0 или 1).

```pycon
>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),
...                indent=4)) # несколько включений в одном
Expression(
    body=ListComp(
        elt=Call(
            func=Name(id='ord', ctx=Load()),
            args=[
                Name(id='c', ctx=Load())]),
        generators=[
            comprehension(
                target=Name(id='line', ctx=Store()),
                iter=Name(id='file', ctx=Load()),
                is_async=0),
            comprehension(
                target=Name(id='c', ctx=Store()),
                iter=Name(id='line', ctx=Load()),
                is_async=0)]))

>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),
...                indent=4)) # выражение-генератор
Expression(
    body=GeneratorExp(
        elt=BinOp(
            left=Name(id='n', ctx=Load()),
            op=Pow(),
            right=Constant(value=2)),
        generators=[
            comprehension(
                target=Name(id='n', ctx=Store()),
                iter=Name(id='it', ctx=Load()),
                ifs=[
                    Compare(
                        left=Name(id='n', ctx=Load()),
                        ops=[
                            Gt()],
                        comparators=[
                            Constant(value=5)]),
                    Compare(
                        left=Name(id='n', ctx=Load()),
                        ops=[
                            Lt()],
                        comparators=[
                            Constant(value=10)])],
                is_async=0)]))

>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),
...                indent=4)) # асинхронное включение
Expression(
    body=ListComp(
        elt=Name(id='i', ctx=Load()),
        generators=[
            comprehension(
                target=Name(id='i', ctx=Store()),
                iter=Name(id='soc', ctx=Load()),
                is_async=1)]))
```

### Инструкции

#### `class ast.Assign(targets, value, type_comment)`

Присваивание. `targets` – список узлов, а `value` – один узел.

Несколько узлов в `targets` обозначают присваивание одного и того же значения каждому. Распаковка представляется помещением узла [`Tuple`](https://python-all.ru/3.14/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.14/library/ast.html#ast.List) внутрь `targets`.

#### `type_comment`

`type_comment` – это необязательная строка с аннотацией типа в виде комментария.

```pycon
>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # множественное присваивание
Module(
    body=[
        Assign(
            targets=[
                Name(id='a', ctx=Store()),
                Name(id='b', ctx=Store())],
            value=Constant(value=1))])

>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # распаковка
Module(
    body=[
        Assign(
            targets=[
                Tuple(
                    elts=[
                        Name(id='a', ctx=Store()),
                        Name(id='b', ctx=Store())],
                    ctx=Store())],
            value=Name(id='c', ctx=Load()))])
```

#### `class ast.AnnAssign(target, annotation, value, simple)`

Присваивание с аннотацией типа. `target` – это один узел, который может быть [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.14/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.14/library/ast.html#ast.Subscript). `annotation` – аннотация, например узел [`Constant`](https://python-all.ru/3.14/library/ast.html#ast.Constant) или `Name`. `value` – один необязательный узел.

`simple` всегда равен либо 0 (обозначает «сложную» цель), либо 1 (обозначает «простую» цель). «Простая» цель состоит только из узла [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name), который не находится в круглых скобках; все остальные цели считаются сложными. Только простые цели появляются в словаре [`__annotations__`](https://python-all.ru/3.14/reference/datamodel.html#object.__annotations__) модулей и классов.

```pycon
>>> print(ast.dump(ast.parse('c: int'), indent=4))
Module(
    body=[
        AnnAssign(
            target=Name(id='c', ctx=Store()),
            annotation=Name(id='int', ctx=Load()),
            simple=1)])

>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # аннотация со скобками
Module(
    body=[
        AnnAssign(
            target=Name(id='a', ctx=Store()),
            annotation=Name(id='int', ctx=Load()),
            value=Constant(value=1),
            simple=0)])

>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # аннотация атрибута
Module(
    body=[
        AnnAssign(
            target=Attribute(
                value=Name(id='a', ctx=Load()),
                attr='b',
                ctx=Store()),
            annotation=Name(id='int', ctx=Load()),
            simple=0)])

>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # аннотация подписки
Module(
    body=[
        AnnAssign(
            target=Subscript(
                value=Name(id='a', ctx=Load()),
                slice=Constant(value=1),
                ctx=Store()),
            annotation=Name(id='int', ctx=Load()),
            simple=0)])
```

#### `class ast.AugAssign(target, op, value)`

Расширенное присваивание, например `a += 1`. В следующем примере `target` – это узел [Имя](https://python-all.ru/3.14/library/ast.html#ast.Name) для `x` (с контекстом [`Store`](https://python-all.ru/3.14/library/ast.html#ast.Store)), `op` – это [Сложение](https://python-all.ru/3.14/library/ast.html#ast.Add), а `value` – это [Константа](https://python-all.ru/3.14/library/ast.html#ast.Constant) со значением 1.

Атрибут `target` не может быть класса [`Tuple`](https://python-all.ru/3.14/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.14/library/ast.html#ast.List), в отличие от целей [`Assign`](https://python-all.ru/3.14/library/ast.html#ast.Assign).

```pycon
>>> print(ast.dump(ast.parse('x += 2'), indent=4))
Module(
    body=[
        AugAssign(
            target=Name(id='x', ctx=Store()),
            op=Add(),
            value=Constant(value=2))])
```

#### `class ast.Raise(exc, cause)`

Инструкция `raise`. `exc` – объект исключения, который необходимо возбудить, обычно [Вызов](https://python-all.ru/3.14/library/ast.html#ast.Call) или [Имя](https://python-all.ru/3.14/library/ast.html#ast.Name), или `None` для отдельного `raise`. `cause` – необязательная часть для `y` в `Возбуждение`.

```pycon
>>> print(ast.dump(ast.parse('raise x from y'), indent=4))
Module(
    body=[
        Raise(
            exc=Name(id='x', ctx=Load()),
            cause=Name(id='y', ctx=Load()))])
```

#### `class ast.Assert(test, msg)`

Утверждение. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.14/library/ast.html#ast.Compare). `msg` содержит сообщение об ошибке.

```pycon
>>> print(ast.dump(ast.parse('assert x,y'), indent=4))
Module(
    body=[
        Assert(
            test=Name(id='x', ctx=Load()),
            msg=Name(id='y', ctx=Load()))])
```

#### `class ast.Delete(targets)`

Представляет инструкцию `del`. `targets` – список узлов, например узлов [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.14/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.14/library/ast.html#ast.Subscript).

```pycon
>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))
Module(
    body=[
        Delete(
            targets=[
                Name(id='x', ctx=Del()),
                Name(id='y', ctx=Del()),
                Name(id='z', ctx=Del())])])
```

#### `class ast.Pass`

Инструкция `pass`.

```pycon
>>> print(ast.dump(ast.parse('pass'), indent=4))
Module(
    body=[
        Pass()])
```

#### `class ast.TypeAlias(name, type_params, value)`

[Псевдоним типа](https://python-all.ru/3.14/library/typing.html#type-aliases), созданный с помощью инструкции [`type`](https://python-all.ru/3.14/reference/simple_stmts.html#type) . `name` – имя псевдонима, `type_params` – список [параметров типа](https://python-all.ru/3.14/library/ast.html#ast-type-params), а `value` – значение псевдонима типа.

```pycon
>>> print(ast.dump(ast.parse('type Alias = int'), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            value=Name(id='int', ctx=Load()))])
```

Добавлено в версии 3.12.

Другие инструкции, которые применимы только внутри функций или циклов, описаны в других разделах.

#### Импорты

#### `class ast.Import(names)`

Инструкция импорта. `names` – это список узлов [`alias`](https://python-all.ru/3.14/library/ast.html#ast.alias).

```pycon
>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))
Module(
    body=[
        Import(
            names=[
                alias(name='x'),
                alias(name='y'),
                alias(name='z')])])
```

#### `class ast.ImportFrom(module, names, level)`

Представляет `from x import y`. `module` – это необработанная строка имени from, без начальных точек, или `None` для инструкций вроде `from . import foo`. `level` – целое число, указывающее уровень относительного импорта (0 означает абсолютный импорт).

```pycon
>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))
Module(
    body=[
        ImportFrom(
            module='y',
            names=[
                alias(name='x'),
                alias(name='y'),
                alias(name='z')],
            level=0)])
```

#### `class ast.alias(name, asname)`

Оба параметра – необработанные строки имён. `asname` может быть `None`, если должно использоваться обычное имя.

```pycon
>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))
Module(
    body=[
        ImportFrom(
            module='foo.bar',
            names=[
                alias(name='a', asname='b'),
                alias(name='c')],
            level=2)])
```

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

> **Примечание**
>
> Необязательные предложения, такие как `else`, сохраняются как пустой список, если они отсутствуют.

#### `class ast.If(test, body, orelse)`

Инструкция `if`. `test` содержит один узел, например узел [`Compare`](https://python-all.ru/3.14/library/ast.html#ast.Compare). `body` и `orelse` содержат по списку узлов.

Предложения `elif` не имеют специального представления в AST, а появляются как дополнительные узлы `If` в разделе `orelse` предыдущего.

```pycon
>>> print(ast.dump(ast.parse("""
... if x:
...    ...
... elif y:
...    ...
... else:
...    ...
... """), indent=4))
Module(
    body=[
        If(
            test=Name(id='x', ctx=Load()),
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            orelse=[
                If(
                    test=Name(id='y', ctx=Load()),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))],
                    orelse=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

#### `class ast.For(target, iter, body, orelse, type_comment)`

Цикл `for`. `target` содержит переменную (или переменные), которой присваивает цикл, в виде одного узла [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.14/library/ast.html#ast.Tuple), [`List`](https://python-all.ru/3.14/library/ast.html#ast.List), [`Attribute`](https://python-all.ru/3.14/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.14/library/ast.html#ast.Subscript). `iter` содержит элемент, по которому выполняется итерация, также в виде одного узла. `body` и `orelse` содержат списки узлов для выполнения. Те, что в `orelse`, выполняются, если цикл завершается нормально, а не по инструкции `break`.

#### `type_comment`

`type_comment` – это необязательная строка с аннотацией типа в виде комментария.

```pycon
>>> print(ast.dump(ast.parse("""
... for x in y:
...     ...
... else:
...     ...
... """), indent=4))
Module(
    body=[
        For(
            target=Name(id='x', ctx=Store()),
            iter=Name(id='y', ctx=Load()),
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            orelse=[
                Expr(
                    value=Constant(value=Ellipsis))])])
```

#### `class ast.While(test, body, orelse)`

Цикл `while`. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.14/library/ast.html#ast.Compare).

```pycon
>>> print(ast.dump(ast.parse("""
... while x:
...    ...
... else:
...    ...
... """), indent=4))
Module(
    body=[
        While(
            test=Name(id='x', ctx=Load()),
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            orelse=[
                Expr(
                    value=Constant(value=Ellipsis))])])
```

#### `class ast.Break`

#### `class ast.Continue`

Инструкции `break` и `continue`.

```pycon
>>> print(ast.dump(ast.parse("""\
... for a in b:
...     if a > 5:
...         break
...     else:
...         continue
...
... """), indent=4))
Module(
    body=[
        For(
            target=Name(id='a', ctx=Store()),
            iter=Name(id='b', ctx=Load()),
            body=[
                If(
                    test=Compare(
                        left=Name(id='a', ctx=Load()),
                        ops=[
                            Gt()],
                        comparators=[
                            Constant(value=5)]),
                    body=[
                        Break()],
                    orelse=[
                        Continue()])])])
```

#### `class ast.Try(body, handlers, orelse, finalbody)`

Блоки `try`. Все атрибуты – списки узлов для выполнения, за исключением `handlers`, который является списком узлов [`ExceptHandler`](https://python-all.ru/3.14/library/ast.html#ast.ExceptHandler).

```pycon
>>> print(ast.dump(ast.parse("""
... try:
...    ...
... except Exception:
...    ...
... except OtherException as e:
...    ...
... else:
...    ...
... finally:
...    ...
... """), indent=4))
Module(
    body=[
        Try(
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            handlers=[
                ExceptHandler(
                    type=Name(id='Exception', ctx=Load()),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                ExceptHandler(
                    type=Name(id='OtherException', ctx=Load()),
                    name='e',
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])],
            orelse=[
                Expr(
                    value=Constant(value=Ellipsis))],
            finalbody=[
                Expr(
                    value=Constant(value=Ellipsis))])])
```

#### `class ast.TryStar(body, handlers, orelse, finalbody)`

Блоки `try`, за которыми следуют предложения `except*`. Атрибуты такие же, как для [`Try`](https://python-all.ru/3.14/library/ast.html#ast.Try), но узлы [`ExceptHandler`](https://python-all.ru/3.14/library/ast.html#ast.ExceptHandler) в `handlers` интерпретируются как блоки `except*`, а не `except`.

```pycon
>>> print(ast.dump(ast.parse("""
... try:
...    ...
... except* Exception:
...    ...
... """), indent=4))
Module(
    body=[
        TryStar(
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            handlers=[
                ExceptHandler(
                    type=Name(id='Exception', ctx=Load()),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.12.

#### `class ast.ExceptHandler(type, name, body)`

Одно предложение `except`. `type` – тип исключения, который оно перехватывает, обычно узел [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name) (или `None` для универсального предложения `except:`). `name` – необработанная строка для имени, в котором будет сохранено исключение, или `None`, если в предложении нет `as foo`. `body` – список узлов.

```pycon
>>> print(ast.dump(ast.parse("""\
... try:
...     a + 1
... except TypeError:
...     pass
... """), indent=4))
Module(
    body=[
        Try(
            body=[
                Expr(
                    value=BinOp(
                        left=Name(id='a', ctx=Load()),
                        op=Add(),
                        right=Constant(value=1)))],
            handlers=[
                ExceptHandler(
                    type=Name(id='TypeError', ctx=Load()),
                    body=[
                        Pass()])])])
```

#### `class ast.With(items, body, type_comment)`

Блок `with`. `items` – это список узлов [`withitem`](https://python-all.ru/3.14/library/ast.html#ast.withitem), представляющих менеджеры контекста, а `body` – это блок с отступом внутри контекста.

#### `type_comment`

`type_comment` – это необязательная строка с аннотацией типа в виде комментария.

#### `class ast.withitem(context_expr, optional_vars)`

Один менеджер контекста в блоке `with`. `context_expr` – это менеджер контекста, часто узел [`Call`](https://python-all.ru/3.14/library/ast.html#ast.Call). `optional_vars` – это [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.14/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.14/library/ast.html#ast.List) для части `as foo`, или `None`, если она не используется.

```pycon
>>> print(ast.dump(ast.parse("""\
... with a as b, c as d:
...    something(b, d)
... """), indent=4))
Module(
    body=[
        With(
            items=[
                withitem(
                    context_expr=Name(id='a', ctx=Load()),
                    optional_vars=Name(id='b', ctx=Store())),
                withitem(
                    context_expr=Name(id='c', ctx=Load()),
                    optional_vars=Name(id='d', ctx=Store()))],
            body=[
                Expr(
                    value=Call(
                        func=Name(id='something', ctx=Load()),
                        args=[
                            Name(id='b', ctx=Load()),
                            Name(id='d', ctx=Load())]))])])
```

### Сопоставление с образцом

#### `class ast.Match(subject, cases)`

Оператор `match`. В `subject` хранится subject сопоставления (объект, который сравнивается с вариантами), а `cases` содержит итерируемый набор узлов [`match_case`](https://python-all.ru/3.14/library/ast.html#ast.match_case) с различными вариантами.

Добавлено в версии 3.10.

#### `class ast.match_case(pattern, guard, body)`

Один вариант (case) в операторе `match`. `pattern` содержит шаблон сопоставления, с которым будет сравниваться subject. Обратите внимание, что узлы [`AST`](https://python-all.ru/3.14/library/ast.html#ast.AST), создаваемые для шаблонов, отличаются от узлов, создаваемых для выражений, даже при одинаковом синтаксисе.

Атрибут `guard` содержит выражение, которое будет вычислено, если шаблон совпадает с subject.

`body` содержит список узлов, которые выполняются, если шаблон совпадает и результат вычисления guard-выражения истинен.

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] if x>0:
...         ...
...     case tuple():
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchAs(name='x')]),
                    guard=Compare(
                        left=Name(id='x', ctx=Load()),
                        ops=[
                            Gt()],
                        comparators=[
                            Constant(value=0)]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchClass(
                        cls=Name(id='tuple', ctx=Load())),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

#### `class ast.MatchValue(value)`

Сопоставление с литералом или шаблоном значения, сравниваемым по равенству. `value` – это узел выражения. Допустимые узлы значений ограничены, как описано в документации оператора match. Этот шаблон успешно срабатывает, если subject сопоставления равен вычисленному значению.

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case "Relevant":
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchValue(
                        value=Constant(value='Relevant')),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

#### `class ast.MatchSingleton(value)`

Сопоставление с литералом, сравниваемым по идентичности. `value` – это синглтон, с которым производится сравнение: `None`, `True` или `False`. Этот шаблон успешно срабатывает, если subject сопоставления является заданной константой.

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case None:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchSingleton(value=None),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

#### `class ast.MatchSequence(patterns)`

Шаблон последовательности (sequence pattern) в match. `patterns` содержит шаблоны, которые будут сопоставляться с элементами subject, если subject является последовательностью. Сопоставляется с последовательностью переменной длины, если один из подшаблонов является узлом `MatchStar`, в противном случае сопоставляется с последовательностью фиксированной длины.

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case [1, 2]:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchValue(
                                value=Constant(value=1)),
                            MatchValue(
                                value=Constant(value=2))]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

#### `class ast.MatchStar(name)`

Сопоставляется с остатком последовательности в шаблоне последовательности переменной длины. Если `name` не равно `None`, то при успешном сопоставлении всего шаблона последовательности этому имени привязывается список, содержащий оставшиеся элементы последовательности.

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case [1, 2, *rest]:
...         ...
...     case [*_]:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchValue(
                                value=Constant(value=1)),
                            MatchValue(
                                value=Constant(value=2)),
                            MatchStar(name='rest')]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchStar()]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

#### `class ast.MatchMapping(keys, patterns, rest)`

Шаблон отображения (mapping pattern) в match. `keys` – последовательность узлов выражений. `patterns` – соответствующая последовательность узлов шаблонов. `rest` – необязательное имя, которое можно указать для захвата оставшихся элементов отображения. Допустимые ключевые выражения ограничены, как описано в документации оператора match.

Этот шаблон успешно срабатывает, если subject является отображением, все вычисленные ключевые выражения присутствуют в отображении, а значение, соответствующее каждому ключу, совпадает с соответствующим подшаблоном. Если `rest` не равно `None`, то при успешном сопоставлении всего шаблона отображения этому имени привязывается словарь, содержащий оставшиеся элементы отображения.

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case {1: _, 2: _}:
...         ...
...     case {**rest}:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchMapping(
                        keys=[
                            Constant(value=1),
                            Constant(value=2)],
                        patterns=[
                            MatchAs(),
                            MatchAs()]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchMapping(rest='rest'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

#### `class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)`

Шаблон класса (class pattern) в match. `cls` – выражение, задающее номинальный класс для сопоставления. `patterns` – последовательность узлов шаблонов, которые будут сопоставляться с определённой классом последовательностью атрибутов для сопоставления с образцом. `kwd_attrs` – последовательность дополнительных атрибутов для сопоставления (указанных как ключевые аргументы в шаблоне класса), `kwd_patterns` – соответствующие шаблоны (указанные как значения ключевых слов в шаблоне класса).

Этот шаблон успешно срабатывает, если subject является экземпляром указанного класса, все позиционные шаблоны совпадают с соответствующими атрибутами, определёнными классом, и все указанные ключевые атрибуты совпадают со своими шаблонами.

Примечание: классы могут определять свойство, возвращающее self, чтобы сопоставлять узел шаблона с сопоставляемым экземпляром. Некоторые встроенные типы также сопоставляются таким образом, как описано в документации оператора match.

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case Point2D(0, 0):
...         ...
...     case Point3D(x=0, y=0, z=0):
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchClass(
                        cls=Name(id='Point2D', ctx=Load()),
                        patterns=[
                            MatchValue(
                                value=Constant(value=0)),
                            MatchValue(
                                value=Constant(value=0))]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchClass(
                        cls=Name(id='Point3D', ctx=Load()),
                        kwd_attrs=[
                            'x',
                            'y',
                            'z'],
                        kwd_patterns=[
                            MatchValue(
                                value=Constant(value=0)),
                            MatchValue(
                                value=Constant(value=0)),
                            MatchValue(
                                value=Constant(value=0))]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

#### `class ast.MatchAs(pattern, name)`

Сопоставление «as-pattern», шаблон захвата (capture pattern) или шаблон-заменитель (wildcard pattern). `pattern` содержит шаблон match, с которым будет сопоставлен subject. Если шаблон равен `None`, узел представляет собой шаблон захвата (т.е. просто имя) и всегда успешно срабатывает.

Атрибут `name` содержит имя, которое будет привязано при успешном сопоставлении шаблона. Если `name` равно `None`, то `pattern` также должно быть `None`, и узел представляет собой шаблон-заменитель (wildcard).

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] as y:
...         ...
...     case _:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchAs(
                        pattern=MatchSequence(
                            patterns=[
                                MatchAs(name='x')]),
                        name='y'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchAs(),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

#### `class ast.MatchOr(patterns)`

Сопоставление «or-pattern» (шаблон ИЛИ). Or-pattern последовательно сопоставляет каждый из своих подшаблонов с subject, пока один из них не сработает. Тогда считается, что or-pattern сработал. Если ни один из подшаблонов не сработал, or-pattern не срабатывает. Атрибут `patterns` содержит список узлов шаблонов match, которые будут сопоставляться с subject.

```pycon
>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] | (y):
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x', ctx=Load()),
            cases=[
                match_case(
                    pattern=MatchOr(
                        patterns=[
                            MatchSequence(
                                patterns=[
                                    MatchAs(name='x')]),
                            MatchAs(name='y')]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])
```

Добавлено в версии 3.10.

### Аннотации типов

#### `class ast.TypeIgnore(lineno, tag)`

Комментарий `# type: ignore`, расположенный на строке *lineno*. *tag* – опциональный тег, задаваемый формой `# type: ignore <tag>`.

```pycon
>>> print(ast.dump(ast.parse('x = 1 # type: ignore', type_comments=True), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Name(id='x', ctx=Store())],
            value=Constant(value=1))],
    type_ignores=[
        TypeIgnore(lineno=1, tag='')])
>>> print(ast.dump(ast.parse('x: bool = 1 # type: ignore[assignment]', type_comments=True), indent=4))
Module(
    body=[
        AnnAssign(
            target=Name(id='x', ctx=Store()),
            annotation=Name(id='bool', ctx=Load()),
            value=Constant(value=1),
            simple=1)],
    type_ignores=[
        TypeIgnore(lineno=1, tag='[assignment]')])
```

> **Примечание**
>
> Узлы `TypeIgnore` не создаются, когда параметр *type\_comments* установлен в `False` (по умолчанию). Подробнее см. [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse).

Добавлено в версии 3.8.

### Параметры типа

[Параметры типа](https://python-all.ru/3.14/reference/compound_stmts.html#type-params) могут существовать у классов, функций и псевдонимов типов.

#### `class ast.TypeVar(name, bound, default_value)`

[`typing.TypeVar`](https://python-all.ru/3.14/library/typing.html#typing.TypeVar). `name` – это имя переменной типа. `bound` – это граница или ограничения, если они есть. Если `bound` представляет собой [`Tuple`](https://python-all.ru/3.14/library/ast.html#ast.Tuple), то это ограничения; иначе – граница. `default_value` – значение по умолчанию; если `TypeVar` не имеет значения по умолчанию, то этот атрибут равен `None`.

```pycon
>>> print(ast.dump(ast.parse("type Alias[T: int = bool] = list[T]"), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            type_params=[
                TypeVar(
                    name='T',
                    bound=Name(id='int', ctx=Load()),
                    default_value=Name(id='bool', ctx=Load()))],
            value=Subscript(
                value=Name(id='list', ctx=Load()),
                slice=Name(id='T', ctx=Load()),
                ctx=Load()))])
```

Добавлено в версии 3.12.

Изменено в версии 3.13: Добавлен параметр *default\_value*.

#### `class ast.ParamSpec(name, default_value)`

[`typing.ParamSpec`](https://python-all.ru/3.14/library/typing.html#typing.ParamSpec). `name` – это имя спецификации параметра. `default_value` – значение по умолчанию; если `ParamSpec` не имеет значения по умолчанию, то этот атрибут устанавливается в `None`.

```pycon
>>> print(ast.dump(ast.parse("type Alias[**P = [int, str]] = Callable[P, int]"), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            type_params=[
                ParamSpec(
                    name='P',
                    default_value=List(
                        elts=[
                            Name(id='int', ctx=Load()),
                            Name(id='str', ctx=Load())],
                        ctx=Load()))],
            value=Subscript(
                value=Name(id='Callable', ctx=Load()),
                slice=Tuple(
                    elts=[
                        Name(id='P', ctx=Load()),
                        Name(id='int', ctx=Load())],
                    ctx=Load()),
                ctx=Load()))])
```

Добавлено в версии 3.12.

Изменено в версии 3.13: Добавлен параметр *default\_value*.

#### `class ast.TypeVarTuple(name, default_value)`

[`typing.TypeVarTuple`](https://python-all.ru/3.14/library/typing.html#typing.TypeVarTuple). `name` – это имя кортежа переменных типа. `default_value` – значение по умолчанию; если `TypeVarTuple` не имеет значения по умолчанию, то этот атрибут устанавливается в `None`.

```pycon
>>> print(ast.dump(ast.parse("type Alias[*Ts = ()] = tuple[*Ts]"), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            type_params=[
                TypeVarTuple(
                    name='Ts',
                    default_value=Tuple(ctx=Load()))],
            value=Subscript(
                value=Name(id='tuple', ctx=Load()),
                slice=Tuple(
                    elts=[
                        Starred(
                            value=Name(id='Ts', ctx=Load()),
                            ctx=Load())],
                    ctx=Load()),
                ctx=Load()))])
```

Добавлено в версии 3.12.

Изменено в версии 3.13: Добавлен параметр *default\_value*.

### Определения функций и классов

#### `class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`

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

- `name` – это необработанная строка имени функции.
- `args` – это узел [`arguments`](https://python-all.ru/3.14/library/ast.html#ast.arguments).
- `body` – это список узлов внутри функции.
- `decorator_list` – это список декораторов, которые будут применены; декораторы перечислены от самого внешнего к внутреннему (т.е. первый в списке применяется последним).
- `returns` – это аннотация возвращаемого значения.
- `type_params` – это список [параметров типа](https://python-all.ru/3.14/library/ast.html#ast-type-params).

#### `type_comment`

`type_comment` – это необязательная строка с аннотацией типа в виде комментария.

Изменено в версии 3.12: Добавлен `type_params`.

#### `class ast.Lambda(args, body)`

`lambda` – это минимальное определение функции, которое можно использовать внутри выражения. В отличие от [`FunctionDef`](https://python-all.ru/3.14/library/ast.html#ast.FunctionDef), `body` содержит один узел.

```pycon
>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))
Module(
    body=[
        Expr(
            value=Lambda(
                args=arguments(
                    args=[
                        arg(arg='x'),
                        arg(arg='y')]),
                body=Constant(value=Ellipsis)))])
```

#### `class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)`

Аргументы функции.

- `posonlyargs`, `args` и `kwonlyargs` – это списки узлов [`arg`](https://python-all.ru/3.14/library/ast.html#ast.arg).
- `vararg` и `kwarg` – это одиночные узлы [`arg`](https://python-all.ru/3.14/library/ast.html#ast.arg), ссылающиеся на параметры `*args, **kwargs`.
- `kw_defaults` – это список значений по умолчанию для keyword-only аргументов. Если один из них равен `None`, соответствующий аргумент обязателен.
- `defaults` – это список значений по умолчанию для аргументов, которые можно передавать позиционно. Если значений по умолчанию меньше, они соответствуют последним n аргументам.

#### `class ast.arg(arg, annotation, type_comment)`

Один аргумент в списке. `arg` – это сырая строка с именем аргумента; `annotation` – это его аннотация, например, узел [`Name`](https://python-all.ru/3.14/library/ast.html#ast.Name).

#### `type_comment`

`type_comment` – это необязательная строка с аннотацией типа в виде комментария

```pycon
>>> print(ast.dump(ast.parse("""\
... @decorator1
... @decorator2
... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':
...     pass
... """), indent=4))
Module(
    body=[
        FunctionDef(
            name='f',
            args=arguments(
                args=[
                    arg(
                        arg='a',
                        annotation=Constant(value='annotation')),
                    arg(arg='b'),
                    arg(arg='c')],
                vararg=arg(arg='d'),
                kwonlyargs=[
                    arg(arg='e'),
                    arg(arg='f')],
                kw_defaults=[
                    None,
                    Constant(value=3)],
                kwarg=arg(arg='g'),
                defaults=[
                    Constant(value=1),
                    Constant(value=2)]),
            body=[
                Pass()],
            decorator_list=[
                Name(id='decorator1', ctx=Load()),
                Name(id='decorator2', ctx=Load())],
            returns=Constant(value='return annotation'))])
```

#### `class ast.Return(value)`

Инструкция `return`.

```pycon
>>> print(ast.dump(ast.parse('return 4'), indent=4))
Module(
    body=[
        Return(
            value=Constant(value=4))])
```

#### `class ast.Yield(value)`

#### `class ast.YieldFrom(value)`

Выражение `yield` или `yield from`. Поскольку это выражения, они должны быть обёрнуты в узел [`Expr`](https://python-all.ru/3.14/library/ast.html#ast.Expr), если возвращаемое значение не используется.

```pycon
>>> print(ast.dump(ast.parse('yield x'), indent=4))
Module(
    body=[
        Expr(
            value=Yield(
                value=Name(id='x', ctx=Load())))])

>>> print(ast.dump(ast.parse('yield from x'), indent=4))
Module(
    body=[
        Expr(
            value=YieldFrom(
                value=Name(id='x', ctx=Load())))])
```

#### `class ast.Global(names)`

#### `class ast.Nonlocal(names)`

Инструкции `global` и `nonlocal`. `names` – это список сырых строк.

```pycon
>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))
Module(
    body=[
        Global(
            names=[
                'x',
                'y',
                'z'])])

>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))
Module(
    body=[
        Nonlocal(
            names=[
                'x',
                'y',
                'z'])])
```

#### `class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)`

Определение класса.

- `name` – это сырая строка с именем класса.
- `bases` – это список узлов для явно указанных базовых классов.
- `keywords` – это список узлов [`keyword`](https://python-all.ru/3.14/library/ast.html#ast.keyword), в первую очередь для ‘metaclass’. Остальные ключевые слова будут переданы метаклассу, в соответствии с [**PEP 3115**](https://python-all.ru/3.14/library/ast.html).
- `body` – это список узлов, представляющих код внутри определения класса.
- `decorator_list` – это список узлов, как и в [`FunctionDef`](https://python-all.ru/3.14/library/ast.html#ast.FunctionDef).
- `type_params` – это список [параметров типа](https://python-all.ru/3.14/library/ast.html#ast-type-params).

```pycon
>>> print(ast.dump(ast.parse("""\
... @decorator1
... @decorator2
... class Foo(base1, base2, metaclass=meta):
...     pass
... """), indent=4))
Module(
    body=[
        ClassDef(
            name='Foo',
            bases=[
                Name(id='base1', ctx=Load()),
                Name(id='base2', ctx=Load())],
            keywords=[
                keyword(
                    arg='metaclass',
                    value=Name(id='meta', ctx=Load()))],
            body=[
                Pass()],
            decorator_list=[
                Name(id='decorator1', ctx=Load()),
                Name(id='decorator2', ctx=Load())])])
```

Изменено в версии 3.12: Добавлен `type_params`.

### async и await

#### `class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`

Определение функции `async def`. Имеет те же поля, что и [`FunctionDef`](https://python-all.ru/3.14/library/ast.html#ast.FunctionDef).

Изменено в версии 3.12: Добавлен `type_params`.

#### `class ast.Await(value)`

Выражение `await`. `value` – это то, чего оно ожидает. Допустимо только в теле [`AsyncFunctionDef`](https://python-all.ru/3.14/library/ast.html#ast.AsyncFunctionDef).

```pycon
>>> print(ast.dump(ast.parse("""\
... async def f():
...     await other_func()
... """), indent=4))
Module(
    body=[
        AsyncFunctionDef(
            name='f',
            args=arguments(),
            body=[
                Expr(
                    value=Await(
                        value=Call(
                            func=Name(id='other_func', ctx=Load()))))])])
```

#### `class ast.AsyncFor(target, iter, body, orelse, type_comment)`

#### `class ast.AsyncWith(items, body, type_comment)`

`async for` циклы и `async with` менеджеры контекста. Они имеют те же поля, что [`For`](https://python-all.ru/3.14/library/ast.html#ast.For) и [`With`](https://python-all.ru/3.14/library/ast.html#ast.With), соответственно. Допустимы только в теле [`AsyncFunctionDef`](https://python-all.ru/3.14/library/ast.html#ast.AsyncFunctionDef).

> **Примечание**
>
> Когда строка разбирается с помощью [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse), узлы операторов (подклассы `ast.operator`, `ast.unaryop`, `ast.cmpop`, `ast.boolop` и `ast.expr_context`) на возвращаемом дереве будут синглтонами. Изменения в одном отразятся во всех других вхождениях того же значения (например, [`ast.Add`](https://python-all.ru/3.14/library/ast.html#ast.Add)).

## `ast` вспомогательные функции

Помимо классов узлов, модуль `ast` определяет следующие служебные функции и классы для обхода абстрактных синтаксических деревьев:

#### `ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None, optimize=-1)`

Разбирает исходный код в узел AST. Эквивалентно `compile(source, filename, mode, flags=FLAGS_VALUE, optimize=optimize)`, где `FLAGS_VALUE` равно `ast.PyCF_ONLY_AST`, если `optimize <= 0`, и `ast.PyCF_OPTIMIZED_AST` в противном случае.

Если задан `type_comments=True`, парсер изменяется, чтобы проверять и возвращать комментарии типов, как указано в [**PEP 484**](https://python-all.ru/3.14/library/ast.html) и [**PEP 526**](https://python-all.ru/3.14/library/ast.html). Это эквивалентно добавлению [`ast.PyCF_TYPE_COMMENTS`](https://python-all.ru/3.14/library/ast.html#ast.PyCF_TYPE_COMMENTS) к флагам, передаваемым в [`compile()`](https://python-all.ru/3.14/library/functions.html#compile). Это приведёт к сообщению об ошибках синтаксиса для неправильно расположенных комментариев типов. Без этого флага комментарии типов будут игнорироваться, и поле `type_comment` в выбранных узлах AST всегда будет `None`. Кроме того, расположение комментариев `# type: ignore` будет возвращаться как атрибут `type_ignores` объекта [`Module`](https://python-all.ru/3.14/library/ast.html#ast.Module) (иначе это всегда пустой список).

Кроме того, если `mode` равно `'func_type'`, синтаксис входных данных изменяется в соответствии с [**PEP 484**](https://python-all.ru/3.14/library/ast.html) «сигнатурными комментариями типов», например `(str, int) -> List[str]`.

Установка `feature_version` в кортеж `(major, minor)` приведёт к «наилучшей попытке» разбора с использованием грамматики этой версии Python. Например, установка `feature_version=(3, 9)` будет пытаться запретить разбор инструкций [`match`](https://python-all.ru/3.14/reference/compound_stmts.html#match). В настоящее время `major` должно быть равно `3`. Самая низкая поддерживаемая версия – `(3, 7)` (и это может увеличиться в будущих версиях Python); самая высокая – `sys.version_info[0:2]`. «Наилучшая попытка» означает, что нет гарантии, что разбор (или успех разбора) будет таким же, как при запуске на версии Python, соответствующей `feature_version`.

Если исходный код содержит нулевой символ (`\0`), возбуждается [`ValueError`](https://python-all.ru/3.14/library/exceptions.html#ValueError).

> **Предупреждение**
>
> Обратите внимание, что успешный разбор исходного кода в объект AST не гарантирует, что предоставленный исходный код является корректным кодом Python, который можно выполнить, поскольку этап компиляции может вызывать дополнительные исключения [`SyntaxError`](https://python-all.ru/3.14/library/exceptions.html#SyntaxError). Например, исходный код `return 42` генерирует корректный узел AST для инструкции return, но его нельзя скомпилировать отдельно (он должен находиться внутри узла функции).
>
> В частности, `ast.parse()` не выполняет никаких проверок областей видимости, которые выполняет этап компиляции.

> **Предупреждение**
>
> Можно вызвать сбой интерпретатора Python с помощью достаточно большой/сложной строки из-за ограничений глубины стека в компиляторе AST Python.

Изменено в версии 3.8: Добавлены `type_comments`, `mode='func_type'` и `feature_version`.

Изменено в версии 3.13: Минимальная поддерживаемая версия для `feature_version` теперь `(3, 7)`. Был добавлен аргумент `optimize`.

#### `ast.unparse(ast_obj)`

Выполняет обратный разбор объекта [`ast.AST`](https://python-all.ru/3.14/library/ast.html#ast.AST) и генерирует строку с кодом, который при обратном разборе с помощью [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse) даст эквивалентный объект `ast.AST`.

> **Предупреждение**
>
> Полученная строка кода не обязательно будет равна исходному коду, который породил объект [`ast.AST`](https://python-all.ru/3.14/library/ast.html#ast.AST) (без каких-либо оптимизаций компилятора, таких как константные кортежи/frozensets).

> **Предупреждение**
>
> Попытка выполнить обратный разбор очень сложного выражения приведёт к [`RecursionError`](https://python-all.ru/3.14/library/exceptions.html#RecursionError).

Добавлено в версии 3.9.

#### `ast.literal_eval(node_or_string)`

Вычисляет узел выражения или строку, содержащую только литерал Python или отображение контейнера. Предоставленная строка или узел могут состоять только из следующих структур литералов Python: строки, байты, числа, кортежи, списки, словари, множества, булевы значения, `None` и `Ellipsis`.

Это можно использовать для вычисления строк, содержащих значения Python, без необходимости разбирать значения самостоятельно. Он не способен вычислять произвольно сложные выражения, например, с операторами или индексацией.

Раньше эта функция документировалась как «безопасная» без определения, что это значит. Это вводило в заблуждение. Она специально разработана так, чтобы не выполнять код Python, в отличие от более общей [`eval()`](https://python-all.ru/3.14/library/functions.html#eval). Нет пространства имён, поиска имён или возможности внешних вызовов. Но она не свободна от атак: относительно небольшой ввод может привести к истощению памяти или истощению стека C, что вызовет сбой процесса. Также существует возможность отказа в обслуживании из-за чрезмерного потребления ЦП на некоторых входных данных. Поэтому вызывать её на недоверенных данных не рекомендуется.

> **Предупреждение**
>
> Можно вызвать сбой интерпретатора Python из-за ограничений глубины стека в компиляторе AST Python.
>
> Она может возбуждать [`ValueError`](https://python-all.ru/3.14/library/exceptions.html#ValueError), [`TypeError`](https://python-all.ru/3.14/library/exceptions.html#TypeError), [`SyntaxError`](https://python-all.ru/3.14/library/exceptions.html#SyntaxError), [`MemoryError`](https://python-all.ru/3.14/library/exceptions.html#MemoryError) и [`RecursionError`](https://python-all.ru/3.14/library/exceptions.html#RecursionError) в зависимости от некорректного ввода.

Изменено в версии 3.2: Теперь допускает литералы байтов и множеств.

Изменено в версии 3.9: Теперь поддерживает создание пустых множеств с помощью `'set()'`.

Изменено в версии 3.10: Для строковых входных данных начальные пробелы и табуляции теперь удаляются.

#### `ast.get_docstring(node, clean=True)`

Возвращает строку документации для данного *узла* (который должен быть узлом [`FunctionDef`](https://python-all.ru/3.14/library/ast.html#ast.FunctionDef), [`AsyncFunctionDef`](https://python-all.ru/3.14/library/ast.html#ast.AsyncFunctionDef), [`ClassDef`](https://python-all.ru/3.14/library/ast.html#ast.ClassDef) или [`Module`](https://python-all.ru/3.14/library/ast.html#ast.Module)) или `None`, если у него нет строки документации. Если *clean* истинно, очищает отступы строки документации с помощью [`inspect.cleandoc()`](https://python-all.ru/3.14/library/inspect.html#inspect.cleandoc).

Изменено в версии 3.5: Теперь поддерживается [`AsyncFunctionDef`](https://python-all.ru/3.14/library/ast.html#ast.AsyncFunctionDef).

#### `ast.get_source_segment(source, node, *, padded=False)`

Возвращает фрагмент исходного кода из *source*, который породил узел *node*. Если не хватает информации о местоположении ([`lineno`](https://python-all.ru/3.14/library/ast.html#ast.AST.lineno), [`end_lineno`](https://python-all.ru/3.14/library/ast.html#ast.AST.end_lineno), [`col_offset`](https://python-all.ru/3.14/library/ast.html#ast.AST.col_offset) или [`end_col_offset`](https://python-all.ru/3.14/library/ast.html#ast.AST.end_col_offset)), возвращает `None`.

Если *padded* равно `True`, первая строка многострочного оператора будет дополнена пробелами, чтобы соответствовать исходной позиции.

Добавлено в версии 3.8.

#### `ast.fix_missing_locations(node)`

При компиляции дерева узлов с помощью [`compile()`](https://python-all.ru/3.14/library/functions.html#compile) компилятор ожидает атрибуты [`lineno`](https://python-all.ru/3.14/library/ast.html#ast.AST.lineno) и [`col_offset`](https://python-all.ru/3.14/library/ast.html#ast.AST.col_offset) для каждого узла, который их поддерживает. Заполнять их вручную для сгенерированных узлов довольно утомительно, поэтому эта вспомогательная функция рекурсивно добавляет эти атрибуты, если их ещё нет, устанавливая их равными значениям родительского узла. Работает рекурсивно, начиная с *node*.

#### `ast.increment_lineno(node, n=1)`

Увеличивает номер строки и номер конечной строки каждого узла в дереве, начиная с *node*, на *n*. Это полезно для «перемещения кода» в другое место в файле.

#### `ast.copy_location(new_node, old_node)`

Копирует информацию о местоположении в исходном коде ([`lineno`](https://python-all.ru/3.14/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.14/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.14/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.14/library/ast.html#ast.AST.end_col_offset)) из *old\_node* в *new\_node*, если это возможно, и возвращает *new\_node*.

#### `ast.iter_fields(node)`

Генерирует кортеж из `(fieldname, value)` для каждого поля в `node._fields`, которое присутствует в *node*.

#### `ast.iter_child_nodes(node)`

Генерирует все непосредственные дочерние узлы *node*, то есть все поля, являющиеся узлами, и все элементы полей, являющихся списками узлов.

#### `ast.walk(node)`

Рекурсивно генерирует все узлы-потомки в дереве, начиная с *node* (включая сам *node*), в произвольном порядке. Это полезно, если требуется только изменить узлы на месте, а контекст не важен.

#### `class ast.NodeVisitor`

Базовый класс для обхода узлов, который обходит абстрактное синтаксическое дерево и вызывает функцию-посетитель для каждого найденного узла. Эта функция может вернуть значение, которое передаётся методом [`visit()`](https://python-all.ru/3.14/library/ast.html#ast.NodeVisitor.visit).

Этот класс предназначен для наследования; в подклассе добавляются методы-посетители.

#### `visit(node)`

Посещает узел. Реализация по умолчанию вызывает метод `self.visit_classname`, где *classname* – имя класса узла, или [`generic_visit()`](https://python-all.ru/3.14/library/ast.html#ast.NodeVisitor.generic_visit), если такой метод отсутствует.

#### `generic_visit(node)`

Этот посетитель вызывает [`visit()`](https://python-all.ru/3.14/library/ast.html#ast.NodeVisitor.visit) для всех дочерних узлов.

Обратите внимание, что дочерние узлы тех узлов, для которых определён собственный метод-посетитель, не будут посещены, если посетитель сам не вызовет `generic_visit()` или не обойдёт их самостоятельно.

#### `visit_Constant(node)`

Обрабатывает все константные узлы.

Не используйте `NodeVisitor`, если требуется вносить изменения в узлы во время обхода. Для этого существует специальный посетитель ([`NodeTransformer`](https://python-all.ru/3.14/library/ast.html#ast.NodeTransformer)), который допускает модификации.

Устарело с версии 3.8, удалено в версии 3.14: Методы `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` и `visit_Ellipsis()` не будут вызываться в Python 3.14+. Вместо них добавьте метод [`visit_Constant()`](https://python-all.ru/3.14/library/ast.html#ast.NodeVisitor.visit_Constant) для обработки всех константных узлов.

#### `class ast.NodeTransformer`

Подкласс [`NodeVisitor`](https://python-all.ru/3.14/library/ast.html#ast.NodeVisitor), который обходит абстрактное синтаксическое дерево и позволяет изменять узлы.

Метод `NodeTransformer` обходит AST и использует возвращаемое значение методов-посетителей для замены или удаления старого узла. Если возвращаемое значение метода-посетителя равно `None`, узел будет удалён из своего местоположения; в противном случае он заменяется возвращённым значением. Возвращённое значение может быть исходным узлом – в этом случае замена не происходит.

Вот пример преобразователя, который переписывает все обращения к именам (`foo`) в `data['foo']`:

```python
class RewriteName(NodeTransformer):

    def visit_Name(self, node):
        return Subscript(
            value=Name(id='data', ctx=Load()),
            slice=Constant(value=node.id),
            ctx=node.ctx
        )
```

Имейте в виду: если у узла, с которым вы работаете, есть дочерние узлы, необходимо либо преобразовать дочерние узлы самостоятельно, либо сначала вызвать для узла метод [`generic_visit()`](https://python-all.ru/3.14/library/ast.html#ast.NodeVisitor.generic_visit).

Для узлов, входящих в состав набора инструкций (это относится ко всем узлам инструкций), посетитель может также возвращать список узлов, а не один узел.

Если `NodeTransformer` вводит новые узлы (не входившие в исходное дерево) без указания информации о расположении (например, [`lineno`](https://python-all.ru/3.14/library/ast.html#ast.AST.lineno)), следует вызвать [`fix_missing_locations()`](https://python-all.ru/3.14/library/ast.html#ast.fix_missing_locations) для нового поддерева, чтобы пересчитать информацию о расположении:

```python
tree = ast.parse('foo', mode='eval')
new_tree = fix_missing_locations(RewriteName().visit(tree))
```

Обычно преобразователь используется следующим образом:

```python
node = YourTransformer().visit(node)
```

#### `ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None, show_empty=False)`

Возвращает форматированный дамп дерева из *node*. Это в основном полезно для отладки. Если *annotate\_fields* равно true (по умолчанию), возвращаемая строка будет показывать имена и значения полей. Если *annotate\_fields* равно false, результирующая строка будет более компактной за счёт опускания однозначных имён полей. Атрибуты, такие как номера строк и смещения столбцов, по умолчанию не выводятся. Если это нужно, *include\_attributes* можно установить в true.

Если *indent* – неотрицательное целое число или строка, дерево будет выведено с отступами указанного уровня. Уровень отступа 0, отрицательное значение или `""` вставляет только переводы строк. `None` (по умолчанию) выбирает однострочное представление. Положительный целочисленный отступ добавляет соответствующее количество пробелов на уровень. Если *indent* – строка (например, `"\t"`), эта строка используется для отступа каждого уровня.

Если *show\_empty* равно false (по умолчанию), необязательные пустые списки будут опущены в выводе. Необязательные значения `None` всегда опускаются.

Изменено в версии 3.9: Добавлена опция *indent*.

Изменено в версии 3.13: Добавлена опция *show\_empty*.

```pycon
>>> print(ast.dump(ast.parse("""\
... async def f():
...     await other_func()
... """), indent=4, show_empty=True))
Module(
    body=[
        AsyncFunctionDef(
            name='f',
            args=arguments(
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]),
            body=[
                Expr(
                    value=Await(
                        value=Call(
                            func=Name(id='other_func', ctx=Load()),
                            args=[],
                            keywords=[])))],
            decorator_list=[],
            type_params=[])],
    type_ignores=[])
```

#### `ast.compare(a, b, /, *, compare_attributes=False)`

Рекурсивно сравнивает два AST.

*compare\_attributes* влияет на то, учитываются ли атрибуты AST при сравнении. Если *compare\_attributes* равно `False` (по умолчанию), атрибуты игнорируются. В противном случае они все должны быть равны. Эта опция полезна для проверки структурного равенства AST при различиях в пробелах или подобных деталях. Атрибуты включают номера строк и смещения столбцов.

Добавлено в версии 3.14.

## Флаги компилятора

Следующие флаги могут быть переданы в [`compile()`](https://python-all.ru/3.14/library/functions.html#compile) для изменения эффектов компиляции программы:

#### `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`

Включает поддержку `await`, `async for`, `async with` и асинхронных включений верхнего уровня.

Добавлено в версии 3.8.

#### `ast.PyCF_ONLY_AST`

Генерирует и возвращает абстрактное синтаксическое дерево вместо скомпилированного объекта кода.

#### `ast.PyCF_OPTIMIZED_AST`

Возвращаемое AST оптимизируется в соответствии с аргументом *optimize* в [`compile()`](https://python-all.ru/3.14/library/functions.html#compile) или [`ast.parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse).

Добавлено в версии 3.13.

#### `ast.PyCF_TYPE_COMMENTS`

Включает поддержку комментариев типов в стиле [**PEP 484**](https://python-all.ru/3.14/library/ast.html) и [**PEP 526**](https://python-all.ru/3.14/library/ast.html) (`# type: <type>`, `# type: ignore <stuff>`).

Добавлено в версии 3.8.

## Использование командной строки

Добавлено в версии 3.9.

Модуль `ast` может быть выполнен как скрипт из командной строки. Это просто:

```sh
python -m ast [-m <mode>] [-a] [infile]
```

Принимаются следующие опции:

#### `-h, --help`

Показать справку и выйти.

#### `-m <mode>`

#### `--mode <mode>`

Определяет, какой вид кода должен быть скомпилирован, как аргумент *mode* в [`parse()`](https://python-all.ru/3.14/library/ast.html#ast.parse).

#### `--no-type-comments`

Не обрабатывать комментарии типов.

#### `-a, --include-attributes`

Включать атрибуты, такие как номера строк и смещения столбцов.

#### `-i <indent>`

#### `--indent <indent>`

Отступ узлов в AST (количество пробелов).

#### `--feature-version <version>`

Версия Python в формате 3.x (например, 3.10). По умолчанию используется текущая версия интерпретатора.

Добавлено в версии 3.14.

#### `-O <level>`

#### `--optimize <level>`

Уровень оптимизации для парсера. По умолчанию оптимизация отключена.

Добавлено в версии 3.14.

#### `--show-empty`

Показывать пустые списки и поля, которые равны `None`. По умолчанию пустые объекты не показываются.

Добавлено в версии 3.14.

Если указан `infile`, его содержимое разбирается в AST и выводится в stdout. В противном случае содержимое читается из stdin.

> **См. также**
>
> [Green Tree Snakes](https://python-all.ru/3.14/library/ast.html) – внешний документационный ресурс, содержащий подробности работы с AST Python.
>
> [ASTTokens](https://python-all.ru/3.14/library/ast.html) дополняет AST Python позициями токенов и текста в исходном коде, который их породил. Это полезно для инструментов, выполняющих преобразования исходного кода.
>
> [leoAst.py](https://python-all.ru/3.14/library/ast.html) объединяет токен-ориентированное и синтаксическое представление программ Python, вставляя двунаправленные связи между токенами и узлами AST.
>
> [LibCST](https://python-all.ru/3.14/library/ast.html) разбирает код как конкретное синтаксическое дерево, похожее на AST, и сохраняет все детали форматирования. Это полезно для создания приложений автоматического рефакторинга (codemod) и линтеров.
>
> [Parso](https://python-all.ru/3.14/library/ast.html) – это парсер Python, поддерживающий восстановление после ошибок и сквозной разбор для разных версий Python (в нескольких версиях Python). Parso также может выводить несколько синтаксических ошибок в вашем файле Python.