ast.md

1> **Источник:** https://python-all.ru/3.13/library/ast.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# `ast` – абстрактные синтаксические деревья89**Исходный код:** [Lib/ast.py](https://python-all.ru/src/3.13/Lib/ast.py)1011---1213Модуль `ast` помогает приложениям Python обрабатывать деревья абстрактного синтаксиса языка Python. Абстрактный синтаксис может меняться от версии к версии; с помощью этого модуля можно программно узнать, как выглядит текущая грамматика.1415Абстрактное синтаксическое дерево можно создать, передав [`ast.PyCF_ONLY_AST`](https://python-all.ru/3.13/library/ast.html#ast.PyCF_ONLY_AST) в качестве флага встроенной функции [`compile()`](https://python-all.ru/3.13/library/functions.html#compile) или используя вспомогательную функцию [`parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse) из этого модуля. Результатом будет дерево объектов, классы которых наследуют от [`ast.AST`](https://python-all.ru/3.13/library/ast.html#ast.AST). Абстрактное синтаксическое дерево можно скомпилировать в объект кода Python с помощью встроенной функции `compile()`.1617## Абстрактная грамматика1819Абстрактная грамматика в настоящее время определяется следующим образом:2021```asdl22-- Встроенные типы ASDL:23-- идентификатор, целое, строка, константа2425module Python26{27    mod = Module(stmt* body, type_ignore* type_ignores)28        | Interactive(stmt* body)29        | Expression(expr body)30        | FunctionType(expr* argtypes, expr returns)3132    stmt = FunctionDef(identifier name, arguments args,33                       stmt* body, expr* decorator_list, expr? returns,34                       string? type_comment, type_param* type_params)35          | AsyncFunctionDef(identifier name, arguments args,36                             stmt* body, expr* decorator_list, expr? returns,37                             string? type_comment, type_param* type_params)3839          | ClassDef(identifier name,40             expr* bases,41             keyword* keywords,42             stmt* body,43             expr* decorator_list,44             type_param* type_params)45          | Return(expr? value)4647          | Delete(expr* targets)48          | Assign(expr* targets, expr value, string? type_comment)49          | TypeAlias(expr name, type_param* type_params, expr value)50          | AugAssign(expr target, operator op, expr value)51          -- 'simple' указывает, что аннотируется простое имя без скобок52          | AnnAssign(expr target, expr annotation, expr? value, int simple)5354          -- используется 'orelse', так как else – ключевое слово в целевых языках55          | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)56          | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)57          | While(expr test, stmt* body, stmt* orelse)58          | If(expr test, stmt* body, stmt* orelse)59          | With(withitem* items, stmt* body, string? type_comment)60          | AsyncWith(withitem* items, stmt* body, string? type_comment)6162          | Match(expr subject, match_case* cases)6364          | Raise(expr? exc, expr? cause)65          | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)66          | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)67          | Assert(expr test, expr? msg)6869          | Import(alias* names)70          | ImportFrom(identifier? module, alias* names, int? level)7172          | Global(identifier* names)73          | Nonlocal(identifier* names)74          | Expr(expr value)75          | Pass | Break | Continue7677          -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером78          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)7980          -- BoolOp() может использовать left и right?81    expr = BoolOp(boolop op, expr* values)82         | NamedExpr(expr target, expr value)83         | BinOp(expr left, operator op, expr right)84         | UnaryOp(unaryop op, expr operand)85         | Lambda(arguments args, expr body)86         | IfExp(expr test, expr body, expr orelse)87         | Dict(expr* keys, expr* values)88         | Set(expr* elts)89         | ListComp(expr elt, comprehension* generators)90         | SetComp(expr elt, comprehension* generators)91         | DictComp(expr key, expr value, comprehension* generators)92         | GeneratorExp(expr elt, comprehension* generators)93         -- грамматика ограничивает, где могут встречаться выражения yield94         | Await(expr value)95         | Yield(expr? value)96         | YieldFrom(expr value)97         -- нужны последовательности для сравнения, чтобы различать98         -- x < 4 < 3 and (x < 4) < 399         | Compare(expr left, cmpop* ops, expr* comparators)100         | Call(expr func, expr* args, keyword* keywords)101         | FormattedValue(expr value, int conversion, expr? format_spec)102         | JoinedStr(expr* values)103         | Constant(constant value, string? kind)104105         -- следующее выражение может появляться в контексте присваивания106         | Attribute(expr value, identifier attr, expr_context ctx)107         | Subscript(expr value, expr slice, expr_context ctx)108         | Starred(expr value, expr_context ctx)109         | Name(identifier id, expr_context ctx)110         | List(expr* elts, expr_context ctx)111         | Tuple(expr* elts, expr_context ctx)112113         -- может встречаться только в Subscript114         | Slice(expr? lower, expr? upper, expr? step)115116          -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером117          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)118119    expr_context = Load | Store | Del120121    boolop = And | Or122123    operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift124                 | RShift | BitOr | BitXor | BitAnd | FloorDiv125126    unaryop = Invert | Not | UAdd | USub127128    cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn129130    comprehension = (expr target, expr iter, expr* ifs, int is_async)131132    excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)133                    attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)134135    arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,136                 expr* kw_defaults, arg? kwarg, expr* defaults)137138    arg = (identifier arg, expr? annotation, string? type_comment)139           attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)140141    -- ключевые аргументы, переданные вызову (идентификатор NULL для **kwargs)142    keyword = (identifier? arg, expr value)143               attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)144145    -- имя импорта с необязательным псевдонимом 'as'146    alias = (identifier name, identifier? asname)147             attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)148149    withitem = (expr context_expr, expr? optional_vars)150151    match_case = (pattern pattern, expr? guard, stmt* body)152153    pattern = MatchValue(expr value)154            | MatchSingleton(constant value)155            | MatchSequence(pattern* patterns)156            | MatchMapping(expr* keys, pattern* patterns, identifier? rest)157            | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)158159            | MatchStar(identifier? name)160            -- необязательный параметр "rest" MatchMapping обрабатывает захват дополнительных ключей отображения161162            | MatchAs(pattern? pattern, identifier? name)163            | MatchOr(pattern* patterns)164165             attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)166167    type_ignore = TypeIgnore(int lineno, string tag)168169    type_param = TypeVar(identifier name, expr? bound, expr? default_value)170               | ParamSpec(identifier name, expr? default_value)171               | TypeVarTuple(identifier name, expr? default_value)172               attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)173}174```175176## Классы узлов177178#### `class ast.AST`179180Это базовый класс для всех узлов AST. Реальные классы узлов унаследованы из файла `Parser/Python.asdl`, который воспроизведён [выше](https://python-all.ru/3.13/library/ast.html#abstract-grammar). Они определены в C-модуле `_ast` и повторно экспортируются в `ast`.181182Для каждого символа левой части абстрактной грамматики определён один класс (например, `ast.stmt` или `ast.expr`). Кроме того, для каждого конструктора правой части определён один класс; эти классы наследуют от классов для деревьев левой части. Например, [`ast.BinOp`](https://python-all.ru/3.13/library/ast.html#ast.BinOp) наследует от `ast.expr`. Для продукционных правил с альтернативами (так называемых «сумм») класс левой части является абстрактным: создаются только экземпляры конкретных узлов-конструкторов.183184#### `_fields`185186Каждый конкретный класс имеет атрибут `_fields`, который содержит имена всех дочерних узлов.187188Каждый экземпляр конкретного класса имеет по одному атрибуту для каждого дочернего узла, тип которого определён в грамматике. Например, экземпляры [`ast.BinOp`](https://python-all.ru/3.13/library/ast.html#ast.BinOp) имеют атрибут `left` типа `ast.expr`.189190Если эти атрибуты помечены как необязательные в грамматике (с помощью вопросительного знака), значением может быть `None`. Если атрибуты могут иметь ноль или более значений (помечены звёздочкой), значения представляются в виде списков Python. Все возможные атрибуты должны присутствовать и иметь корректные значения при компиляции AST с помощью [`compile()`](https://python-all.ru/3.13/library/functions.html#compile).191192#### `_field_types`193194Атрибут `_field_types` каждого конкретного класса представляет собой словарь, отображающий имена полей (как указано в [`_fields`](https://python-all.ru/3.13/library/ast.html#ast.AST._fields)) в их типы.195196```pycon197>>> ast.TypeVar._field_types198{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr | None}199```200201Добавлено в версии 3.13.202203#### `lineno`204205#### `col_offset`206207#### `end_lineno`208209#### `end_col_offset`210211Экземпляры подклассов `ast.expr` и `ast.stmt` имеют атрибуты [`lineno`](https://python-all.ru/3.13/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.13/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.13/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.13/library/ast.html#ast.AST.end_col_offset). Атрибуты `lineno` и `end_lineno` – это номер первой и последней строки исходного текста (нумерация с 1, то есть первая строка – строка 1), а `col_offset` и `end_col_offset` – соответствующие смещения в байтах UTF-8 от первого и последнего токенов, породивших узел. Смещение UTF-8 записывается, потому что парсер использует UTF-8 внутри.212213Обратите внимание, что конечные позиции не требуются компилятором и поэтому являются необязательными. Смещение конца находится *после* последнего символа, например, можно получить фрагмент исходного кода узла выражения из одной строки с помощью `source_line[node.col_offset : node.end_col_offset]`.214215Конструктор класса `ast.T` разбирает свои аргументы следующим образом:216217- Если есть позиционные аргументы, их должно быть столько же, сколько элементов в `T._fields`; они будут присвоены как атрибуты с этими именами.218- Если есть ключевые аргументы, они установят атрибуты с теми же именами в указанные значения.219220Например, чтобы создать и заполнить узел [`ast.UnaryOp`](https://python-all.ru/3.13/library/ast.html#ast.UnaryOp), можно использовать221222```python223node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),224                   lineno=0, col_offset=0)225```226227Если поле, которое является необязательным в грамматике, опущено в конструкторе, оно по умолчанию равно `None`. Если опущено поле-список, оно по умолчанию равно пустому списку. Если опущено поле типа `ast.expr_context`, оно по умолчанию равно [`Load()`](https://python-all.ru/3.13/library/ast.html#ast.Load). Если опущено любое другое поле, возбуждается [`DeprecationWarning`](https://python-all.ru/3.13/library/exceptions.html#DeprecationWarning) и узел AST не будет иметь этого поля. В Python 3.15 это условие будет вызывать ошибку.228229Изменено в версии 3.8: Класс [`ast.Constant`](https://python-all.ru/3.13/library/ast.html#ast.Constant) теперь используется для всех констант.230231Изменено в версии 3.9: Простые индексы представляются своим значением, расширенные срезы представляются кортежами.232233Изменено в версии 3.13: Конструкторы узлов AST были изменены, чтобы предоставлять разумные значения по умолчанию для пропущенных полей: необязательные поля теперь по умолчанию равны `None`, поля-списки по умолчанию равны пустому списку, а поля типа `ast.expr_context` по умолчанию равны [`Load()`](https://python-all.ru/3.13/library/ast.html#ast.Load). Ранее пропущенные атрибуты отсутствовали у сконструированных узлов (при обращении к ним возбуждалось [`AttributeError`](https://python-all.ru/3.13/library/exceptions.html#AttributeError)).234235Устарело с версии 3.8: Старые классы `ast.Num`, `ast.Str`, `ast.Bytes`, `ast.NameConstant` и `ast.Ellipsis` всё ещё доступны, но будут удалены в будущих версиях Python. А пока их создание будет возвращать экземпляр другого класса.236237Устарело с версии 3.9: Старые классы `ast.Index` и `ast.ExtSlice` всё ещё доступны, но будут удалены в будущих выпусках Python. При этом при их создании будет возвращён экземпляр другого класса.238239Устарело с версии 3.13, будет удалено в версии 3.15: В предыдущих версиях Python допускалось создание узлов AST с отсутствующими обязательными полями. Кроме того, конструкторы узлов AST принимали произвольные ключевые аргументы, которые устанавливались как атрибуты узла AST, даже если они не соответствовали ни одному из полей узла AST. Это поведение устарело и будет удалено в Python 3.15.240241> **Примечание**242>243> Описания конкретных классов узлов, приведённые здесь, изначально были адаптированы из замечательного проекта [Green Tree Snakes](https://python-all.ru/3.13/library/ast.html) и всех его участников.244245### Корневые узлы246247#### `class ast.Module(body, type_ignores)`248249A Python module, as with [file input](https://python-all.ru/3.13/reference/toplevel_components.html#file-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse) in the default `"exec"` *mode*.250251`body` is a [`list`](https://python-all.ru/3.13/library/stdtypes.html#list) of the module’s [Statements](https://python-all.ru/3.13/library/ast.html#ast-statements).252253`type_ignores` – это список [`list`](https://python-all.ru/3.13/library/stdtypes.html#list) комментариев об игнорировании типов в модуле; подробнее см. в [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse).254255```pycon256>>> print(ast.dump(ast.parse('x = 1'), indent=4))257Module(258    body=[259        Assign(260            targets=[261                Name(id='x', ctx=Store())],262            value=Constant(value=1))])263```264265#### `class ast.Expression(body)`266267A single Python [expression input](https://python-all.ru/3.13/reference/toplevel_components.html#expression-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse) when *mode* is `"eval"`.268269`body` is a single node, one of the [expression types](https://python-all.ru/3.13/library/ast.html#ast-expressions).270271```pycon272>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))273Expression(274    body=Constant(value=123))275```276277#### `class ast.Interactive(body)`278279A single [interactive input](https://python-all.ru/3.13/reference/toplevel_components.html#interactive), like in [Interactive Mode](https://python-all.ru/3.13/tutorial/appendix.html#tut-interac). Node type generated by [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse) when *mode* is `"single"`.280281`body` is a [`list`](https://python-all.ru/3.13/library/stdtypes.html#list) of [statement nodes](https://python-all.ru/3.13/library/ast.html#ast-statements).282283```pycon284>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))285Interactive(286    body=[287        Assign(288            targets=[289                Name(id='x', ctx=Store())],290            value=Constant(value=1)),291        Assign(292            targets=[293                Name(id='y', ctx=Store())],294            value=Constant(value=2))])295```296297#### `class ast.FunctionType(argtypes, returns)`298299A 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.13/library/ast.html) annotations. Node type generated by [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse) when *mode* is `"func_type"`.300301Такие комментарии о типах выглядели следующим образом:302303```python304def sum_two_number(a, b):305    # type: (int, int) -> int306    return a + b307```308309`argtypes` is a [`list`](https://python-all.ru/3.13/library/stdtypes.html#list) of [expression nodes](https://python-all.ru/3.13/library/ast.html#ast-expressions).310311`returns` is a single [expression node](https://python-all.ru/3.13/library/ast.html#ast-expressions).312313```pycon314>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))315FunctionType(316    argtypes=[317        Name(id='int', ctx=Load()),318        Name(id='str', ctx=Load())],319    returns=Subscript(320        value=Name(id='List', ctx=Load()),321        slice=Name(id='int', ctx=Load()),322        ctx=Load()))323```324325Добавлено в версии 3.8.326327### Литералы328329#### `class ast.Constant(value, kind)`330331Постоянное значение. Атрибут `value` `Constant` литерала содержит представляемый объект Python. Представленными значениями могут быть экземпляры [`str`](https://python-all.ru/3.13/library/stdtypes.html#str), [`bytes`](https://python-all.ru/3.13/library/stdtypes.html#bytes), [`int`](https://python-all.ru/3.13/library/functions.html#int), [`float`](https://python-all.ru/3.13/library/functions.html#float), [`complex`](https://python-all.ru/3.13/library/functions.html#complex) и [`bool`](https://python-all.ru/3.13/library/functions.html#bool), а также константы [`None`](https://python-all.ru/3.13/library/constants.html#None) и [`Ellipsis`](https://python-all.ru/3.13/library/constants.html#Ellipsis).332333Атрибут `kind` – необязательная строка. Для строковых литералов с префиксом `u` значение `kind` устанавливается в `'u'`. Для всех остальных констант `kind` равно `None`.334335```pycon336>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))337Expression(338    body=Constant(value=123))339>>> print(ast.dump(ast.parse("u'hello'", mode='eval'), indent=4))340Expression(341    body=Constant(value='hello', kind='u'))342```343344#### `class ast.FormattedValue(value, conversion, format_spec)`345346Узел, представляющий одно поле форматирования в f-строке. Если строка содержит только одно поле форматирования и больше ничего, узел может быть изолированным; в противном случае он встречается внутри [`JoinedStr`](https://python-all.ru/3.13/library/ast.html#ast.JoinedStr).347348- `value` – это любой узел выражения (например, литерал, переменная или вызов функции).349- `conversion` – целое число:350351  - -1: без форматирования352  - 115: `!s` форматирование строк353  - 114: `!r` форматирование repr354  - 97: `!a` форматирование ascii355- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.13/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно.356357#### `class ast.JoinedStr(values)`358359F-строка, содержащая последовательность [`FormattedValue`](https://python-all.ru/3.13/library/ast.html#ast.FormattedValue) и [`Constant`](https://python-all.ru/3.13/library/ast.html#ast.Constant) узлов.360361```pycon362>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))363Expression(364    body=JoinedStr(365        values=[366            Constant(value='sin('),367            FormattedValue(368                value=Name(id='a', ctx=Load()),369                conversion=-1),370            Constant(value=') is '),371            FormattedValue(372                value=Call(373                    func=Name(id='sin', ctx=Load()),374                    args=[375                        Name(id='a', ctx=Load())]),376                conversion=-1,377                format_spec=JoinedStr(378                    values=[379                        Constant(value='.3')]))]))380```381382#### `class ast.List(elts, ctx)`383384#### `class ast.Tuple(elts, ctx)`385386Список или кортеж. `elts` содержит список узлов, представляющих элементы. `ctx` равен [`Store`](https://python-all.ru/3.13/library/ast.html#ast.Store), если контейнер является целью присваивания (т.е. `(x,y)=something`), и [`Load`](https://python-all.ru/3.13/library/ast.html#ast.Load) в противном случае.387388```pycon389>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))390Expression(391    body=List(392        elts=[393            Constant(value=1),394            Constant(value=2),395            Constant(value=3)],396        ctx=Load()))397>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))398Expression(399    body=Tuple(400        elts=[401            Constant(value=1),402            Constant(value=2),403            Constant(value=3)],404        ctx=Load()))405```406407#### `class ast.Set(elts)`408409Множество. `elts` содержит список узлов, представляющих элементы множества.410411```pycon412>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))413Expression(414    body=Set(415        elts=[416            Constant(value=1),417            Constant(value=2),418            Constant(value=3)]))419```420421#### `class ast.Dict(keys, values)`422423Словарь. `keys` и `values` содержат списки узлов, представляющих ключи и значения соответственно, в соответствующем порядке (то, что было бы возвращено при вызове `dictionary.keys()` и `dictionary.values()`).424425При распаковке словаря с помощью литералов словаря выражение, которое нужно раскрыть, помещается в список `values`, а `None` – на соответствующую позицию в `keys`.426427```pycon428>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))429Expression(430    body=Dict(431        keys=[432            Constant(value='a'),433            None],434        values=[435            Constant(value=1),436            Name(id='d', ctx=Load())]))437```438439### Переменные440441#### `class ast.Name(id, ctx)`442443Имя переменной. `id` содержит имя в виде строки, а `ctx` – один из следующих типов.444445#### `class ast.Load`446447#### `class ast.Store`448449#### `class ast.Del`450451Ссылки на переменные можно использовать для загрузки значения переменной, для присваивания ей нового значения или для её удаления. Ссылки на переменные получают контекст, чтобы различать эти случаи.452453```pycon454>>> print(ast.dump(ast.parse('a'), indent=4))455Module(456    body=[457        Expr(458            value=Name(id='a', ctx=Load()))])459460>>> print(ast.dump(ast.parse('a = 1'), indent=4))461Module(462    body=[463        Assign(464            targets=[465                Name(id='a', ctx=Store())],466            value=Constant(value=1))])467468>>> print(ast.dump(ast.parse('del a'), indent=4))469Module(470    body=[471        Delete(472            targets=[473                Name(id='a', ctx=Del())])])474```475476#### `class ast.Starred(value, ctx)`477478Ссылка на переменную `*var`. В `value` хранится переменная, обычно узел [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name). Этот тип необходимо использовать при построении узла [`Call`](https://python-all.ru/3.13/library/ast.html#ast.Call) с помощью `*args`.479480```pycon481>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))482Module(483    body=[484        Assign(485            targets=[486                Tuple(487                    elts=[488                        Name(id='a', ctx=Store()),489                        Starred(490                            value=Name(id='b', ctx=Store()),491                            ctx=Store())],492                    ctx=Store())],493            value=Name(id='it', ctx=Load()))])494```495496### Выражения497498#### `class ast.Expr(value)`499500Когда выражение, например вызов функции, выступает в роли самостоятельного оператора и его возвращаемое значение не используется и не сохраняется, оно помещается в этот контейнер. `value` содержит один из остальных узлов этого раздела: узел [`Constant`](https://python-all.ru/3.13/library/ast.html#ast.Constant), узел [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name), [`Lambda`](https://python-all.ru/3.13/library/ast.html#ast.Lambda), [`Yield`](https://python-all.ru/3.13/library/ast.html#ast.Yield) или [`YieldFrom`](https://python-all.ru/3.13/library/ast.html#ast.YieldFrom).501502```pycon503>>> print(ast.dump(ast.parse('-a'), indent=4))504Module(505    body=[506        Expr(507            value=UnaryOp(508                op=USub(),509                operand=Name(id='a', ctx=Load())))])510```511512#### `class ast.UnaryOp(op, operand)`513514Унарная операция. `op` – оператор, а `operand` – любой узел выражения.515516#### `class ast.UAdd`517518#### `class ast.USub`519520#### `class ast.Not`521522#### `class ast.Invert`523524Токены унарных операторов. `Not` – ключевое слово `not`, `Invert` – оператор `~`.525526```pycon527>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))528Expression(529    body=UnaryOp(530        op=Not(),531        operand=Name(id='x', ctx=Load())))532```533534#### `class ast.BinOp(left, op, right)`535536Бинарная операция (например, сложение или деление). `op` – оператор, а `left` и `right` – любые узлы выражений.537538```pycon539>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))540Expression(541    body=BinOp(542        left=Name(id='x', ctx=Load()),543        op=Add(),544        right=Name(id='y', ctx=Load())))545```546547#### `class ast.Add`548549#### `class ast.Sub`550551#### `class ast.Mult`552553#### `class ast.Div`554555#### `class ast.FloorDiv`556557#### `class ast.Mod`558559#### `class ast.Pow`560561#### `class ast.LShift`562563#### `class ast.RShift`564565#### `class ast.BitOr`566567#### `class ast.BitXor`568569#### `class ast.BitAnd`570571#### `class ast.MatMult`572573Токены бинарных операторов.574575#### `class ast.BoolOp(op, values)`576577Логическая операция – 'or' или 'and'. `op` – это [`Or`](https://python-all.ru/3.13/library/ast.html#ast.Or) или [`And`](https://python-all.ru/3.13/library/ast.html#ast.And). `values` – участвующие значения. Последовательные операции с одним и тем же оператором, например `a or b or c`, сводятся в один узел с несколькими значениями.578579Это не включает `not`, который является [`UnaryOp`](https://python-all.ru/3.13/library/ast.html#ast.UnaryOp).580581```pycon582>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))583Expression(584    body=BoolOp(585        op=Or(),586        values=[587            Name(id='x', ctx=Load()),588            Name(id='y', ctx=Load())]))589```590591#### `class ast.And`592593#### `class ast.Or`594595Токены логических операторов.596597#### `class ast.Compare(left, ops, comparators)`598599Сравнение двух или более значений. `left` – первое значение в сравнении, `ops` – список операторов, а `comparators` – список значений после первого элемента сравнения.600601```pycon602>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))603Expression(604    body=Compare(605        left=Constant(value=1),606        ops=[607            LtE(),608            Lt()],609        comparators=[610            Name(id='a', ctx=Load()),611            Constant(value=10)]))612```613614#### `class ast.Eq`615616#### `class ast.NotEq`617618#### `class ast.Lt`619620#### `class ast.LtE`621622#### `class ast.Gt`623624#### `class ast.GtE`625626#### `class ast.Is`627628#### `class ast.IsNot`629630#### `class ast.In`631632#### `class ast.NotIn`633634Токены операторов сравнения.635636#### `class ast.Call(func, args, keywords)`637638Вызов функции. `func` – это функция; обычно это объект [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name) или [`Attribute`](https://python-all.ru/3.13/library/ast.html#ast.Attribute). Об аргументах:639640- `args` содержит список аргументов, переданных по позиции.641- `keywords` содержит список объектов [`keyword`](https://python-all.ru/3.13/library/ast.html#ast.keyword), представляющих аргументы, переданные по ключевому слову.642643Аргументы `args` и `keywords` необязательны и по умолчанию равны пустым спискам.644645```pycon646>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))647Expression(648    body=Call(649        func=Name(id='func', ctx=Load()),650        args=[651            Name(id='a', ctx=Load()),652            Starred(653                value=Name(id='d', ctx=Load()),654                ctx=Load())],655        keywords=[656            keyword(657                arg='b',658                value=Name(id='c', ctx=Load())),659            keyword(660                value=Name(id='e', ctx=Load()))]))661```662663#### `class ast.keyword(arg, value)`664665Именованный аргумент вызова функции или определения класса. `arg` – это необработанная строка с именем параметра, `value` – узел, который нужно передать.666667#### `class ast.IfExp(test, body, orelse)`668669Выражение, например `a if b else c`. Каждое поле содержит один узел, поэтому в следующем примере все три являются узлами [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name).670671```pycon672>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))673Expression(674    body=IfExp(675        test=Name(id='b', ctx=Load()),676        body=Name(id='a', ctx=Load()),677        orelse=Name(id='c', ctx=Load())))678```679680#### `class ast.Attribute(value, attr, ctx)`681682Доступ к атрибуту, например `d.keys`. `value` – это узел, обычно [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name). `attr` – это строка с именем атрибута, а `ctx` – [`Load`](https://python-all.ru/3.13/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.13/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.13/library/ast.html#ast.Del) в зависимости от того, как используется атрибут.683684```pycon685>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))686Expression(687    body=Attribute(688        value=Name(id='snake', ctx=Load()),689        attr='colour',690        ctx=Load()))691```692693#### `class ast.NamedExpr(target, value)`694695Именованное выражение. Этот узел AST создаётся оператором присваивания (также известным как оператор «морж»). В отличие от узла [`Assign`](https://python-all.ru/3.13/library/ast.html#ast.Assign), где первый аргумент может быть несколькими узлами, в данном случае и `target`, и `value` должны быть одиночными узлами.696697```pycon698>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))699Expression(700    body=NamedExpr(701        target=Name(id='x', ctx=Store()),702        value=Constant(value=4)))703```704705Добавлено в версии 3.8.706707#### Индексирование708709#### `class ast.Subscript(value, slice, ctx)`710711Индексация, такая как `l[1]`. `value` – индексируемый объект (обычно последовательность или отображение). `slice` – это индекс, срез или ключ. Оно может быть [`Tuple`](https://python-all.ru/3.13/library/ast.html#ast.Tuple) и содержать [`Slice`](https://python-all.ru/3.13/library/ast.html#ast.Slice). `ctx` является [`Load`](https://python-all.ru/3.13/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.13/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.13/library/ast.html#ast.Del) в зависимости от выполняемого действия при индексации.712713```pycon714>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))715Expression(716    body=Subscript(717        value=Name(id='l', ctx=Load()),718        slice=Tuple(719            elts=[720                Slice(721                    lower=Constant(value=1),722                    upper=Constant(value=2)),723                Constant(value=3)],724            ctx=Load()),725        ctx=Load()))726```727728#### `class ast.Slice(lower, upper, step)`729730Обычный срез (в виде `lower:upper` или `lower:upper:step`). Может встречаться только внутри поля *slice* узла [`Subscript`](https://python-all.ru/3.13/library/ast.html#ast.Subscript), либо напрямую, либо как элемент [`Tuple`](https://python-all.ru/3.13/library/ast.html#ast.Tuple).731732```pycon733>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))734Expression(735    body=Subscript(736        value=Name(id='l', ctx=Load()),737        slice=Slice(738            lower=Constant(value=1),739            upper=Constant(value=2)),740        ctx=Load()))741```742743#### Генераторы коллекций744745#### `class ast.ListComp(elt, generators)`746747#### `class ast.SetComp(elt, generators)`748749#### `class ast.GeneratorExp(elt, generators)`750751#### `class ast.DictComp(key, value, generators)`752753Генераторы списков и множеств, генераторные выражения и генераторы словарей. `elt` (или `key` и `value`) – это один узел, представляющий часть, которая будет вычисляться для каждого элемента.754755`generators` – это список узлов [`comprehension`](https://python-all.ru/3.13/library/ast.html#ast.comprehension).756757```pycon758>>> print(ast.dump(759...     ast.parse('[x for x in numbers]', mode='eval'),760...     indent=4,761... ))762Expression(763    body=ListComp(764        elt=Name(id='x', ctx=Load()),765        generators=[766            comprehension(767                target=Name(id='x', ctx=Store()),768                iter=Name(id='numbers', ctx=Load()),769                is_async=0)]))770>>> print(ast.dump(771...     ast.parse('{x: x**2 for x in numbers}', mode='eval'),772...     indent=4,773... ))774Expression(775    body=DictComp(776        key=Name(id='x', ctx=Load()),777        value=BinOp(778            left=Name(id='x', ctx=Load()),779            op=Pow(),780            right=Constant(value=2)),781        generators=[782            comprehension(783                target=Name(id='x', ctx=Store()),784                iter=Name(id='numbers', ctx=Load()),785                is_async=0)]))786>>> print(ast.dump(787...     ast.parse('{x for x in numbers}', mode='eval'),788...     indent=4,789... ))790Expression(791    body=SetComp(792        elt=Name(id='x', ctx=Load()),793        generators=[794            comprehension(795                target=Name(id='x', ctx=Store()),796                iter=Name(id='numbers', ctx=Load()),797                is_async=0)]))798```799800#### `class ast.comprehension(target, iter, ifs, is_async)`801802Одно предложение `for` в генераторе коллекции. `target` – это ссылка, используемая для каждого элемента (обычно узел [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name) или [`Tuple`](https://python-all.ru/3.13/library/ast.html#ast.Tuple)). `iter` – объект, по которому выполняется итерация. `ifs` – список проверочных выражений: каждое предложение `for` может содержать несколько `ifs`.803804`is_async` указывает, что генератор коллекции является асинхронным (использует `async for` вместо `for`). Значение – целое число (0 или 1).805806```pycon807>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),808...                indent=4)) # несколько включений в одном809Expression(810    body=ListComp(811        elt=Call(812            func=Name(id='ord', ctx=Load()),813            args=[814                Name(id='c', ctx=Load())]),815        generators=[816            comprehension(817                target=Name(id='line', ctx=Store()),818                iter=Name(id='file', ctx=Load()),819                is_async=0),820            comprehension(821                target=Name(id='c', ctx=Store()),822                iter=Name(id='line', ctx=Load()),823                is_async=0)]))824825>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),826...                indent=4)) # выражение-генератор827Expression(828    body=GeneratorExp(829        elt=BinOp(830            left=Name(id='n', ctx=Load()),831            op=Pow(),832            right=Constant(value=2)),833        generators=[834            comprehension(835                target=Name(id='n', ctx=Store()),836                iter=Name(id='it', ctx=Load()),837                ifs=[838                    Compare(839                        left=Name(id='n', ctx=Load()),840                        ops=[841                            Gt()],842                        comparators=[843                            Constant(value=5)]),844                    Compare(845                        left=Name(id='n', ctx=Load()),846                        ops=[847                            Lt()],848                        comparators=[849                            Constant(value=10)])],850                is_async=0)]))851852>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),853...                indent=4)) # асинхронное включение854Expression(855    body=ListComp(856        elt=Name(id='i', ctx=Load()),857        generators=[858            comprehension(859                target=Name(id='i', ctx=Store()),860                iter=Name(id='soc', ctx=Load()),861                is_async=1)]))862```863864### Инструкции865866#### `class ast.Assign(targets, value, type_comment)`867868Присваивание. `targets` – список узлов, а `value` – один узел.869870Несколько узлов в `targets` обозначают присваивание одного и того же значения каждому. Распаковка представляется помещением узла [`Tuple`](https://python-all.ru/3.13/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.13/library/ast.html#ast.List) внутрь `targets`.871872#### `type_comment`873874`type_comment` – это необязательная строка с аннотацией типа в виде комментария.875876```pycon877>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # множественное присваивание878Module(879    body=[880        Assign(881            targets=[882                Name(id='a', ctx=Store()),883                Name(id='b', ctx=Store())],884            value=Constant(value=1))])885886>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # распаковка887Module(888    body=[889        Assign(890            targets=[891                Tuple(892                    elts=[893                        Name(id='a', ctx=Store()),894                        Name(id='b', ctx=Store())],895                    ctx=Store())],896            value=Name(id='c', ctx=Load()))])897```898899#### `class ast.AnnAssign(target, annotation, value, simple)`900901Присваивание с аннотацией типа. `target` – это один узел, который может быть [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.13/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.13/library/ast.html#ast.Subscript). `annotation` – аннотация, например узел [`Constant`](https://python-all.ru/3.13/library/ast.html#ast.Constant) или `Name`. `value` – один необязательный узел.902903`simple` всегда равен либо 0 (обозначает «сложную» цель), либо 1 (обозначает «простую» цель). «Простая» цель состоит только из узла [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name), который не находится в круглых скобках; все остальные цели считаются сложными. Только простые цели появляются в словаре `__annotations__` модулей и классов.904905```pycon906>>> print(ast.dump(ast.parse('c: int'), indent=4))907Module(908    body=[909        AnnAssign(910            target=Name(id='c', ctx=Store()),911            annotation=Name(id='int', ctx=Load()),912            simple=1)])913914>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # аннотация со скобками915Module(916    body=[917        AnnAssign(918            target=Name(id='a', ctx=Store()),919            annotation=Name(id='int', ctx=Load()),920            value=Constant(value=1),921            simple=0)])922923>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # аннотация атрибута924Module(925    body=[926        AnnAssign(927            target=Attribute(928                value=Name(id='a', ctx=Load()),929                attr='b',930                ctx=Store()),931            annotation=Name(id='int', ctx=Load()),932            simple=0)])933934>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # аннотация подписки935Module(936    body=[937        AnnAssign(938            target=Subscript(939                value=Name(id='a', ctx=Load()),940                slice=Constant(value=1),941                ctx=Store()),942            annotation=Name(id='int', ctx=Load()),943            simple=0)])944```945946#### `class ast.AugAssign(target, op, value)`947948Расширенное присваивание, например `a += 1`. В следующем примере `target` – это узел [Имя](https://python-all.ru/3.13/library/ast.html#ast.Name) для `x` (с контекстом [`Store`](https://python-all.ru/3.13/library/ast.html#ast.Store)), `op` – это [Сложение](https://python-all.ru/3.13/library/ast.html#ast.Add), а `value` – это [Константа](https://python-all.ru/3.13/library/ast.html#ast.Constant) со значением 1.949950Атрибут `target` не может быть класса [`Tuple`](https://python-all.ru/3.13/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.13/library/ast.html#ast.List), в отличие от целей [`Assign`](https://python-all.ru/3.13/library/ast.html#ast.Assign).951952```pycon953>>> print(ast.dump(ast.parse('x += 2'), indent=4))954Module(955    body=[956        AugAssign(957            target=Name(id='x', ctx=Store()),958            op=Add(),959            value=Constant(value=2))])960```961962#### `class ast.Raise(exc, cause)`963964Инструкция `raise`. `exc` – объект исключения, который необходимо возбудить, обычно [Вызов](https://python-all.ru/3.13/library/ast.html#ast.Call) или [Имя](https://python-all.ru/3.13/library/ast.html#ast.Name), или `None` для отдельного `raise`. `cause` – необязательная часть для `y` в `Возбуждение`.965966```pycon967>>> print(ast.dump(ast.parse('raise x from y'), indent=4))968Module(969    body=[970        Raise(971            exc=Name(id='x', ctx=Load()),972            cause=Name(id='y', ctx=Load()))])973```974975#### `class ast.Assert(test, msg)`976977Утверждение. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.13/library/ast.html#ast.Compare). `msg` содержит сообщение об ошибке.978979```pycon980>>> print(ast.dump(ast.parse('assert x,y'), indent=4))981Module(982    body=[983        Assert(984            test=Name(id='x', ctx=Load()),985            msg=Name(id='y', ctx=Load()))])986```987988#### `class ast.Delete(targets)`989990Представляет инструкцию `del`. `targets` – список узлов, например узлов [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.13/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.13/library/ast.html#ast.Subscript).991992```pycon993>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))994Module(995    body=[996        Delete(997            targets=[998                Name(id='x', ctx=Del()),999                Name(id='y', ctx=Del()),1000                Name(id='z', ctx=Del())])])1001```10021003#### `class ast.Pass`10041005Инструкция `pass`.10061007```pycon1008>>> print(ast.dump(ast.parse('pass'), indent=4))1009Module(1010    body=[1011        Pass()])1012```10131014#### `class ast.TypeAlias(name, type_params, value)`10151016[Псевдоним типа](https://python-all.ru/3.13/library/typing.html#type-aliases), созданный с помощью инструкции [`type`](https://python-all.ru/3.13/reference/simple_stmts.html#type) . `name` – имя псевдонима, `type_params` – список [параметров типа](https://python-all.ru/3.13/library/ast.html#ast-type-params), а `value` – значение псевдонима типа.10171018```pycon1019>>> print(ast.dump(ast.parse('type Alias = int'), indent=4))1020Module(1021    body=[1022        TypeAlias(1023            name=Name(id='Alias', ctx=Store()),1024            value=Name(id='int', ctx=Load()))])1025```10261027Добавлено в версии 3.12.10281029Другие инструкции, которые применимы только внутри функций или циклов, описаны в других разделах.10301031#### Импорты10321033#### `class ast.Import(names)`10341035Инструкция импорта. `names` – это список узлов [`alias`](https://python-all.ru/3.13/library/ast.html#ast.alias).10361037```pycon1038>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))1039Module(1040    body=[1041        Import(1042            names=[1043                alias(name='x'),1044                alias(name='y'),1045                alias(name='z')])])1046```10471048#### `class ast.ImportFrom(module, names, level)`10491050Представляет `from x import y`. `module` – это необработанная строка имени from, без начальных точек, или `None` для инструкций вроде `from . import foo`. `level` – целое число, указывающее уровень относительного импорта (0 означает абсолютный импорт).10511052```pycon1053>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))1054Module(1055    body=[1056        ImportFrom(1057            module='y',1058            names=[1059                alias(name='x'),1060                alias(name='y'),1061                alias(name='z')],1062            level=0)])1063```10641065#### `class ast.alias(name, asname)`10661067Оба параметра – необработанные строки имён. `asname` может быть `None`, если должно использоваться обычное имя.10681069```pycon1070>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))1071Module(1072    body=[1073        ImportFrom(1074            module='foo.bar',1075            names=[1076                alias(name='a', asname='b'),1077                alias(name='c')],1078            level=2)])1079```10801081### Управление потоком10821083> **Примечание**1084>1085> Необязательные предложения, такие как `else`, сохраняются как пустой список, если они отсутствуют.10861087#### `class ast.If(test, body, orelse)`10881089Инструкция `if`. `test` содержит один узел, например узел [`Compare`](https://python-all.ru/3.13/library/ast.html#ast.Compare). `body` и `orelse` содержат по списку узлов.10901091Предложения `elif` не имеют специального представления в AST, а появляются как дополнительные узлы `If` в разделе `orelse` предыдущего.10921093```pycon1094>>> print(ast.dump(ast.parse("""1095... if x:1096...    ...1097... elif y:1098...    ...1099... else:1100...    ...1101... """), indent=4))1102Module(1103    body=[1104        If(1105            test=Name(id='x', ctx=Load()),1106            body=[1107                Expr(1108                    value=Constant(value=Ellipsis))],1109            orelse=[1110                If(1111                    test=Name(id='y', ctx=Load()),1112                    body=[1113                        Expr(1114                            value=Constant(value=Ellipsis))],1115                    orelse=[1116                        Expr(1117                            value=Constant(value=Ellipsis))])])])1118```11191120#### `class ast.For(target, iter, body, orelse, type_comment)`11211122Цикл `for`. `target` содержит переменную (или переменные), которой присваивает цикл, в виде одного узла [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.13/library/ast.html#ast.Tuple), [`List`](https://python-all.ru/3.13/library/ast.html#ast.List), [`Attribute`](https://python-all.ru/3.13/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.13/library/ast.html#ast.Subscript). `iter` содержит элемент, по которому выполняется итерация, также в виде одного узла. `body` и `orelse` содержат списки узлов для выполнения. Те, что в `orelse`, выполняются, если цикл завершается нормально, а не по инструкции `break`.11231124#### `type_comment`11251126`type_comment` – это необязательная строка с аннотацией типа в виде комментария.11271128```pycon1129>>> print(ast.dump(ast.parse("""1130... for x in y:1131...     ...1132... else:1133...     ...1134... """), indent=4))1135Module(1136    body=[1137        For(1138            target=Name(id='x', ctx=Store()),1139            iter=Name(id='y', ctx=Load()),1140            body=[1141                Expr(1142                    value=Constant(value=Ellipsis))],1143            orelse=[1144                Expr(1145                    value=Constant(value=Ellipsis))])])1146```11471148#### `class ast.While(test, body, orelse)`11491150Цикл `while`. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.13/library/ast.html#ast.Compare).11511152```pycon1153>>> print(ast.dump(ast.parse("""1154... while x:1155...    ...1156... else:1157...    ...1158... """), indent=4))1159Module(1160    body=[1161        While(1162            test=Name(id='x', ctx=Load()),1163            body=[1164                Expr(1165                    value=Constant(value=Ellipsis))],1166            orelse=[1167                Expr(1168                    value=Constant(value=Ellipsis))])])1169```11701171#### `class ast.Break`11721173#### `class ast.Continue`11741175Инструкции `break` и `continue`.11761177```pycon1178>>> print(ast.dump(ast.parse("""\1179... for a in b:1180...     if a > 5:1181...         break1182...     else:1183...         continue1184...1185... """), indent=4))1186Module(1187    body=[1188        For(1189            target=Name(id='a', ctx=Store()),1190            iter=Name(id='b', ctx=Load()),1191            body=[1192                If(1193                    test=Compare(1194                        left=Name(id='a', ctx=Load()),1195                        ops=[1196                            Gt()],1197                        comparators=[1198                            Constant(value=5)]),1199                    body=[1200                        Break()],1201                    orelse=[1202                        Continue()])])])1203```12041205#### `class ast.Try(body, handlers, orelse, finalbody)`12061207Блоки `try`. Все атрибуты – списки узлов для выполнения, за исключением `handlers`, который является списком узлов [`ExceptHandler`](https://python-all.ru/3.13/library/ast.html#ast.ExceptHandler).12081209```pycon1210>>> print(ast.dump(ast.parse("""1211... try:1212...    ...1213... except Exception:1214...    ...1215... except OtherException as e:1216...    ...1217... else:1218...    ...1219... finally:1220...    ...1221... """), indent=4))1222Module(1223    body=[1224        Try(1225            body=[1226                Expr(1227                    value=Constant(value=Ellipsis))],1228            handlers=[1229                ExceptHandler(1230                    type=Name(id='Exception', ctx=Load()),1231                    body=[1232                        Expr(1233                            value=Constant(value=Ellipsis))]),1234                ExceptHandler(1235                    type=Name(id='OtherException', ctx=Load()),1236                    name='e',1237                    body=[1238                        Expr(1239                            value=Constant(value=Ellipsis))])],1240            orelse=[1241                Expr(1242                    value=Constant(value=Ellipsis))],1243            finalbody=[1244                Expr(1245                    value=Constant(value=Ellipsis))])])1246```12471248#### `class ast.TryStar(body, handlers, orelse, finalbody)`12491250Блоки `try`, за которыми следуют предложения `except*`. Атрибуты такие же, как для [`Try`](https://python-all.ru/3.13/library/ast.html#ast.Try), но узлы [`ExceptHandler`](https://python-all.ru/3.13/library/ast.html#ast.ExceptHandler) в `handlers` интерпретируются как блоки `except*`, а не `except`.12511252```pycon1253>>> print(ast.dump(ast.parse("""1254... try:1255...    ...1256... except* Exception:1257...    ...1258... """), indent=4))1259Module(1260    body=[1261        TryStar(1262            body=[1263                Expr(1264                    value=Constant(value=Ellipsis))],1265            handlers=[1266                ExceptHandler(1267                    type=Name(id='Exception', ctx=Load()),1268                    body=[1269                        Expr(1270                            value=Constant(value=Ellipsis))])])])1271```12721273Добавлено в версии 3.12.12741275#### `class ast.ExceptHandler(type, name, body)`12761277Одно предложение `except`. `type` – тип исключения, который оно перехватывает, обычно узел [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name) (или `None` для универсального предложения `except:`). `name` – необработанная строка для имени, в котором будет сохранено исключение, или `None`, если в предложении нет `as foo`. `body` – список узлов.12781279```pycon1280>>> print(ast.dump(ast.parse("""\1281... try:1282...     a + 11283... except TypeError:1284...     pass1285... """), indent=4))1286Module(1287    body=[1288        Try(1289            body=[1290                Expr(1291                    value=BinOp(1292                        left=Name(id='a', ctx=Load()),1293                        op=Add(),1294                        right=Constant(value=1)))],1295            handlers=[1296                ExceptHandler(1297                    type=Name(id='TypeError', ctx=Load()),1298                    body=[1299                        Pass()])])])1300```13011302#### `class ast.With(items, body, type_comment)`13031304Блок `with`. `items` – это список узлов [`withitem`](https://python-all.ru/3.13/library/ast.html#ast.withitem), представляющих менеджеры контекста, а `body` – это блок с отступом внутри контекста.13051306#### `type_comment`13071308`type_comment` – это необязательная строка с аннотацией типа в виде комментария.13091310#### `class ast.withitem(context_expr, optional_vars)`13111312Один менеджер контекста в блоке `with`. `context_expr` – это менеджер контекста, часто узел [`Call`](https://python-all.ru/3.13/library/ast.html#ast.Call). `optional_vars` – это [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.13/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.13/library/ast.html#ast.List) для части `as foo`, или `None`, если она не используется.13131314```pycon1315>>> print(ast.dump(ast.parse("""\1316... with a as b, c as d:1317...    something(b, d)1318... """), indent=4))1319Module(1320    body=[1321        With(1322            items=[1323                withitem(1324                    context_expr=Name(id='a', ctx=Load()),1325                    optional_vars=Name(id='b', ctx=Store())),1326                withitem(1327                    context_expr=Name(id='c', ctx=Load()),1328                    optional_vars=Name(id='d', ctx=Store()))],1329            body=[1330                Expr(1331                    value=Call(1332                        func=Name(id='something', ctx=Load()),1333                        args=[1334                            Name(id='b', ctx=Load()),1335                            Name(id='d', ctx=Load())]))])])1336```13371338### Сопоставление с образцом13391340#### `class ast.Match(subject, cases)`13411342Оператор `match`. В `subject` хранится subject сопоставления (объект, который сравнивается с вариантами), а `cases` содержит итерируемый набор узлов [`match_case`](https://python-all.ru/3.13/library/ast.html#ast.match_case) с различными вариантами.13431344Добавлено в версии 3.10.13451346#### `class ast.match_case(pattern, guard, body)`13471348Один вариант (case) в операторе `match`. `pattern` содержит шаблон сопоставления, с которым будет сравниваться subject. Обратите внимание, что узлы [`AST`](https://python-all.ru/3.13/library/ast.html#ast.AST), создаваемые для шаблонов, отличаются от узлов, создаваемых для выражений, даже при одинаковом синтаксисе.13491350Атрибут `guard` содержит выражение, которое будет вычислено, если шаблон совпадает с subject.13511352`body` содержит список узлов, которые выполняются, если шаблон совпадает и результат вычисления guard-выражения истинен.13531354```pycon1355>>> print(ast.dump(ast.parse("""1356... match x:1357...     case [x] if x>0:1358...         ...1359...     case tuple():1360...         ...1361... """), indent=4))1362Module(1363    body=[1364        Match(1365            subject=Name(id='x', ctx=Load()),1366            cases=[1367                match_case(1368                    pattern=MatchSequence(1369                        patterns=[1370                            MatchAs(name='x')]),1371                    guard=Compare(1372                        left=Name(id='x', ctx=Load()),1373                        ops=[1374                            Gt()],1375                        comparators=[1376                            Constant(value=0)]),1377                    body=[1378                        Expr(1379                            value=Constant(value=Ellipsis))]),1380                match_case(1381                    pattern=MatchClass(1382                        cls=Name(id='tuple', ctx=Load())),1383                    body=[1384                        Expr(1385                            value=Constant(value=Ellipsis))])])])1386```13871388Добавлено в версии 3.10.13891390#### `class ast.MatchValue(value)`13911392Сопоставление с литералом или шаблоном значения, сравниваемым по равенству. `value` – это узел выражения. Допустимые узлы значений ограничены, как описано в документации оператора match. Этот шаблон успешно срабатывает, если subject сопоставления равен вычисленному значению.13931394```pycon1395>>> print(ast.dump(ast.parse("""1396... match x:1397...     case "Relevant":1398...         ...1399... """), indent=4))1400Module(1401    body=[1402        Match(1403            subject=Name(id='x', ctx=Load()),1404            cases=[1405                match_case(1406                    pattern=MatchValue(1407                        value=Constant(value='Relevant')),1408                    body=[1409                        Expr(1410                            value=Constant(value=Ellipsis))])])])1411```14121413Добавлено в версии 3.10.14141415#### `class ast.MatchSingleton(value)`14161417Сопоставление с литералом, сравниваемым по идентичности. `value` – это синглтон, с которым производится сравнение: `None`, `True` или `False`. Этот шаблон успешно срабатывает, если subject сопоставления является заданной константой.14181419```pycon1420>>> print(ast.dump(ast.parse("""1421... match x:1422...     case None:1423...         ...1424... """), indent=4))1425Module(1426    body=[1427        Match(1428            subject=Name(id='x', ctx=Load()),1429            cases=[1430                match_case(1431                    pattern=MatchSingleton(value=None),1432                    body=[1433                        Expr(1434                            value=Constant(value=Ellipsis))])])])1435```14361437Добавлено в версии 3.10.14381439#### `class ast.MatchSequence(patterns)`14401441Шаблон последовательности (sequence pattern) в match. `patterns` содержит шаблоны, которые будут сопоставляться с элементами subject, если subject является последовательностью. Сопоставляется с последовательностью переменной длины, если один из подшаблонов является узлом `MatchStar`, в противном случае сопоставляется с последовательностью фиксированной длины.14421443```pycon1444>>> print(ast.dump(ast.parse("""1445... match x:1446...     case [1, 2]:1447...         ...1448... """), indent=4))1449Module(1450    body=[1451        Match(1452            subject=Name(id='x', ctx=Load()),1453            cases=[1454                match_case(1455                    pattern=MatchSequence(1456                        patterns=[1457                            MatchValue(1458                                value=Constant(value=1)),1459                            MatchValue(1460                                value=Constant(value=2))]),1461                    body=[1462                        Expr(1463                            value=Constant(value=Ellipsis))])])])1464```14651466Добавлено в версии 3.10.14671468#### `class ast.MatchStar(name)`14691470Сопоставляется с остатком последовательности в шаблоне последовательности переменной длины. Если `name` не равно `None`, то при успешном сопоставлении всего шаблона последовательности этому имени привязывается список, содержащий оставшиеся элементы последовательности.14711472```pycon1473>>> print(ast.dump(ast.parse("""1474... match x:1475...     case [1, 2, *rest]:1476...         ...1477...     case [*_]:1478...         ...1479... """), indent=4))1480Module(1481    body=[1482        Match(1483            subject=Name(id='x', ctx=Load()),1484            cases=[1485                match_case(1486                    pattern=MatchSequence(1487                        patterns=[1488                            MatchValue(1489                                value=Constant(value=1)),1490                            MatchValue(1491                                value=Constant(value=2)),1492                            MatchStar(name='rest')]),1493                    body=[1494                        Expr(1495                            value=Constant(value=Ellipsis))]),1496                match_case(1497                    pattern=MatchSequence(1498                        patterns=[1499                            MatchStar()]),1500                    body=[1501                        Expr(1502                            value=Constant(value=Ellipsis))])])])1503```15041505Добавлено в версии 3.10.15061507#### `class ast.MatchMapping(keys, patterns, rest)`15081509Шаблон отображения (mapping pattern) в match. `keys` – последовательность узлов выражений. `patterns` – соответствующая последовательность узлов шаблонов. `rest` – необязательное имя, которое можно указать для захвата оставшихся элементов отображения. Допустимые ключевые выражения ограничены, как описано в документации оператора match.15101511Этот шаблон успешно срабатывает, если subject является отображением, все вычисленные ключевые выражения присутствуют в отображении, а значение, соответствующее каждому ключу, совпадает с соответствующим подшаблоном. Если `rest` не равно `None`, то при успешном сопоставлении всего шаблона отображения этому имени привязывается словарь, содержащий оставшиеся элементы отображения.15121513```pycon1514>>> print(ast.dump(ast.parse("""1515... match x:1516...     case {1: _, 2: _}:1517...         ...1518...     case {**rest}:1519...         ...1520... """), indent=4))1521Module(1522    body=[1523        Match(1524            subject=Name(id='x', ctx=Load()),1525            cases=[1526                match_case(1527                    pattern=MatchMapping(1528                        keys=[1529                            Constant(value=1),1530                            Constant(value=2)],1531                        patterns=[1532                            MatchAs(),1533                            MatchAs()]),1534                    body=[1535                        Expr(1536                            value=Constant(value=Ellipsis))]),1537                match_case(1538                    pattern=MatchMapping(rest='rest'),1539                    body=[1540                        Expr(1541                            value=Constant(value=Ellipsis))])])])1542```15431544Добавлено в версии 3.10.15451546#### `class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)`15471548Шаблон класса (class pattern) в match. `cls` – выражение, задающее номинальный класс для сопоставления. `patterns` – последовательность узлов шаблонов, которые будут сопоставляться с определённой классом последовательностью атрибутов для сопоставления с образцом. `kwd_attrs` – последовательность дополнительных атрибутов для сопоставления (указанных как ключевые аргументы в шаблоне класса), `kwd_patterns` – соответствующие шаблоны (указанные как значения ключевых слов в шаблоне класса).15491550Этот шаблон успешно срабатывает, если subject является экземпляром указанного класса, все позиционные шаблоны совпадают с соответствующими атрибутами, определёнными классом, и все указанные ключевые атрибуты совпадают со своими шаблонами.15511552Примечание: классы могут определять свойство, возвращающее self, чтобы сопоставлять узел шаблона с сопоставляемым экземпляром. Некоторые встроенные типы также сопоставляются таким образом, как описано в документации оператора match.15531554```pycon1555>>> print(ast.dump(ast.parse("""1556... match x:1557...     case Point2D(0, 0):1558...         ...1559...     case Point3D(x=0, y=0, z=0):1560...         ...1561... """), indent=4))1562Module(1563    body=[1564        Match(1565            subject=Name(id='x', ctx=Load()),1566            cases=[1567                match_case(1568                    pattern=MatchClass(1569                        cls=Name(id='Point2D', ctx=Load()),1570                        patterns=[1571                            MatchValue(1572                                value=Constant(value=0)),1573                            MatchValue(1574                                value=Constant(value=0))]),1575                    body=[1576                        Expr(1577                            value=Constant(value=Ellipsis))]),1578                match_case(1579                    pattern=MatchClass(1580                        cls=Name(id='Point3D', ctx=Load()),1581                        kwd_attrs=[1582                            'x',1583                            'y',1584                            'z'],1585                        kwd_patterns=[1586                            MatchValue(1587                                value=Constant(value=0)),1588                            MatchValue(1589                                value=Constant(value=0)),1590                            MatchValue(1591                                value=Constant(value=0))]),1592                    body=[1593                        Expr(1594                            value=Constant(value=Ellipsis))])])])1595```15961597Добавлено в версии 3.10.15981599#### `class ast.MatchAs(pattern, name)`16001601Сопоставление «as-pattern», шаблон захвата (capture pattern) или шаблон-заменитель (wildcard pattern). `pattern` содержит шаблон match, с которым будет сопоставлен subject. Если шаблон равен `None`, узел представляет собой шаблон захвата (т.е. просто имя) и всегда успешно срабатывает.16021603Атрибут `name` содержит имя, которое будет привязано при успешном сопоставлении шаблона. Если `name` равно `None`, то `pattern` также должно быть `None`, и узел представляет собой шаблон-заменитель (wildcard).16041605```pycon1606>>> print(ast.dump(ast.parse("""1607... match x:1608...     case [x] as y:1609...         ...1610...     case _:1611...         ...1612... """), indent=4))1613Module(1614    body=[1615        Match(1616            subject=Name(id='x', ctx=Load()),1617            cases=[1618                match_case(1619                    pattern=MatchAs(1620                        pattern=MatchSequence(1621                            patterns=[1622                                MatchAs(name='x')]),1623                        name='y'),1624                    body=[1625                        Expr(1626                            value=Constant(value=Ellipsis))]),1627                match_case(1628                    pattern=MatchAs(),1629                    body=[1630                        Expr(1631                            value=Constant(value=Ellipsis))])])])1632```16331634Добавлено в версии 3.10.16351636#### `class ast.MatchOr(patterns)`16371638Сопоставление «or-pattern» (шаблон ИЛИ). Or-pattern последовательно сопоставляет каждый из своих подшаблонов с subject, пока один из них не сработает. Тогда считается, что or-pattern сработал. Если ни один из подшаблонов не сработал, or-pattern не срабатывает. Атрибут `patterns` содержит список узлов шаблонов match, которые будут сопоставляться с subject.16391640```pycon1641>>> print(ast.dump(ast.parse("""1642... match x:1643...     case [x] | (y):1644...         ...1645... """), indent=4))1646Module(1647    body=[1648        Match(1649            subject=Name(id='x', ctx=Load()),1650            cases=[1651                match_case(1652                    pattern=MatchOr(1653                        patterns=[1654                            MatchSequence(1655                                patterns=[1656                                    MatchAs(name='x')]),1657                            MatchAs(name='y')]),1658                    body=[1659                        Expr(1660                            value=Constant(value=Ellipsis))])])])1661```16621663Добавлено в версии 3.10.16641665### Аннотации типов16661667#### `class ast.TypeIgnore(lineno, tag)`16681669Комментарий `# type: ignore`, расположенный на строке *lineno*. *tag* – опциональный тег, задаваемый формой `# type: ignore <tag>`.16701671```pycon1672>>> print(ast.dump(ast.parse('x = 1 # type: ignore', type_comments=True), indent=4))1673Module(1674    body=[1675        Assign(1676            targets=[1677                Name(id='x', ctx=Store())],1678            value=Constant(value=1))],1679    type_ignores=[1680        TypeIgnore(lineno=1, tag='')])1681>>> print(ast.dump(ast.parse('x: bool = 1 # type: ignore[assignment]', type_comments=True), indent=4))1682Module(1683    body=[1684        AnnAssign(1685            target=Name(id='x', ctx=Store()),1686            annotation=Name(id='bool', ctx=Load()),1687            value=Constant(value=1),1688            simple=1)],1689    type_ignores=[1690        TypeIgnore(lineno=1, tag='[assignment]')])1691```16921693> **Примечание**1694>1695> Узлы `TypeIgnore` не создаются, когда параметр *type\_comments* установлен в `False` (по умолчанию). Подробнее см. [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse).16961697Добавлено в версии 3.8.16981699### Параметры типа17001701[Параметры типа](https://python-all.ru/3.13/reference/compound_stmts.html#type-params) могут существовать у классов, функций и псевдонимов типов.17021703#### `class ast.TypeVar(name, bound, default_value)`17041705[`typing.TypeVar`](https://python-all.ru/3.13/library/typing.html#typing.TypeVar). `name` – это имя переменной типа. `bound` – это граница или ограничения, если они есть. Если `bound` представляет собой [`Tuple`](https://python-all.ru/3.13/library/ast.html#ast.Tuple), то это ограничения; иначе – граница. `default_value` – значение по умолчанию; если `TypeVar` не имеет значения по умолчанию, то этот атрибут равен `None`.17061707```pycon1708>>> print(ast.dump(ast.parse("type Alias[T: int = bool] = list[T]"), indent=4))1709Module(1710    body=[1711        TypeAlias(1712            name=Name(id='Alias', ctx=Store()),1713            type_params=[1714                TypeVar(1715                    name='T',1716                    bound=Name(id='int', ctx=Load()),1717                    default_value=Name(id='bool', ctx=Load()))],1718            value=Subscript(1719                value=Name(id='list', ctx=Load()),1720                slice=Name(id='T', ctx=Load()),1721                ctx=Load()))])1722```17231724Добавлено в версии 3.12.17251726Изменено в версии 3.13: Добавлен параметр *default\_value*.17271728#### `class ast.ParamSpec(name, default_value)`17291730[`typing.ParamSpec`](https://python-all.ru/3.13/library/typing.html#typing.ParamSpec). `name` – это имя спецификации параметра. `default_value` – значение по умолчанию; если `ParamSpec` не имеет значения по умолчанию, то этот атрибут устанавливается в `None`.17311732```pycon1733>>> print(ast.dump(ast.parse("type Alias[**P = [int, str]] = Callable[P, int]"), indent=4))1734Module(1735    body=[1736        TypeAlias(1737            name=Name(id='Alias', ctx=Store()),1738            type_params=[1739                ParamSpec(1740                    name='P',1741                    default_value=List(1742                        elts=[1743                            Name(id='int', ctx=Load()),1744                            Name(id='str', ctx=Load())],1745                        ctx=Load()))],1746            value=Subscript(1747                value=Name(id='Callable', ctx=Load()),1748                slice=Tuple(1749                    elts=[1750                        Name(id='P', ctx=Load()),1751                        Name(id='int', ctx=Load())],1752                    ctx=Load()),1753                ctx=Load()))])1754```17551756Добавлено в версии 3.12.17571758Изменено в версии 3.13: Добавлен параметр *default\_value*.17591760#### `class ast.TypeVarTuple(name, default_value)`17611762[`typing.TypeVarTuple`](https://python-all.ru/3.13/library/typing.html#typing.TypeVarTuple). `name` – это имя кортежа переменных типа. `default_value` – значение по умолчанию; если `TypeVarTuple` не имеет значения по умолчанию, то этот атрибут устанавливается в `None`.17631764```pycon1765>>> print(ast.dump(ast.parse("type Alias[*Ts = ()] = tuple[*Ts]"), indent=4))1766Module(1767    body=[1768        TypeAlias(1769            name=Name(id='Alias', ctx=Store()),1770            type_params=[1771                TypeVarTuple(1772                    name='Ts',1773                    default_value=Tuple(ctx=Load()))],1774            value=Subscript(1775                value=Name(id='tuple', ctx=Load()),1776                slice=Tuple(1777                    elts=[1778                        Starred(1779                            value=Name(id='Ts', ctx=Load()),1780                            ctx=Load())],1781                    ctx=Load()),1782                ctx=Load()))])1783```17841785Добавлено в версии 3.12.17861787Изменено в версии 3.13: Добавлен параметр *default\_value*.17881789### Определения функций и классов17901791#### `class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`17921793Определение функции.17941795- `name` – это необработанная строка имени функции.1796- `args` – это узел [`arguments`](https://python-all.ru/3.13/library/ast.html#ast.arguments).1797- `body` – это список узлов внутри функции.1798- `decorator_list` – это список декораторов, которые будут применены; декораторы перечислены от самого внешнего к внутреннему (т.е. первый в списке применяется последним).1799- `returns` – это аннотация возвращаемого значения.1800- `type_params` – это список [параметров типа](https://python-all.ru/3.13/library/ast.html#ast-type-params).18011802#### `type_comment`18031804`type_comment` – это необязательная строка с аннотацией типа в виде комментария.18051806Изменено в версии 3.12: Добавлен `type_params`.18071808#### `class ast.Lambda(args, body)`18091810`lambda` – это минимальное определение функции, которое можно использовать внутри выражения. В отличие от [`FunctionDef`](https://python-all.ru/3.13/library/ast.html#ast.FunctionDef), `body` содержит один узел.18111812```pycon1813>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))1814Module(1815    body=[1816        Expr(1817            value=Lambda(1818                args=arguments(1819                    args=[1820                        arg(arg='x'),1821                        arg(arg='y')]),1822                body=Constant(value=Ellipsis)))])1823```18241825#### `class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)`18261827Аргументы функции.18281829- `posonlyargs`, `args` и `kwonlyargs` – это списки узлов [`arg`](https://python-all.ru/3.13/library/ast.html#ast.arg).1830- `vararg` и `kwarg` – это одиночные узлы [`arg`](https://python-all.ru/3.13/library/ast.html#ast.arg), ссылающиеся на параметры `*args, **kwargs`.1831- `kw_defaults` – это список значений по умолчанию для keyword-only аргументов. Если один из них равен `None`, соответствующий аргумент обязателен.1832- `defaults` – это список значений по умолчанию для аргументов, которые можно передавать позиционно. Если значений по умолчанию меньше, они соответствуют последним n аргументам.18331834#### `class ast.arg(arg, annotation, type_comment)`18351836Один аргумент в списке. `arg` – это сырая строка с именем аргумента; `annotation` – это его аннотация, например, узел [`Name`](https://python-all.ru/3.13/library/ast.html#ast.Name).18371838#### `type_comment`18391840`type_comment` – это необязательная строка с аннотацией типа в виде комментария18411842```pycon1843>>> print(ast.dump(ast.parse("""\1844... @decorator11845... @decorator21846... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':1847...     pass1848... """), indent=4))1849Module(1850    body=[1851        FunctionDef(1852            name='f',1853            args=arguments(1854                args=[1855                    arg(1856                        arg='a',1857                        annotation=Constant(value='annotation')),1858                    arg(arg='b'),1859                    arg(arg='c')],1860                vararg=arg(arg='d'),1861                kwonlyargs=[1862                    arg(arg='e'),1863                    arg(arg='f')],1864                kw_defaults=[1865                    None,1866                    Constant(value=3)],1867                kwarg=arg(arg='g'),1868                defaults=[1869                    Constant(value=1),1870                    Constant(value=2)]),1871            body=[1872                Pass()],1873            decorator_list=[1874                Name(id='decorator1', ctx=Load()),1875                Name(id='decorator2', ctx=Load())],1876            returns=Constant(value='return annotation'))])1877```18781879#### `class ast.Return(value)`18801881Инструкция `return`.18821883```pycon1884>>> print(ast.dump(ast.parse('return 4'), indent=4))1885Module(1886    body=[1887        Return(1888            value=Constant(value=4))])1889```18901891#### `class ast.Yield(value)`18921893#### `class ast.YieldFrom(value)`18941895Выражение `yield` или `yield from`. Поскольку это выражения, они должны быть обёрнуты в узел [`Expr`](https://python-all.ru/3.13/library/ast.html#ast.Expr), если возвращаемое значение не используется.18961897```pycon1898>>> print(ast.dump(ast.parse('yield x'), indent=4))1899Module(1900    body=[1901        Expr(1902            value=Yield(1903                value=Name(id='x', ctx=Load())))])19041905>>> print(ast.dump(ast.parse('yield from x'), indent=4))1906Module(1907    body=[1908        Expr(1909            value=YieldFrom(1910                value=Name(id='x', ctx=Load())))])1911```19121913#### `class ast.Global(names)`19141915#### `class ast.Nonlocal(names)`19161917Инструкции `global` и `nonlocal`. `names` – это список сырых строк.19181919```pycon1920>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))1921Module(1922    body=[1923        Global(1924            names=[1925                'x',1926                'y',1927                'z'])])19281929>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))1930Module(1931    body=[1932        Nonlocal(1933            names=[1934                'x',1935                'y',1936                'z'])])1937```19381939#### `class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)`19401941Определение класса.19421943- `name` – это сырая строка с именем класса.1944- `bases` – это список узлов для явно указанных базовых классов.1945- `keywords` – это список узлов [`keyword`](https://python-all.ru/3.13/library/ast.html#ast.keyword), в первую очередь для ‘metaclass’. Остальные ключевые слова будут переданы метаклассу, в соответствии с [**PEP 3115**](https://python-all.ru/3.13/library/ast.html).1946- `body` – это список узлов, представляющих код внутри определения класса.1947- `decorator_list` – это список узлов, как и в [`FunctionDef`](https://python-all.ru/3.13/library/ast.html#ast.FunctionDef).1948- `type_params` – это список [параметров типа](https://python-all.ru/3.13/library/ast.html#ast-type-params).19491950```pycon1951>>> print(ast.dump(ast.parse("""\1952... @decorator11953... @decorator21954... class Foo(base1, base2, metaclass=meta):1955...     pass1956... """), indent=4))1957Module(1958    body=[1959        ClassDef(1960            name='Foo',1961            bases=[1962                Name(id='base1', ctx=Load()),1963                Name(id='base2', ctx=Load())],1964            keywords=[1965                keyword(1966                    arg='metaclass',1967                    value=Name(id='meta', ctx=Load()))],1968            body=[1969                Pass()],1970            decorator_list=[1971                Name(id='decorator1', ctx=Load()),1972                Name(id='decorator2', ctx=Load())])])1973```19741975Изменено в версии 3.12: Добавлен `type_params`.19761977### async и await19781979#### `class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`19801981Определение функции `async def`. Имеет те же поля, что и [`FunctionDef`](https://python-all.ru/3.13/library/ast.html#ast.FunctionDef).19821983Изменено в версии 3.12: Добавлен `type_params`.19841985#### `class ast.Await(value)`19861987Выражение `await`. `value` – это то, чего оно ожидает. Допустимо только в теле [`AsyncFunctionDef`](https://python-all.ru/3.13/library/ast.html#ast.AsyncFunctionDef).19881989```pycon1990>>> print(ast.dump(ast.parse("""\1991... async def f():1992...     await other_func()1993... """), indent=4))1994Module(1995    body=[1996        AsyncFunctionDef(1997            name='f',1998            args=arguments(),1999            body=[2000                Expr(2001                    value=Await(2002                        value=Call(2003                            func=Name(id='other_func', ctx=Load()))))])])2004```20052006#### `class ast.AsyncFor(target, iter, body, orelse, type_comment)`20072008#### `class ast.AsyncWith(items, body, type_comment)`20092010`async for` циклы и `async with` менеджеры контекста. Они имеют те же поля, что [`For`](https://python-all.ru/3.13/library/ast.html#ast.For) и [`With`](https://python-all.ru/3.13/library/ast.html#ast.With), соответственно. Допустимы только в теле [`AsyncFunctionDef`](https://python-all.ru/3.13/library/ast.html#ast.AsyncFunctionDef).20112012> **Примечание**2013>2014> Когда строка разбирается парсером [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse), узлы операторов (подклассы `ast.operator`, `ast.unaryop`, `ast.cmpop`, `ast.boolop` и `ast.expr_context`) на возвращаемом дереве являются синглтонами. Изменения в одном будут отражены во всех других вхождениях того же значения (например, [`ast.Add`](https://python-all.ru/3.13/library/ast.html#ast.Add)).20152016## `ast` Вспомогательные функции20172018Помимо классов узлов, модуль `ast` определяет следующие служебные функции и классы для обхода абстрактных синтаксических деревьев:20192020#### `ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None, optimize=-1)`20212022Разбирает исходный код в узел AST. Эквивалентно `compile(source, filename, mode, flags=FLAGS_VALUE, optimize=optimize)`, где `FLAGS_VALUE` равно `ast.PyCF_ONLY_AST`, если `optimize <= 0`, и `ast.PyCF_OPTIMIZED_AST` в противном случае.20232024Если задан `type_comments=True`, парсер изменяется, чтобы проверять и возвращать комментарии типов, как указано в [**PEP 484**](https://python-all.ru/3.13/library/ast.html) и [**PEP 526**](https://python-all.ru/3.13/library/ast.html). Это эквивалентно добавлению [`ast.PyCF_TYPE_COMMENTS`](https://python-all.ru/3.13/library/ast.html#ast.PyCF_TYPE_COMMENTS) к флагам, передаваемым в [`compile()`](https://python-all.ru/3.13/library/functions.html#compile). Это приведёт к сообщению об ошибках синтаксиса для неправильно расположенных комментариев типов. Без этого флага комментарии типов будут игнорироваться, и поле `type_comment` в выбранных узлах AST всегда будет `None`. Кроме того, расположение комментариев `# type: ignore` будет возвращаться как атрибут `type_ignores` объекта [`Module`](https://python-all.ru/3.13/library/ast.html#ast.Module) (иначе это всегда пустой список).20252026Кроме того, если `mode` равно `'func_type'`, синтаксис входных данных изменяется в соответствии с [**PEP 484**](https://python-all.ru/3.13/library/ast.html) «сигнатурными комментариями типов», например `(str, int) -> List[str]`.20272028Установка `feature_version` в кортеж `(major, minor)` приведёт к «наилучшей попытке» разбора с использованием грамматики этой версии Python. Например, установка `feature_version=(3, 9)` будет пытаться запретить разбор инструкций [`match`](https://python-all.ru/3.13/reference/compound_stmts.html#match). В настоящее время `major` должно быть равно `3`. Самая низкая поддерживаемая версия – `(3, 7)` (и это может увеличиться в будущих версиях Python); самая высокая – `sys.version_info[0:2]`. «Наилучшая попытка» означает, что нет гарантии, что разбор (или успех разбора) будет таким же, как при запуске на версии Python, соответствующей `feature_version`.20292030Если исходный код содержит нулевой символ (`\0`), возбуждается [`ValueError`](https://python-all.ru/3.13/library/exceptions.html#ValueError).20312032> **Предупреждение**2033>2034> Обратите внимание, что успешный разбор исходного кода в объект AST не гарантирует, что предоставленный исходный код является корректным кодом Python, который можно выполнить, поскольку этап компиляции может вызывать дополнительные исключения [`SyntaxError`](https://python-all.ru/3.13/library/exceptions.html#SyntaxError). Например, исходный код `return 42` генерирует корректный узел AST для инструкции return, но его нельзя скомпилировать отдельно (он должен находиться внутри узла функции).2035>2036> В частности, `ast.parse()` не выполняет никаких проверок областей видимости, которые выполняет этап компиляции.20372038> **Предупреждение**2039>2040> Можно вызвать сбой интерпретатора Python с помощью достаточно большой/сложной строки из-за ограничений глубины стека в компиляторе AST Python.20412042Изменено в версии 3.8: Добавлены `type_comments`, `mode='func_type'` и `feature_version`.20432044Изменено в версии 3.13: Минимальная поддерживаемая версия для `feature_version` теперь `(3, 7)`. Был добавлен аргумент `optimize`.20452046#### `ast.unparse(ast_obj)`20472048Выполняет обратный разбор объекта [`ast.AST`](https://python-all.ru/3.13/library/ast.html#ast.AST) и генерирует строку с кодом, который при обратном разборе с помощью [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse) даст эквивалентный объект `ast.AST`.20492050> **Предупреждение**2051>2052> Полученная строка кода не обязательно будет равна исходному коду, который породил объект [`ast.AST`](https://python-all.ru/3.13/library/ast.html#ast.AST) (без каких-либо оптимизаций компилятора, таких как константные кортежи/frozensets).20532054> **Предупреждение**2055>2056> Попытка выполнить обратный разбор очень сложного выражения приведёт к [`RecursionError`](https://python-all.ru/3.13/library/exceptions.html#RecursionError).20572058Добавлено в версии 3.9.20592060#### `ast.literal_eval(node_or_string)`20612062Вычисляет узел выражения или строку, содержащую только литерал Python или отображение контейнера. Предоставленная строка или узел могут состоять только из следующих структур литералов Python: строки, байты, числа, кортежи, списки, словари, множества, булевы значения, `None` и `Ellipsis`.20632064Это можно использовать для вычисления строк, содержащих значения Python, без необходимости разбирать значения самостоятельно. Он не способен вычислять произвольно сложные выражения, например, с операторами или индексацией.20652066Раньше эта функция документировалась как «безопасная» без определения, что это значит. Это вводило в заблуждение. Она специально разработана так, чтобы не выполнять код Python, в отличие от более общей [`eval()`](https://python-all.ru/3.13/library/functions.html#eval). Нет пространства имён, поиска имён или возможности внешних вызовов. Но она не свободна от атак: относительно небольшой ввод может привести к истощению памяти или истощению стека C, что вызовет сбой процесса. Также существует возможность отказа в обслуживании из-за чрезмерного потребления ЦП на некоторых входных данных. Поэтому вызывать её на недоверенных данных не рекомендуется.20672068> **Предупреждение**2069>2070> Можно вызвать сбой интерпретатора Python из-за ограничений глубины стека в компиляторе AST Python.2071>2072> Она может возбуждать [`ValueError`](https://python-all.ru/3.13/library/exceptions.html#ValueError), [`TypeError`](https://python-all.ru/3.13/library/exceptions.html#TypeError), [`SyntaxError`](https://python-all.ru/3.13/library/exceptions.html#SyntaxError), [`MemoryError`](https://python-all.ru/3.13/library/exceptions.html#MemoryError) и [`RecursionError`](https://python-all.ru/3.13/library/exceptions.html#RecursionError) в зависимости от некорректного ввода.20732074Изменено в версии 3.2: Теперь допускает литералы байтов и множеств.20752076Изменено в версии 3.9: Теперь поддерживает создание пустых множеств с помощью `'set()'`.20772078Изменено в версии 3.10: Для строковых входных данных начальные пробелы и табуляции теперь удаляются.20792080#### `ast.get_docstring(node, clean=True)`20812082Возвращает строку документации для данного *узла* (который должен быть узлом [`FunctionDef`](https://python-all.ru/3.13/library/ast.html#ast.FunctionDef), [`AsyncFunctionDef`](https://python-all.ru/3.13/library/ast.html#ast.AsyncFunctionDef), [`ClassDef`](https://python-all.ru/3.13/library/ast.html#ast.ClassDef) или [`Module`](https://python-all.ru/3.13/library/ast.html#ast.Module)) или `None`, если у него нет строки документации. Если *clean* истинно, очищает отступы строки документации с помощью [`inspect.cleandoc()`](https://python-all.ru/3.13/library/inspect.html#inspect.cleandoc).20832084Изменено в версии 3.5: Теперь поддерживается [`AsyncFunctionDef`](https://python-all.ru/3.13/library/ast.html#ast.AsyncFunctionDef).20852086#### `ast.get_source_segment(source, node, *, padded=False)`20872088Возвращает фрагмент исходного кода из *source*, который породил узел *node*. Если не хватает информации о местоположении ([`lineno`](https://python-all.ru/3.13/library/ast.html#ast.AST.lineno), [`end_lineno`](https://python-all.ru/3.13/library/ast.html#ast.AST.end_lineno), [`col_offset`](https://python-all.ru/3.13/library/ast.html#ast.AST.col_offset) или [`end_col_offset`](https://python-all.ru/3.13/library/ast.html#ast.AST.end_col_offset)), возвращает `None`.20892090Если *padded* равно `True`, первая строка многострочного оператора будет дополнена пробелами, чтобы соответствовать исходной позиции.20912092Добавлено в версии 3.8.20932094#### `ast.fix_missing_locations(node)`20952096При компиляции дерева узлов с помощью [`compile()`](https://python-all.ru/3.13/library/functions.html#compile) компилятор ожидает атрибуты [`lineno`](https://python-all.ru/3.13/library/ast.html#ast.AST.lineno) и [`col_offset`](https://python-all.ru/3.13/library/ast.html#ast.AST.col_offset) для каждого узла, который их поддерживает. Заполнять их вручную для сгенерированных узлов довольно утомительно, поэтому эта вспомогательная функция рекурсивно добавляет эти атрибуты, если их ещё нет, устанавливая их равными значениям родительского узла. Работает рекурсивно, начиная с *node*.20972098#### `ast.increment_lineno(node, n=1)`20992100Увеличивает номер строки и номер конечной строки каждого узла в дереве, начиная с *node*, на *n*. Это полезно для «перемещения кода» в другое место в файле.21012102#### `ast.copy_location(new_node, old_node)`21032104Копирует информацию о местоположении в исходном коде ([`lineno`](https://python-all.ru/3.13/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.13/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.13/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.13/library/ast.html#ast.AST.end_col_offset)) из *old\_node* в *new\_node*, если это возможно, и возвращает *new\_node*.21052106#### `ast.iter_fields(node)`21072108Генерирует кортеж из `(fieldname, value)` для каждого поля в `node._fields`, которое присутствует в *node*.21092110#### `ast.iter_child_nodes(node)`21112112Генерирует все непосредственные дочерние узлы *node*, то есть все поля, являющиеся узлами, и все элементы полей, являющихся списками узлов.21132114#### `ast.walk(node)`21152116Рекурсивно генерирует все узлы-потомки в дереве, начиная с *node* (включая сам *node*), в произвольном порядке. Это полезно, если требуется только изменить узлы на месте, а контекст не важен.21172118#### `class ast.NodeVisitor`21192120Базовый класс для обхода узлов, который обходит абстрактное синтаксическое дерево и вызывает функцию-посетитель для каждого найденного узла. Эта функция может вернуть значение, которое передаётся методом [`visit()`](https://python-all.ru/3.13/library/ast.html#ast.NodeVisitor.visit).21212122Этот класс предназначен для наследования; в подклассе добавляются методы-посетители.21232124#### `visit(node)`21252126Посещает узел. Реализация по умолчанию вызывает метод `self.visit_classname`, где *classname* – имя класса узла, или [`generic_visit()`](https://python-all.ru/3.13/library/ast.html#ast.NodeVisitor.generic_visit), если такой метод отсутствует.21272128#### `generic_visit(node)`21292130Этот посетитель вызывает [`visit()`](https://python-all.ru/3.13/library/ast.html#ast.NodeVisitor.visit) для всех дочерних узлов.21312132Обратите внимание, что дочерние узлы тех узлов, для которых определён собственный метод-посетитель, не будут посещены, если посетитель сам не вызовет `generic_visit()` или не обойдёт их самостоятельно.21332134#### `visit_Constant(node)`21352136Обрабатывает все константные узлы.21372138Не используйте `NodeVisitor`, если требуется вносить изменения в узлы во время обхода. Для этого существует специальный посетитель ([`NodeTransformer`](https://python-all.ru/3.13/library/ast.html#ast.NodeTransformer)), который допускает модификации.21392140Устарело с версии 3.8: Методы `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` и `visit_Ellipsis()` теперь устарели и не будут вызываться в будущих версиях Python. Добавьте метод [`visit_Constant()`](https://python-all.ru/3.13/library/ast.html#ast.NodeVisitor.visit_Constant) для обработки всех узлов-констант.21412142#### `class ast.NodeTransformer`21432144Подкласс [`NodeVisitor`](https://python-all.ru/3.13/library/ast.html#ast.NodeVisitor), который обходит абстрактное синтаксическое дерево и позволяет изменять узлы.21452146Метод `NodeTransformer` обходит AST и использует возвращаемое значение методов-посетителей для замены или удаления старого узла. Если возвращаемое значение метода-посетителя равно `None`, узел будет удалён из своего местоположения; в противном случае он заменяется возвращённым значением. Возвращённое значение может быть исходным узлом – в этом случае замена не происходит.21472148Вот пример преобразователя, который переписывает все обращения к именам (`foo`) в `data['foo']`:21492150```python2151class RewriteName(NodeTransformer):21522153    def visit_Name(self, node):2154        return Subscript(2155            value=Name(id='data', ctx=Load()),2156            slice=Constant(value=node.id),2157            ctx=node.ctx2158        )2159```21602161Имейте в виду: если у узла, с которым вы работаете, есть дочерние узлы, необходимо либо преобразовать дочерние узлы самостоятельно, либо сначала вызвать для узла метод [`generic_visit()`](https://python-all.ru/3.13/library/ast.html#ast.NodeVisitor.generic_visit).21622163Для узлов, входящих в состав набора инструкций (это относится ко всем узлам инструкций), посетитель может также возвращать список узлов, а не один узел.21642165Если `NodeTransformer` вводит новые узлы (не входившие в исходное дерево) без указания информации о расположении (например, [`lineno`](https://python-all.ru/3.13/library/ast.html#ast.AST.lineno)), следует вызвать [`fix_missing_locations()`](https://python-all.ru/3.13/library/ast.html#ast.fix_missing_locations) для нового поддерева, чтобы пересчитать информацию о расположении:21662167```python2168tree = ast.parse('foo', mode='eval')2169new_tree = fix_missing_locations(RewriteName().visit(tree))2170```21712172Обычно преобразователь используется следующим образом:21732174```python2175node = YourTransformer().visit(node)2176```21772178#### `ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None, show_empty=False)`21792180Возвращает форматированный дамп дерева из *node*. Это в основном полезно для отладки. Если *annotate\_fields* равно true (по умолчанию), возвращаемая строка будет показывать имена и значения полей. Если *annotate\_fields* равно false, результирующая строка будет более компактной за счёт опускания однозначных имён полей. Атрибуты, такие как номера строк и смещения столбцов, по умолчанию не выводятся. Если это нужно, *include\_attributes* можно установить в true.21812182Если *indent* – неотрицательное целое число или строка, дерево будет выведено с отступами указанного уровня. Уровень отступа 0, отрицательное значение или `""` вставляет только переводы строк. `None` (по умолчанию) выбирает однострочное представление. Положительный целочисленный отступ добавляет соответствующее количество пробелов на уровень. Если *indent* – строка (например, `"\t"`), эта строка используется для отступа каждого уровня.21832184Если *show\_empty* равно false (по умолчанию), необязательные пустые списки будут опущены в выводе. Необязательные значения `None` всегда опускаются.21852186Изменено в версии 3.9: Добавлена опция *indent*.21872188Изменено в версии 3.13: Добавлена опция *show\_empty*.21892190```pycon2191>>> print(ast.dump(ast.parse("""\2192... async def f():2193...     await other_func()2194... """), indent=4, show_empty=True))2195Module(2196    body=[2197        AsyncFunctionDef(2198            name='f',2199            args=arguments(2200                posonlyargs=[],2201                args=[],2202                kwonlyargs=[],2203                kw_defaults=[],2204                defaults=[]),2205            body=[2206                Expr(2207                    value=Await(2208                        value=Call(2209                            func=Name(id='other_func', ctx=Load()),2210                            args=[],2211                            keywords=[])))],2212            decorator_list=[],2213            type_params=[])],2214    type_ignores=[])2215```22162217## Флаги компилятора22182219Следующие флаги могут быть переданы в [`compile()`](https://python-all.ru/3.13/library/functions.html#compile) для изменения эффектов компиляции программы:22202221#### `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`22222223Включает поддержку `await`, `async for`, `async with` и асинхронных включений верхнего уровня.22242225Добавлено в версии 3.8.22262227#### `ast.PyCF_ONLY_AST`22282229Генерирует и возвращает абстрактное синтаксическое дерево вместо скомпилированного объекта кода.22302231#### `ast.PyCF_OPTIMIZED_AST`22322233Возвращаемое AST оптимизируется в соответствии с аргументом *optimize* в [`compile()`](https://python-all.ru/3.13/library/functions.html#compile) или [`ast.parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse).22342235Добавлено в версии 3.13.22362237#### `ast.PyCF_TYPE_COMMENTS`22382239Включает поддержку комментариев типов в стиле [**PEP 484**](https://python-all.ru/3.13/library/ast.html) и [**PEP 526**](https://python-all.ru/3.13/library/ast.html) (`# type: <type>`, `# type: ignore <stuff>`).22402241Добавлено в версии 3.8.22422243## Использование командной строки22442245Добавлено в версии 3.9.22462247Модуль `ast` может быть выполнен как скрипт из командной строки. Это просто:22482249```sh2250python -m ast [-m <mode>] [-a] [infile]2251```22522253Принимаются следующие опции:22542255#### `-h, --help`22562257Показать справку и выйти.22582259#### `-m <mode>`22602261#### `--mode <mode>`22622263Определяет, какой вид кода должен быть скомпилирован, как аргумент *mode* в [`parse()`](https://python-all.ru/3.13/library/ast.html#ast.parse).22642265#### `--no-type-comments`22662267Не обрабатывать комментарии типов.22682269#### `-a, --include-attributes`22702271Включать атрибуты, такие как номера строк и смещения столбцов.22722273#### `-i <indent>`22742275#### `--indent <indent>`22762277Отступ узлов в AST (количество пробелов).22782279Если указан `infile`, его содержимое разбирается в AST и выводится в stdout. В противном случае содержимое читается из stdin.22802281> **См. также**2282>2283> [Green Tree Snakes](https://python-all.ru/3.13/library/ast.html) – внешний документационный ресурс, содержащий подробности работы с AST Python.2284>2285> [ASTTokens](https://python-all.ru/3.13/library/ast.html) дополняет AST Python позициями токенов и текста в исходном коде, который их породил. Это полезно для инструментов, выполняющих преобразования исходного кода.2286>2287> [leoAst.py](https://python-all.ru/3.13/library/ast.html) объединяет токен-ориентированное и синтаксическое представление программ Python, вставляя двунаправленные связи между токенами и узлами AST.2288>2289> [LibCST](https://python-all.ru/3.13/library/ast.html) разбирает код как конкретное синтаксическое дерево, похожее на AST, и сохраняет все детали форматирования. Это полезно для создания приложений автоматического рефакторинга (codemod) и линтеров.2290>2291> [Parso](https://python-all.ru/3.13/library/ast.html) – это парсер Python, поддерживающий восстановление после ошибок и сквозной разбор для разных версий Python (в нескольких версиях Python). Parso также может выводить несколько синтаксических ошибок в вашем файле Python.2292