ast.md

1> **Источник:** https://python-all.ru/3.12/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.12/Lib/ast.py)1011---1213Модуль [`ast`](https://python-all.ru/3.12/library/ast.html#module-ast) помогает приложениям Python обрабатывать деревья абстрактного синтаксиса языка Python. Абстрактный синтаксис может меняться от версии к версии; с помощью этого модуля можно программно узнать, как выглядит текущая грамматика.1415Абстрактное синтаксическое дерево можно создать, передав [`ast.PyCF_ONLY_AST`](https://python-all.ru/3.12/library/ast.html#ast.PyCF_ONLY_AST) в качестве флага встроенной функции [`compile()`](https://python-all.ru/3.12/library/functions.html#compile) или используя вспомогательную функцию [`parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse) из этого модуля. Результатом будет дерево объектов, классы которых наследуют от [`ast.AST`](https://python-all.ru/3.12/library/ast.html#ast.AST). Абстрактное синтаксическое дерево можно скомпилировать в объект кода Python с помощью встроенной функции [`compile()`](https://python-all.ru/3.12/library/functions.html#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)170               | ParamSpec(identifier name)171               | TypeVarTuple(identifier name)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.12/library/ast.html#abstract-grammar). Они определены в C-модуле `_ast` и повторно экспортируются в [`ast`](https://python-all.ru/3.12/library/ast.html#module-ast).181182Для каждого символа левой части абстрактной грамматики определён один класс (например, `ast.stmt` или `ast.expr`). Кроме того, для каждого конструктора правой части определён один класс; эти классы наследуют от классов для деревьев левой части. Например, [`ast.BinOp`](https://python-all.ru/3.12/library/ast.html#ast.BinOp) наследует от `ast.expr`. Для продукционных правил с альтернативами (так называемых «сумм») класс левой части является абстрактным: создаются только экземпляры конкретных узлов-конструкторов.183184#### `_fields`185186Каждый конкретный класс имеет атрибут [`_fields`](https://python-all.ru/3.12/library/ast.html#ast.AST._fields), который содержит имена всех дочерних узлов.187188Каждый экземпляр конкретного класса имеет по одному атрибуту для каждого дочернего узла, тип которого определён в грамматике. Например, экземпляры [`ast.BinOp`](https://python-all.ru/3.12/library/ast.html#ast.BinOp) имеют атрибут `left` типа `ast.expr`.189190Если эти атрибуты помечены как необязательные в грамматике (с помощью вопросительного знака), значением может быть `None`. Если атрибуты могут иметь ноль или более значений (помечены звёздочкой), значения представляются в виде списков Python. Все возможные атрибуты должны присутствовать и иметь корректные значения при компиляции AST с помощью [`compile()`](https://python-all.ru/3.12/library/functions.html#compile).191192#### `lineno`193194#### `col_offset`195196#### `end_lineno`197198#### `end_col_offset`199200Экземпляры подклассов `ast.expr` и `ast.stmt` имеют атрибуты [`lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.end_col_offset). Атрибуты [`lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.lineno) и [`end_lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.end_lineno) – это номер первой и последней строки исходного текста (нумерация с 1, то есть первая строка – строка 1), а [`col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.col_offset) и [`end_col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.end_col_offset) – соответствующие смещения в байтах UTF-8 от первого и последнего токенов, породивших узел. Смещение UTF-8 записывается, потому что парсер использует UTF-8 внутри.201202Обратите внимание, что конечные позиции не требуются компилятором и поэтому являются необязательными. Смещение конца находится *после* последнего символа, например, можно получить фрагмент исходного кода узла выражения из одной строки с помощью `source_line[node.col_offset : node.end_col_offset]`.203204Конструктор класса `ast.T` разбирает свои аргументы следующим образом:205206- Если есть позиционные аргументы, их должно быть столько же, сколько элементов в `T._fields`; они будут присвоены как атрибуты с этими именами.207- Если есть ключевые аргументы, они установят атрибуты с теми же именами в указанные значения.208209Например, чтобы создать и заполнить узел [`ast.UnaryOp`](https://python-all.ru/3.12/library/ast.html#ast.UnaryOp), можно использовать210211```python212node = ast.UnaryOp()213node.op = ast.USub()214node.operand = ast.Constant()215node.operand.value = 5216node.operand.lineno = 0217node.operand.col_offset = 0218node.lineno = 0219node.col_offset = 0220```221222или более компактный223224```python225node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),226                   lineno=0, col_offset=0)227```228229Изменено в версии 3.8: Класс [`ast.Constant`](https://python-all.ru/3.12/library/ast.html#ast.Constant) теперь используется для всех констант.230231Изменено в версии 3.9: Простые индексы представляются своим значением, расширенные срезы представляются кортежами.232233Устарело с версии 3.8: Старые классы `ast.Num`, `ast.Str`, `ast.Bytes`, `ast.NameConstant` и `ast.Ellipsis` всё ещё доступны, но будут удалены в будущих версиях Python. А пока их создание будет возвращать экземпляр другого класса.234235Устарело с версии 3.9: Старые классы `ast.Index` и `ast.ExtSlice` всё ещё доступны, но будут удалены в будущих выпусках Python. При этом при их создании будет возвращён экземпляр другого класса.236237> **Примечание**238>239> Описания конкретных классов узлов, приведённые здесь, изначально были адаптированы из замечательного проекта [Green Tree Snakes](https://python-all.ru/3.12/library/ast.html) и всех его участников.240241### Корневые узлы242243#### `class ast.Module(body, type_ignores)`244245A Python module, as with [file input](https://python-all.ru/3.12/reference/toplevel_components.html#file-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse) in the default `"exec"` *mode*.246247`body` is a [`list`](https://python-all.ru/3.12/library/stdtypes.html#list) of the module’s [Statements](https://python-all.ru/3.12/library/ast.html#ast-statements).248249`type_ignores` – это список [`list`](https://python-all.ru/3.12/library/stdtypes.html#list) комментариев об игнорировании типов в модуле; подробнее см. в [`ast.parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse).250251```pycon252>>> print(ast.dump(ast.parse('x = 1'), indent=4))253Module(254    body=[255        Assign(256            targets=[257                Name(id='x', ctx=Store())],258            value=Constant(value=1))],259    type_ignores=[])260```261262#### `class ast.Expression(body)`263264A single Python [expression input](https://python-all.ru/3.12/reference/toplevel_components.html#expression-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse) when *mode* is `"eval"`.265266`body` is a single node, one of the [expression types](https://python-all.ru/3.12/library/ast.html#ast-expressions).267268```pycon269>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))270Expression(271    body=Constant(value=123))272```273274#### `class ast.Interactive(body)`275276A single [interactive input](https://python-all.ru/3.12/reference/toplevel_components.html#interactive), like in [Interactive Mode](https://python-all.ru/3.12/tutorial/appendix.html#tut-interac). Node type generated by [`ast.parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse) when *mode* is `"single"`.277278`body` is a [`list`](https://python-all.ru/3.12/library/stdtypes.html#list) of [statement nodes](https://python-all.ru/3.12/library/ast.html#ast-statements).279280```pycon281>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))282Interactive(283    body=[284        Assign(285            targets=[286                Name(id='x', ctx=Store())],287            value=Constant(value=1)),288        Assign(289            targets=[290                Name(id='y', ctx=Store())],291            value=Constant(value=2))])292```293294#### `class ast.FunctionType(argtypes, returns)`295296A 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.12/library/ast.html) annotations. Node type generated by [`ast.parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse) when *mode* is `"func_type"`.297298Такие комментарии о типах выглядели следующим образом:299300```python301def sum_two_number(a, b):302    # type: (int, int) -> int303    return a + b304```305306`argtypes` is a [`list`](https://python-all.ru/3.12/library/stdtypes.html#list) of [expression nodes](https://python-all.ru/3.12/library/ast.html#ast-expressions).307308`returns` is a single [expression node](https://python-all.ru/3.12/library/ast.html#ast-expressions).309310```pycon311>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))312FunctionType(313    argtypes=[314        Name(id='int', ctx=Load()),315        Name(id='str', ctx=Load())],316    returns=Subscript(317        value=Name(id='List', ctx=Load()),318        slice=Name(id='int', ctx=Load()),319        ctx=Load()))320```321322Добавлено в версии 3.8.323324### Литералы325326#### `class ast.Constant(value)`327328Постоянное значение. Атрибут `value` литерала `Constant` содержит объект Python, который он представляет. Представленные значения могут быть простыми типами, такими как число, строка или `None`, а также неизменяемыми контейнерными типами (кортежами и замороженными множествами), если все их элементы постоянны.329330```pycon331>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))332Expression(333    body=Constant(value=123))334```335336#### `class ast.FormattedValue(value, conversion, format_spec)`337338Узел, представляющий одно поле форматирования в f-строке. Если строка содержит только одно поле форматирования и больше ничего, узел может быть изолированным; в противном случае он встречается внутри [`JoinedStr`](https://python-all.ru/3.12/library/ast.html#ast.JoinedStr).339340- `value` – это любой узел выражения (например, литерал, переменная или вызов функции).341- `conversion` – целое число:342343  - -1: без форматирования344  - 115: `!s` форматирование строк345  - 114: `!r` форматирование repr346  - 97: `!a` форматирование ascii347- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.12/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно.348349#### `class ast.JoinedStr(values)`350351F-строка, содержащая последовательность [`FormattedValue`](https://python-all.ru/3.12/library/ast.html#ast.FormattedValue) и [`Constant`](https://python-all.ru/3.12/library/ast.html#ast.Constant) узлов.352353```pycon354>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))355Expression(356    body=JoinedStr(357        values=[358            Constant(value='sin('),359            FormattedValue(360                value=Name(id='a', ctx=Load()),361                conversion=-1),362            Constant(value=') is '),363            FormattedValue(364                value=Call(365                    func=Name(id='sin', ctx=Load()),366                    args=[367                        Name(id='a', ctx=Load())],368                    keywords=[]),369                conversion=-1,370                format_spec=JoinedStr(371                    values=[372                        Constant(value='.3')]))]))373```374375#### `class ast.List(elts, ctx)`376377#### `class ast.Tuple(elts, ctx)`378379Список или кортеж. `elts` содержит список узлов, представляющих элементы. `ctx` равен [`Store`](https://python-all.ru/3.12/library/ast.html#ast.Store), если контейнер является целью присваивания (т.е. `(x,y)=something`), и [`Load`](https://python-all.ru/3.12/library/ast.html#ast.Load) в противном случае.380381```pycon382>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))383Expression(384    body=List(385        elts=[386            Constant(value=1),387            Constant(value=2),388            Constant(value=3)],389        ctx=Load()))390>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))391Expression(392    body=Tuple(393        elts=[394            Constant(value=1),395            Constant(value=2),396            Constant(value=3)],397        ctx=Load()))398```399400#### `class ast.Set(elts)`401402Множество. `elts` содержит список узлов, представляющих элементы множества.403404```pycon405>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))406Expression(407    body=Set(408        elts=[409            Constant(value=1),410            Constant(value=2),411            Constant(value=3)]))412```413414#### `class ast.Dict(keys, values)`415416Словарь. `keys` и `values` содержат списки узлов, представляющих ключи и значения соответственно, в соответствующем порядке (то, что было бы возвращено при вызове `dictionary.keys()` и `dictionary.values()`).417418При распаковке словаря с помощью литералов словаря выражение, которое нужно раскрыть, помещается в список `values`, а `None` – на соответствующую позицию в `keys`.419420```pycon421>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))422Expression(423    body=Dict(424        keys=[425            Constant(value='a'),426            None],427        values=[428            Constant(value=1),429            Name(id='d', ctx=Load())]))430```431432### Переменные433434#### `class ast.Name(id, ctx)`435436Имя переменной. `id` содержит имя в виде строки, а `ctx` – один из следующих типов.437438#### `class ast.Load`439440#### `class ast.Store`441442#### `class ast.Del`443444Ссылки на переменные можно использовать для загрузки значения переменной, для присваивания ей нового значения или для её удаления. Ссылки на переменные получают контекст, чтобы различать эти случаи.445446```pycon447>>> print(ast.dump(ast.parse('a'), indent=4))448Module(449    body=[450        Expr(451            value=Name(id='a', ctx=Load()))],452    type_ignores=[])453454>>> print(ast.dump(ast.parse('a = 1'), indent=4))455Module(456    body=[457        Assign(458            targets=[459                Name(id='a', ctx=Store())],460            value=Constant(value=1))],461    type_ignores=[])462463>>> print(ast.dump(ast.parse('del a'), indent=4))464Module(465    body=[466        Delete(467            targets=[468                Name(id='a', ctx=Del())])],469    type_ignores=[])470```471472#### `class ast.Starred(value, ctx)`473474Ссылка на переменную `*var`. В `value` хранится переменная, обычно узел [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name). Этот тип необходимо использовать при построении узла [`Call`](https://python-all.ru/3.12/library/ast.html#ast.Call) с помощью `*args`.475476```pycon477>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))478Module(479    body=[480        Assign(481            targets=[482                Tuple(483                    elts=[484                        Name(id='a', ctx=Store()),485                        Starred(486                            value=Name(id='b', ctx=Store()),487                            ctx=Store())],488                    ctx=Store())],489            value=Name(id='it', ctx=Load()))],490    type_ignores=[])491```492493### Выражения494495#### `class ast.Expr(value)`496497Когда выражение, например вызов функции, выступает в роли самостоятельного оператора и его возвращаемое значение не используется и не сохраняется, оно помещается в этот контейнер. `value` содержит один из остальных узлов этого раздела: узел [`Constant`](https://python-all.ru/3.12/library/ast.html#ast.Constant), узел [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name), [`Lambda`](https://python-all.ru/3.12/library/ast.html#ast.Lambda), [`Yield`](https://python-all.ru/3.12/library/ast.html#ast.Yield) или [`YieldFrom`](https://python-all.ru/3.12/library/ast.html#ast.YieldFrom).498499```pycon500>>> print(ast.dump(ast.parse('-a'), indent=4))501Module(502    body=[503        Expr(504            value=UnaryOp(505                op=USub(),506                operand=Name(id='a', ctx=Load())))],507    type_ignores=[])508```509510#### `class ast.UnaryOp(op, operand)`511512Унарная операция. `op` – оператор, а `operand` – любой узел выражения.513514#### `class ast.UAdd`515516#### `class ast.USub`517518#### `class ast.Not`519520#### `class ast.Invert`521522Токены унарных операторов. [`Not`](https://python-all.ru/3.12/library/ast.html#ast.Not) – ключевое слово `not`, [`Invert`](https://python-all.ru/3.12/library/ast.html#ast.Invert) – оператор `~`.523524```pycon525>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))526Expression(527    body=UnaryOp(528        op=Not(),529        operand=Name(id='x', ctx=Load())))530```531532#### `class ast.BinOp(left, op, right)`533534Бинарная операция (например, сложение или деление). `op` – оператор, а `left` и `right` – любые узлы выражений.535536```pycon537>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))538Expression(539    body=BinOp(540        left=Name(id='x', ctx=Load()),541        op=Add(),542        right=Name(id='y', ctx=Load())))543```544545#### `class ast.Add`546547#### `class ast.Sub`548549#### `class ast.Mult`550551#### `class ast.Div`552553#### `class ast.FloorDiv`554555#### `class ast.Mod`556557#### `class ast.Pow`558559#### `class ast.LShift`560561#### `class ast.RShift`562563#### `class ast.BitOr`564565#### `class ast.BitXor`566567#### `class ast.BitAnd`568569#### `class ast.MatMult`570571Токены бинарных операторов.572573#### `class ast.BoolOp(op, values)`574575Логическая операция – 'or' или 'and'. `op` – это [`Or`](https://python-all.ru/3.12/library/ast.html#ast.Or) или [`And`](https://python-all.ru/3.12/library/ast.html#ast.And). `values` – участвующие значения. Последовательные операции с одним и тем же оператором, например `a or b or c`, сводятся в один узел с несколькими значениями.576577Это не включает `not`, который является [`UnaryOp`](https://python-all.ru/3.12/library/ast.html#ast.UnaryOp).578579```pycon580>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))581Expression(582    body=BoolOp(583        op=Or(),584        values=[585            Name(id='x', ctx=Load()),586            Name(id='y', ctx=Load())]))587```588589#### `class ast.And`590591#### `class ast.Or`592593Токены логических операторов.594595#### `class ast.Compare(left, ops, comparators)`596597Сравнение двух или более значений. `left` – первое значение в сравнении, `ops` – список операторов, а `comparators` – список значений после первого элемента сравнения.598599```pycon600>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))601Expression(602    body=Compare(603        left=Constant(value=1),604        ops=[605            LtE(),606            Lt()],607        comparators=[608            Name(id='a', ctx=Load()),609            Constant(value=10)]))610```611612#### `class ast.Eq`613614#### `class ast.NotEq`615616#### `class ast.Lt`617618#### `class ast.LtE`619620#### `class ast.Gt`621622#### `class ast.GtE`623624#### `class ast.Is`625626#### `class ast.IsNot`627628#### `class ast.In`629630#### `class ast.NotIn`631632Токены операторов сравнения.633634#### `class ast.Call(func, args, keywords)`635636Вызов функции. `func` – это функция; обычно это объект [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name) или [`Attribute`](https://python-all.ru/3.12/library/ast.html#ast.Attribute). Об аргументах:637638- `args` содержит список аргументов, переданных по позиции.639- `keywords` содержит список объектов [`keyword`](https://python-all.ru/3.12/library/ast.html#ast.keyword), представляющих аргументы, переданные по ключевому слову.640641При создании узла `Call` обязательны `args` и `keywords`, но они могут быть пустыми списками.642643```pycon644>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))645Expression(646    body=Call(647        func=Name(id='func', ctx=Load()),648        args=[649            Name(id='a', ctx=Load()),650            Starred(651                value=Name(id='d', ctx=Load()),652                ctx=Load())],653        keywords=[654            keyword(655                arg='b',656                value=Name(id='c', ctx=Load())),657            keyword(658                value=Name(id='e', ctx=Load()))]))659```660661#### `class ast.keyword(arg, value)`662663Именованный аргумент вызова функции или определения класса. `arg` – это необработанная строка с именем параметра, `value` – узел, который нужно передать.664665#### `class ast.IfExp(test, body, orelse)`666667Выражение, например `a if b else c`. Каждое поле содержит один узел, поэтому в следующем примере все три являются узлами [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name).668669```pycon670>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))671Expression(672    body=IfExp(673        test=Name(id='b', ctx=Load()),674        body=Name(id='a', ctx=Load()),675        orelse=Name(id='c', ctx=Load())))676```677678#### `class ast.Attribute(value, attr, ctx)`679680Доступ к атрибуту, например `d.keys`. `value` – это узел, обычно [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name). `attr` – это строка с именем атрибута, а `ctx` – [`Load`](https://python-all.ru/3.12/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.12/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.12/library/ast.html#ast.Del) в зависимости от того, как используется атрибут.681682```pycon683>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))684Expression(685    body=Attribute(686        value=Name(id='snake', ctx=Load()),687        attr='colour',688        ctx=Load()))689```690691#### `class ast.NamedExpr(target, value)`692693Именованное выражение. Этот узел AST создаётся оператором присваивания (также известным как оператор «морж»). В отличие от узла [`Assign`](https://python-all.ru/3.12/library/ast.html#ast.Assign), где первый аргумент может быть несколькими узлами, в данном случае и `target`, и `value` должны быть одиночными узлами.694695```pycon696>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))697Expression(698    body=NamedExpr(699        target=Name(id='x', ctx=Store()),700        value=Constant(value=4)))701```702703Добавлено в версии 3.8.704705#### Индексирование706707#### `class ast.Subscript(value, slice, ctx)`708709Индексация, такая как `l[1]`. `value` – индексируемый объект (обычно последовательность или отображение). `slice` – это индекс, срез или ключ. Оно может быть [`Tuple`](https://python-all.ru/3.12/library/ast.html#ast.Tuple) и содержать [`Slice`](https://python-all.ru/3.12/library/ast.html#ast.Slice). `ctx` является [`Load`](https://python-all.ru/3.12/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.12/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.12/library/ast.html#ast.Del) в зависимости от выполняемого действия при индексации.710711```pycon712>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))713Expression(714    body=Subscript(715        value=Name(id='l', ctx=Load()),716        slice=Tuple(717            elts=[718                Slice(719                    lower=Constant(value=1),720                    upper=Constant(value=2)),721                Constant(value=3)],722            ctx=Load()),723        ctx=Load()))724```725726#### `class ast.Slice(lower, upper, step)`727728Обычный срез (в виде `lower:upper` или `lower:upper:step`). Может встречаться только внутри поля *slice* узла [`Subscript`](https://python-all.ru/3.12/library/ast.html#ast.Subscript), либо напрямую, либо как элемент [`Tuple`](https://python-all.ru/3.12/library/ast.html#ast.Tuple).729730```pycon731>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))732Expression(733    body=Subscript(734        value=Name(id='l', ctx=Load()),735        slice=Slice(736            lower=Constant(value=1),737            upper=Constant(value=2)),738        ctx=Load()))739```740741#### Генераторы коллекций742743#### `class ast.ListComp(elt, generators)`744745#### `class ast.SetComp(elt, generators)`746747#### `class ast.GeneratorExp(elt, generators)`748749#### `class ast.DictComp(key, value, generators)`750751Генераторы списков и множеств, генераторные выражения и генераторы словарей. `elt` (или `key` и `value`) – это один узел, представляющий часть, которая будет вычисляться для каждого элемента.752753`generators` – это список узлов [`comprehension`](https://python-all.ru/3.12/library/ast.html#ast.comprehension).754755```pycon756>>> print(ast.dump(ast.parse('[x for x in numbers]', mode='eval'), indent=4))757Expression(758    body=ListComp(759        elt=Name(id='x', ctx=Load()),760        generators=[761            comprehension(762                target=Name(id='x', ctx=Store()),763                iter=Name(id='numbers', ctx=Load()),764                ifs=[],765                is_async=0)]))766>>> print(ast.dump(ast.parse('{x: x**2 for x in numbers}', mode='eval'), indent=4))767Expression(768    body=DictComp(769        key=Name(id='x', ctx=Load()),770        value=BinOp(771            left=Name(id='x', ctx=Load()),772            op=Pow(),773            right=Constant(value=2)),774        generators=[775            comprehension(776                target=Name(id='x', ctx=Store()),777                iter=Name(id='numbers', ctx=Load()),778                ifs=[],779                is_async=0)]))780>>> print(ast.dump(ast.parse('{x for x in numbers}', mode='eval'), indent=4))781Expression(782    body=SetComp(783        elt=Name(id='x', ctx=Load()),784        generators=[785            comprehension(786                target=Name(id='x', ctx=Store()),787                iter=Name(id='numbers', ctx=Load()),788                ifs=[],789                is_async=0)]))790```791792#### `class ast.comprehension(target, iter, ifs, is_async)`793794Одно предложение `for` в генераторе коллекции. `target` – это ссылка, используемая для каждого элемента (обычно узел [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name) или [`Tuple`](https://python-all.ru/3.12/library/ast.html#ast.Tuple)). `iter` – объект, по которому выполняется итерация. `ifs` – список проверочных выражений: каждое предложение `for` может содержать несколько `ifs`.795796`is_async` указывает, что генератор коллекции является асинхронным (использует `async for` вместо `for`). Значение – целое число (0 или 1).797798```pycon799>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),800...                indent=4)) # несколько включений в одном801Expression(802    body=ListComp(803        elt=Call(804            func=Name(id='ord', ctx=Load()),805            args=[806                Name(id='c', ctx=Load())],807            keywords=[]),808        generators=[809            comprehension(810                target=Name(id='line', ctx=Store()),811                iter=Name(id='file', ctx=Load()),812                ifs=[],813                is_async=0),814            comprehension(815                target=Name(id='c', ctx=Store()),816                iter=Name(id='line', ctx=Load()),817                ifs=[],818                is_async=0)]))819820>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),821...                indent=4)) # выражение-генератор822Expression(823    body=GeneratorExp(824        elt=BinOp(825            left=Name(id='n', ctx=Load()),826            op=Pow(),827            right=Constant(value=2)),828        generators=[829            comprehension(830                target=Name(id='n', ctx=Store()),831                iter=Name(id='it', ctx=Load()),832                ifs=[833                    Compare(834                        left=Name(id='n', ctx=Load()),835                        ops=[836                            Gt()],837                        comparators=[838                            Constant(value=5)]),839                    Compare(840                        left=Name(id='n', ctx=Load()),841                        ops=[842                            Lt()],843                        comparators=[844                            Constant(value=10)])],845                is_async=0)]))846847>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),848...                indent=4)) # асинхронное включение849Expression(850    body=ListComp(851        elt=Name(id='i', ctx=Load()),852        generators=[853            comprehension(854                target=Name(id='i', ctx=Store()),855                iter=Name(id='soc', ctx=Load()),856                ifs=[],857                is_async=1)]))858```859860### Инструкции861862#### `class ast.Assign(targets, value, type_comment)`863864Присваивание. `targets` – список узлов, а `value` – один узел.865866Несколько узлов в `targets` обозначают присваивание одного и того же значения каждому. Распаковка представляется помещением узла [`Tuple`](https://python-all.ru/3.12/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.12/library/ast.html#ast.List) внутрь `targets`.867868#### `type_comment`869870`type_comment` – это необязательная строка с аннотацией типа в виде комментария.871872```pycon873>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # множественное присваивание874Module(875    body=[876        Assign(877            targets=[878                Name(id='a', ctx=Store()),879                Name(id='b', ctx=Store())],880            value=Constant(value=1))],881    type_ignores=[])882883>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # распаковка884Module(885    body=[886        Assign(887            targets=[888                Tuple(889                    elts=[890                        Name(id='a', ctx=Store()),891                        Name(id='b', ctx=Store())],892                    ctx=Store())],893            value=Name(id='c', ctx=Load()))],894    type_ignores=[])895```896897#### `class ast.AnnAssign(target, annotation, value, simple)`898899Присваивание с аннотацией типа. `target` – это один узел, который может быть [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.12/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.12/library/ast.html#ast.Subscript). `annotation` – аннотация, например узел [`Constant`](https://python-all.ru/3.12/library/ast.html#ast.Constant) или [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name). `value` – один необязательный узел.900901`simple` всегда равен либо 0 (обозначает «сложную» цель), либо 1 (обозначает «простую» цель). «Простая» цель состоит только из узла [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name), который не находится в круглых скобках; все остальные цели считаются сложными. Только простые цели появляются в словаре `__annotations__` модулей и классов.902903```pycon904>>> print(ast.dump(ast.parse('c: int'), indent=4))905Module(906    body=[907        AnnAssign(908            target=Name(id='c', ctx=Store()),909            annotation=Name(id='int', ctx=Load()),910            simple=1)],911    type_ignores=[])912913>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # аннотация со скобками914Module(915    body=[916        AnnAssign(917            target=Name(id='a', ctx=Store()),918            annotation=Name(id='int', ctx=Load()),919            value=Constant(value=1),920            simple=0)],921    type_ignores=[])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)],933    type_ignores=[])934935>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # аннотация подписки936Module(937    body=[938        AnnAssign(939            target=Subscript(940                value=Name(id='a', ctx=Load()),941                slice=Constant(value=1),942                ctx=Store()),943            annotation=Name(id='int', ctx=Load()),944            simple=0)],945    type_ignores=[])946```947948#### `class ast.AugAssign(target, op, value)`949950Расширенное присваивание, например `a += 1`. В следующем примере `target` – это узел [Имя](https://python-all.ru/3.12/library/ast.html#ast.Name) для `x` (с контекстом [`Store`](https://python-all.ru/3.12/library/ast.html#ast.Store)), `op` – это [Сложение](https://python-all.ru/3.12/library/ast.html#ast.Add), а `value` – это [Константа](https://python-all.ru/3.12/library/ast.html#ast.Constant) со значением 1.951952Атрибут `target` не может быть класса [`Tuple`](https://python-all.ru/3.12/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.12/library/ast.html#ast.List), в отличие от целей [`Assign`](https://python-all.ru/3.12/library/ast.html#ast.Assign).953954```pycon955>>> print(ast.dump(ast.parse('x += 2'), indent=4))956Module(957    body=[958        AugAssign(959            target=Name(id='x', ctx=Store()),960            op=Add(),961            value=Constant(value=2))],962    type_ignores=[])963```964965#### `class ast.Raise(exc, cause)`966967Инструкция `raise`. `exc` – объект исключения, который необходимо возбудить, обычно [Вызов](https://python-all.ru/3.12/library/ast.html#ast.Call) или [Имя](https://python-all.ru/3.12/library/ast.html#ast.Name), или `None` для отдельного `raise`. `cause` – необязательная часть для `y` в `Возбуждение`.968969```pycon970>>> print(ast.dump(ast.parse('raise x from y'), indent=4))971Module(972    body=[973        Raise(974            exc=Name(id='x', ctx=Load()),975            cause=Name(id='y', ctx=Load()))],976    type_ignores=[])977```978979#### `class ast.Assert(test, msg)`980981Утверждение. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.12/library/ast.html#ast.Compare). `msg` содержит сообщение об ошибке.982983```pycon984>>> print(ast.dump(ast.parse('assert x,y'), indent=4))985Module(986    body=[987        Assert(988            test=Name(id='x', ctx=Load()),989            msg=Name(id='y', ctx=Load()))],990    type_ignores=[])991```992993#### `class ast.Delete(targets)`994995Представляет инструкцию `del`. `targets` – список узлов, например узлов [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.12/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.12/library/ast.html#ast.Subscript).996997```pycon998>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))999Module(1000    body=[1001        Delete(1002            targets=[1003                Name(id='x', ctx=Del()),1004                Name(id='y', ctx=Del()),1005                Name(id='z', ctx=Del())])],1006    type_ignores=[])1007```10081009#### `class ast.Pass`10101011Инструкция `pass`.10121013```pycon1014>>> print(ast.dump(ast.parse('pass'), indent=4))1015Module(1016    body=[1017        Pass()],1018    type_ignores=[])1019```10201021#### `class ast.TypeAlias(name, type_params, value)`10221023[Псевдоним типа](https://python-all.ru/3.12/library/typing.html#type-aliases), созданный с помощью инструкции [`type`](https://python-all.ru/3.12/reference/simple_stmts.html#type) . `name` – имя псевдонима, `type_params` – список [параметров типа](https://python-all.ru/3.12/library/ast.html#ast-type-params), а `value` – значение псевдонима типа.10241025```pycon1026>>> print(ast.dump(ast.parse('type Alias = int'), indent=4))1027Module(1028    body=[1029        TypeAlias(1030            name=Name(id='Alias', ctx=Store()),1031            type_params=[],1032            value=Name(id='int', ctx=Load()))],1033    type_ignores=[])1034```10351036Добавлено в версии 3.12.10371038Другие инструкции, которые применимы только внутри функций или циклов, описаны в других разделах.10391040#### Импорты10411042#### `class ast.Import(names)`10431044Инструкция импорта. `names` – это список узлов [`alias`](https://python-all.ru/3.12/library/ast.html#ast.alias).10451046```pycon1047>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))1048Module(1049    body=[1050        Import(1051            names=[1052                alias(name='x'),1053                alias(name='y'),1054                alias(name='z')])],1055    type_ignores=[])1056```10571058#### `class ast.ImportFrom(module, names, level)`10591060Представляет `from x import y`. `module` – это необработанная строка имени from, без начальных точек, или `None` для инструкций вроде `from . import foo`. `level` – целое число, указывающее уровень относительного импорта (0 означает абсолютный импорт).10611062```pycon1063>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))1064Module(1065    body=[1066        ImportFrom(1067            module='y',1068            names=[1069                alias(name='x'),1070                alias(name='y'),1071                alias(name='z')],1072            level=0)],1073    type_ignores=[])1074```10751076#### `class ast.alias(name, asname)`10771078Оба параметра – необработанные строки имён. `asname` может быть `None`, если должно использоваться обычное имя.10791080```pycon1081>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))1082Module(1083    body=[1084        ImportFrom(1085            module='foo.bar',1086            names=[1087                alias(name='a', asname='b'),1088                alias(name='c')],1089            level=2)],1090    type_ignores=[])1091```10921093### Управление потоком10941095> **Примечание**1096>1097> Необязательные предложения, такие как `else`, сохраняются как пустой список, если они отсутствуют.10981099#### `class ast.If(test, body, orelse)`11001101Инструкция `if`. `test` содержит один узел, например узел [`Compare`](https://python-all.ru/3.12/library/ast.html#ast.Compare). `body` и `orelse` содержат по списку узлов.11021103Предложения `elif` не имеют специального представления в AST, а появляются как дополнительные узлы [`If`](https://python-all.ru/3.12/library/ast.html#ast.If) в разделе `orelse` предыдущего.11041105```pycon1106>>> print(ast.dump(ast.parse("""1107... if x:1108...    ...1109... elif y:1110...    ...1111... else:1112...    ...1113... """), indent=4))1114Module(1115    body=[1116        If(1117            test=Name(id='x', ctx=Load()),1118            body=[1119                Expr(1120                    value=Constant(value=Ellipsis))],1121            orelse=[1122                If(1123                    test=Name(id='y', ctx=Load()),1124                    body=[1125                        Expr(1126                            value=Constant(value=Ellipsis))],1127                    orelse=[1128                        Expr(1129                            value=Constant(value=Ellipsis))])])],1130    type_ignores=[])1131```11321133#### `class ast.For(target, iter, body, orelse, type_comment)`11341135Цикл `for`. `target` содержит переменную (или переменные), которой присваивает цикл, в виде одного узла [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.12/library/ast.html#ast.Tuple), [`List`](https://python-all.ru/3.12/library/ast.html#ast.List), [`Attribute`](https://python-all.ru/3.12/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.12/library/ast.html#ast.Subscript). `iter` содержит элемент, по которому выполняется итерация, также в виде одного узла. `body` и `orelse` содержат списки узлов для выполнения. Те, что в `orelse`, выполняются, если цикл завершается нормально, а не по инструкции `break`.11361137#### `type_comment`11381139`type_comment` – это необязательная строка с аннотацией типа в виде комментария.11401141```pycon1142>>> print(ast.dump(ast.parse("""1143... for x in y:1144...     ...1145... else:1146...     ...1147... """), indent=4))1148Module(1149    body=[1150        For(1151            target=Name(id='x', ctx=Store()),1152            iter=Name(id='y', ctx=Load()),1153            body=[1154                Expr(1155                    value=Constant(value=Ellipsis))],1156            orelse=[1157                Expr(1158                    value=Constant(value=Ellipsis))])],1159    type_ignores=[])1160```11611162#### `class ast.While(test, body, orelse)`11631164Цикл `while`. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.12/library/ast.html#ast.Compare).11651166```pycon1167>> print(ast.dump(ast.parse("""1168... while x:1169...    ...1170... else:1171...    ...1172... """), indent=4))1173Module(1174    body=[1175        While(1176            test=Name(id='x', ctx=Load()),1177            body=[1178                Expr(1179                    value=Constant(value=Ellipsis))],1180            orelse=[1181                Expr(1182                    value=Constant(value=Ellipsis))])],1183    type_ignores=[])1184```11851186#### `class ast.Break`11871188#### `class ast.Continue`11891190Инструкции `break` и `continue`.11911192```pycon1193>>> print(ast.dump(ast.parse("""\1194... for a in b:1195...     if a > 5:1196...         break1197...     else:1198...         continue1199...1200... """), indent=4))1201Module(1202    body=[1203        For(1204            target=Name(id='a', ctx=Store()),1205            iter=Name(id='b', ctx=Load()),1206            body=[1207                If(1208                    test=Compare(1209                        left=Name(id='a', ctx=Load()),1210                        ops=[1211                            Gt()],1212                        comparators=[1213                            Constant(value=5)]),1214                    body=[1215                        Break()],1216                    orelse=[1217                        Continue()])],1218            orelse=[])],1219    type_ignores=[])1220```12211222#### `class ast.Try(body, handlers, orelse, finalbody)`12231224Блоки `try`. Все атрибуты – списки узлов для выполнения, за исключением `handlers`, который является списком узлов [`ExceptHandler`](https://python-all.ru/3.12/library/ast.html#ast.ExceptHandler).12251226```pycon1227>>> print(ast.dump(ast.parse("""1228... try:1229...    ...1230... except Exception:1231...    ...1232... except OtherException as e:1233...    ...1234... else:1235...    ...1236... finally:1237...    ...1238... """), indent=4))1239Module(1240    body=[1241        Try(1242            body=[1243                Expr(1244                    value=Constant(value=Ellipsis))],1245            handlers=[1246                ExceptHandler(1247                    type=Name(id='Exception', ctx=Load()),1248                    body=[1249                        Expr(1250                            value=Constant(value=Ellipsis))]),1251                ExceptHandler(1252                    type=Name(id='OtherException', ctx=Load()),1253                    name='e',1254                    body=[1255                        Expr(1256                            value=Constant(value=Ellipsis))])],1257            orelse=[1258                Expr(1259                    value=Constant(value=Ellipsis))],1260            finalbody=[1261                Expr(1262                    value=Constant(value=Ellipsis))])],1263    type_ignores=[])1264```12651266#### `class ast.TryStar(body, handlers, orelse, finalbody)`12671268Блоки `try`, за которыми следуют предложения `except*`. Атрибуты такие же, как для [`Try`](https://python-all.ru/3.12/library/ast.html#ast.Try), но узлы [`ExceptHandler`](https://python-all.ru/3.12/library/ast.html#ast.ExceptHandler) в `handlers` интерпретируются как блоки `except*`, а не `except`.12691270```pycon1271>>> print(ast.dump(ast.parse("""1272... try:1273...    ...1274... except* Exception:1275...    ...1276... """), indent=4))1277Module(1278    body=[1279        TryStar(1280            body=[1281                Expr(1282                    value=Constant(value=Ellipsis))],1283            handlers=[1284                ExceptHandler(1285                    type=Name(id='Exception', ctx=Load()),1286                    body=[1287                        Expr(1288                            value=Constant(value=Ellipsis))])],1289            orelse=[],1290            finalbody=[])],1291    type_ignores=[])1292```12931294Добавлено в версии 3.12.12951296#### `class ast.ExceptHandler(type, name, body)`12971298Одно предложение `except`. `type` – тип исключения, который оно перехватывает, обычно узел [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name) (или `None` для универсального предложения `except:`). `name` – необработанная строка для имени, в котором будет сохранено исключение, или `None`, если в предложении нет `as foo`. `body` – список узлов.12991300```pycon1301>>> print(ast.dump(ast.parse("""\1302... try:1303...     a + 11304... except TypeError:1305...     pass1306... """), indent=4))1307Module(1308    body=[1309        Try(1310            body=[1311                Expr(1312                    value=BinOp(1313                        left=Name(id='a', ctx=Load()),1314                        op=Add(),1315                        right=Constant(value=1)))],1316            handlers=[1317                ExceptHandler(1318                    type=Name(id='TypeError', ctx=Load()),1319                    body=[1320                        Pass()])],1321            orelse=[],1322            finalbody=[])],1323    type_ignores=[])1324```13251326#### `class ast.With(items, body, type_comment)`13271328Блок `with`. `items` – это список узлов [`withitem`](https://python-all.ru/3.12/library/ast.html#ast.withitem), представляющих менеджеры контекста, а `body` – это блок с отступом внутри контекста.13291330#### `type_comment`13311332`type_comment` – это необязательная строка с аннотацией типа в виде комментария.13331334#### `class ast.withitem(context_expr, optional_vars)`13351336Один менеджер контекста в блоке `with`. `context_expr` – это менеджер контекста, часто узел [`Call`](https://python-all.ru/3.12/library/ast.html#ast.Call). `optional_vars` – это [`Name`](https://python-all.ru/3.12/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.12/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.12/library/ast.html#ast.List) для части `as foo`, или `None`, если она не используется.13371338```pycon1339>>> print(ast.dump(ast.parse("""\1340... with a as b, c as d:1341...    something(b, d)1342... """), indent=4))1343Module(1344    body=[1345        With(1346            items=[1347                withitem(1348                    context_expr=Name(id='a', ctx=Load()),1349                    optional_vars=Name(id='b', ctx=Store())),1350                withitem(1351                    context_expr=Name(id='c', ctx=Load()),1352                    optional_vars=Name(id='d', ctx=Store()))],1353            body=[1354                Expr(1355                    value=Call(1356                        func=Name(id='something', ctx=Load()),1357                        args=[1358                            Name(id='b', ctx=Load()),1359                            Name(id='d', ctx=Load())],1360                        keywords=[]))])],1361    type_ignores=[])1362```13631364### Сопоставление с образцом13651366#### `class ast.Match(subject, cases)`13671368Оператор `match`. В `subject` хранится subject сопоставления (объект, который сравнивается с вариантами), а `cases` содержит итерируемый набор узлов [`match_case`](https://python-all.ru/3.12/library/ast.html#ast.match_case) с различными вариантами.13691370Добавлено в версии 3.10.13711372#### `class ast.match_case(pattern, guard, body)`13731374Один вариант (case) в операторе `match`. `pattern` содержит шаблон сопоставления, с которым будет сравниваться subject. Обратите внимание, что узлы [`AST`](https://python-all.ru/3.12/library/ast.html#ast.AST), создаваемые для шаблонов, отличаются от узлов, создаваемых для выражений, даже при одинаковом синтаксисе.13751376Атрибут `guard` содержит выражение, которое будет вычислено, если шаблон совпадает с subject.13771378`body` содержит список узлов, которые выполняются, если шаблон совпадает и результат вычисления guard-выражения истинен.13791380```pycon1381>>> print(ast.dump(ast.parse("""1382... match x:1383...     case [x] if x>0:1384...         ...1385...     case tuple():1386...         ...1387... """), indent=4))1388Module(1389    body=[1390        Match(1391            subject=Name(id='x', ctx=Load()),1392            cases=[1393                match_case(1394                    pattern=MatchSequence(1395                        patterns=[1396                            MatchAs(name='x')]),1397                    guard=Compare(1398                        left=Name(id='x', ctx=Load()),1399                        ops=[1400                            Gt()],1401                        comparators=[1402                            Constant(value=0)]),1403                    body=[1404                        Expr(1405                            value=Constant(value=Ellipsis))]),1406                match_case(1407                    pattern=MatchClass(1408                        cls=Name(id='tuple', ctx=Load()),1409                        patterns=[],1410                        kwd_attrs=[],1411                        kwd_patterns=[]),1412                    body=[1413                        Expr(1414                            value=Constant(value=Ellipsis))])])],1415    type_ignores=[])1416```14171418Добавлено в версии 3.10.14191420#### `class ast.MatchValue(value)`14211422Сопоставление с литералом или шаблоном значения, сравниваемым по равенству. `value` – это узел выражения. Допустимые узлы значений ограничены, как описано в документации оператора match. Этот шаблон успешно срабатывает, если subject сопоставления равен вычисленному значению.14231424```pycon1425>>> print(ast.dump(ast.parse("""1426... match x:1427...     case "Relevant":1428...         ...1429... """), indent=4))1430Module(1431    body=[1432        Match(1433            subject=Name(id='x', ctx=Load()),1434            cases=[1435                match_case(1436                    pattern=MatchValue(1437                        value=Constant(value='Relevant')),1438                    body=[1439                        Expr(1440                            value=Constant(value=Ellipsis))])])],1441    type_ignores=[])1442```14431444Добавлено в версии 3.10.14451446#### `class ast.MatchSingleton(value)`14471448Сопоставление с литералом, сравниваемым по идентичности. `value` – это синглтон, с которым производится сравнение: `None`, `True` или `False`. Этот шаблон успешно срабатывает, если subject сопоставления является заданной константой.14491450```pycon1451>>> print(ast.dump(ast.parse("""1452... match x:1453...     case None:1454...         ...1455... """), indent=4))1456Module(1457    body=[1458        Match(1459            subject=Name(id='x', ctx=Load()),1460            cases=[1461                match_case(1462                    pattern=MatchSingleton(value=None),1463                    body=[1464                        Expr(1465                            value=Constant(value=Ellipsis))])])],1466    type_ignores=[])1467```14681469Добавлено в версии 3.10.14701471#### `class ast.MatchSequence(patterns)`14721473Шаблон последовательности (sequence pattern) в match. `patterns` содержит шаблоны, которые будут сопоставляться с элементами subject, если subject является последовательностью. Сопоставляется с последовательностью переменной длины, если один из подшаблонов является узлом `MatchStar`, в противном случае сопоставляется с последовательностью фиксированной длины.14741475```pycon1476>>> print(ast.dump(ast.parse("""1477... match x:1478...     case [1, 2]:1479...         ...1480... """), indent=4))1481Module(1482    body=[1483        Match(1484            subject=Name(id='x', ctx=Load()),1485            cases=[1486                match_case(1487                    pattern=MatchSequence(1488                        patterns=[1489                            MatchValue(1490                                value=Constant(value=1)),1491                            MatchValue(1492                                value=Constant(value=2))]),1493                    body=[1494                        Expr(1495                            value=Constant(value=Ellipsis))])])],1496    type_ignores=[])1497```14981499Добавлено в версии 3.10.15001501#### `class ast.MatchStar(name)`15021503Сопоставляется с остатком последовательности в шаблоне последовательности переменной длины. Если `name` не равно `None`, то при успешном сопоставлении всего шаблона последовательности этому имени привязывается список, содержащий оставшиеся элементы последовательности.15041505```pycon1506>>> print(ast.dump(ast.parse("""1507... match x:1508...     case [1, 2, *rest]:1509...         ...1510...     case [*_]:1511...         ...1512... """), indent=4))1513Module(1514    body=[1515        Match(1516            subject=Name(id='x', ctx=Load()),1517            cases=[1518                match_case(1519                    pattern=MatchSequence(1520                        patterns=[1521                            MatchValue(1522                                value=Constant(value=1)),1523                            MatchValue(1524                                value=Constant(value=2)),1525                            MatchStar(name='rest')]),1526                    body=[1527                        Expr(1528                            value=Constant(value=Ellipsis))]),1529                match_case(1530                    pattern=MatchSequence(1531                        patterns=[1532                            MatchStar()]),1533                    body=[1534                        Expr(1535                            value=Constant(value=Ellipsis))])])],1536    type_ignores=[])1537```15381539Добавлено в версии 3.10.15401541#### `class ast.MatchMapping(keys, patterns, rest)`15421543Шаблон отображения (mapping pattern) в match. `keys` – последовательность узлов выражений. `patterns` – соответствующая последовательность узлов шаблонов. `rest` – необязательное имя, которое можно указать для захвата оставшихся элементов отображения. Допустимые ключевые выражения ограничены, как описано в документации оператора match.15441545Этот шаблон успешно срабатывает, если subject является отображением, все вычисленные ключевые выражения присутствуют в отображении, а значение, соответствующее каждому ключу, совпадает с соответствующим подшаблоном. Если `rest` не равно `None`, то при успешном сопоставлении всего шаблона отображения этому имени привязывается словарь, содержащий оставшиеся элементы отображения.15461547```pycon1548>>> print(ast.dump(ast.parse("""1549... match x:1550...     case {1: _, 2: _}:1551...         ...1552...     case {**rest}:1553...         ...1554... """), indent=4))1555Module(1556    body=[1557        Match(1558            subject=Name(id='x', ctx=Load()),1559            cases=[1560                match_case(1561                    pattern=MatchMapping(1562                        keys=[1563                            Constant(value=1),1564                            Constant(value=2)],1565                        patterns=[1566                            MatchAs(),1567                            MatchAs()]),1568                    body=[1569                        Expr(1570                            value=Constant(value=Ellipsis))]),1571                match_case(1572                    pattern=MatchMapping(keys=[], patterns=[], rest='rest'),1573                    body=[1574                        Expr(1575                            value=Constant(value=Ellipsis))])])],1576    type_ignores=[])1577```15781579Добавлено в версии 3.10.15801581#### `class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)`15821583Шаблон класса (class pattern) в match. `cls` – выражение, задающее номинальный класс для сопоставления. `patterns` – последовательность узлов шаблонов, которые будут сопоставляться с определённой классом последовательностью атрибутов для сопоставления с образцом. `kwd_attrs` – последовательность дополнительных атрибутов для сопоставления (указанных как ключевые аргументы в шаблоне класса), `kwd_patterns` – соответствующие шаблоны (указанные как значения ключевых слов в шаблоне класса).15841585Этот шаблон успешно срабатывает, если subject является экземпляром указанного класса, все позиционные шаблоны совпадают с соответствующими атрибутами, определёнными классом, и все указанные ключевые атрибуты совпадают со своими шаблонами.15861587Примечание: классы могут определять свойство, возвращающее self, чтобы сопоставлять узел шаблона с сопоставляемым экземпляром. Некоторые встроенные типы также сопоставляются таким образом, как описано в документации оператора match.15881589```pycon1590>>> print(ast.dump(ast.parse("""1591... match x:1592...     case Point2D(0, 0):1593...         ...1594...     case Point3D(x=0, y=0, z=0):1595...         ...1596... """), indent=4))1597Module(1598    body=[1599        Match(1600            subject=Name(id='x', ctx=Load()),1601            cases=[1602                match_case(1603                    pattern=MatchClass(1604                        cls=Name(id='Point2D', ctx=Load()),1605                        patterns=[1606                            MatchValue(1607                                value=Constant(value=0)),1608                            MatchValue(1609                                value=Constant(value=0))],1610                        kwd_attrs=[],1611                        kwd_patterns=[]),1612                    body=[1613                        Expr(1614                            value=Constant(value=Ellipsis))]),1615                match_case(1616                    pattern=MatchClass(1617                        cls=Name(id='Point3D', ctx=Load()),1618                        patterns=[],1619                        kwd_attrs=[1620                            'x',1621                            'y',1622                            'z'],1623                        kwd_patterns=[1624                            MatchValue(1625                                value=Constant(value=0)),1626                            MatchValue(1627                                value=Constant(value=0)),1628                            MatchValue(1629                                value=Constant(value=0))]),1630                    body=[1631                        Expr(1632                            value=Constant(value=Ellipsis))])])],1633    type_ignores=[])1634```16351636Добавлено в версии 3.10.16371638#### `class ast.MatchAs(pattern, name)`16391640Сопоставление «as-pattern», шаблон захвата (capture pattern) или шаблон-заменитель (wildcard pattern). `pattern` содержит шаблон match, с которым будет сопоставлен subject. Если шаблон равен `None`, узел представляет собой шаблон захвата (т.е. просто имя) и всегда успешно срабатывает.16411642Атрибут `name` содержит имя, которое будет привязано при успешном сопоставлении шаблона. Если `name` равно `None`, то `pattern` также должно быть `None`, и узел представляет собой шаблон-заменитель (wildcard).16431644```pycon1645>>> print(ast.dump(ast.parse("""1646... match x:1647...     case [x] as y:1648...         ...1649...     case _:1650...         ...1651... """), indent=4))1652Module(1653    body=[1654        Match(1655            subject=Name(id='x', ctx=Load()),1656            cases=[1657                match_case(1658                    pattern=MatchAs(1659                        pattern=MatchSequence(1660                            patterns=[1661                                MatchAs(name='x')]),1662                        name='y'),1663                    body=[1664                        Expr(1665                            value=Constant(value=Ellipsis))]),1666                match_case(1667                    pattern=MatchAs(),1668                    body=[1669                        Expr(1670                            value=Constant(value=Ellipsis))])])],1671    type_ignores=[])1672```16731674Добавлено в версии 3.10.16751676#### `class ast.MatchOr(patterns)`16771678Сопоставление «or-pattern» (шаблон ИЛИ). Or-pattern последовательно сопоставляет каждый из своих подшаблонов с subject, пока один из них не сработает. Тогда считается, что or-pattern сработал. Если ни один из подшаблонов не сработал, or-pattern не срабатывает. Атрибут `patterns` содержит список узлов шаблонов match, которые будут сопоставляться с subject.16791680```pycon1681>>> print(ast.dump(ast.parse("""1682... match x:1683...     case [x] | (y):1684...         ...1685... """), indent=4))1686Module(1687    body=[1688        Match(1689            subject=Name(id='x', ctx=Load()),1690            cases=[1691                match_case(1692                    pattern=MatchOr(1693                        patterns=[1694                            MatchSequence(1695                                patterns=[1696                                    MatchAs(name='x')]),1697                            MatchAs(name='y')]),1698                    body=[1699                        Expr(1700                            value=Constant(value=Ellipsis))])])],1701    type_ignores=[])1702```17031704Добавлено в версии 3.10.17051706### Параметры типа17071708[Параметры типа](https://python-all.ru/3.12/reference/compound_stmts.html#type-params) могут существовать у классов, функций и псевдонимов типов.17091710#### `class ast.TypeVar(name, bound)`17111712Узел [`typing.TypeVar`](https://python-all.ru/3.12/library/typing.html#typing.TypeVar). `name` – это имя переменной типа. `bound` – это граница или ограничения, если они есть. Если `bound` является [`Tuple`](https://python-all.ru/3.12/library/ast.html#ast.Tuple), то оно представляет ограничения; в противном случае оно представляет границу.17131714```pycon1715>>> print(ast.dump(ast.parse("type Alias[T: int] = list[T]"), indent=4))1716Module(1717    body=[1718        TypeAlias(1719            name=Name(id='Alias', ctx=Store()),1720            type_params=[1721                TypeVar(1722                    name='T',1723                    bound=Name(id='int', ctx=Load()))],1724            value=Subscript(1725                value=Name(id='list', ctx=Load()),1726                slice=Name(id='T', ctx=Load()),1727                ctx=Load()))],1728    type_ignores=[])1729```17301731Добавлено в версии 3.12.17321733#### `class ast.ParamSpec(name)`17341735Узел [`typing.ParamSpec`](https://python-all.ru/3.12/library/typing.html#typing.ParamSpec). `name` – это имя спецификации параметра.17361737```pycon1738>>> print(ast.dump(ast.parse("type Alias[**P] = Callable[P, int]"), indent=4))1739Module(1740    body=[1741        TypeAlias(1742            name=Name(id='Alias', ctx=Store()),1743            type_params=[1744                ParamSpec(name='P')],1745            value=Subscript(1746                value=Name(id='Callable', ctx=Load()),1747                slice=Tuple(1748                    elts=[1749                        Name(id='P', ctx=Load()),1750                        Name(id='int', ctx=Load())],1751                    ctx=Load()),1752                ctx=Load()))],1753    type_ignores=[])1754```17551756Добавлено в версии 3.12.17571758#### `class ast.TypeVarTuple(name)`17591760Узел [`typing.TypeVarTuple`](https://python-all.ru/3.12/library/typing.html#typing.TypeVarTuple). `name` – это имя кортежа переменных типа.17611762```pycon1763>>> print(ast.dump(ast.parse("type Alias[*Ts] = tuple[*Ts]"), indent=4))1764Module(1765    body=[1766        TypeAlias(1767            name=Name(id='Alias', ctx=Store()),1768            type_params=[1769                TypeVarTuple(name='Ts')],1770            value=Subscript(1771                value=Name(id='tuple', ctx=Load()),1772                slice=Tuple(1773                    elts=[1774                        Starred(1775                            value=Name(id='Ts', ctx=Load()),1776                            ctx=Load())],1777                    ctx=Load()),1778                ctx=Load()))],1779    type_ignores=[])1780```17811782Добавлено в версии 3.12.17831784### Определения функций и классов17851786#### `class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`17871788Определение функции.17891790- `name` – это необработанная строка имени функции.1791- `args` – это узел [`arguments`](https://python-all.ru/3.12/library/ast.html#ast.arguments).1792- `body` – это список узлов внутри функции.1793- `decorator_list` – это список декораторов, которые будут применены; декораторы перечислены от самого внешнего к внутреннему (т.е. первый в списке применяется последним).1794- `returns` – это аннотация возвращаемого значения.1795- `type_params` – это список [параметров типа](https://python-all.ru/3.12/library/ast.html#ast-type-params).17961797#### `type_comment`17981799`type_comment` – это необязательная строка с аннотацией типа в виде комментария.18001801Изменено в версии 3.12: Добавлен `type_params`.18021803#### `class ast.Lambda(args, body)`18041805`lambda` – это минимальное определение функции, которое можно использовать внутри выражения. В отличие от [`FunctionDef`](https://python-all.ru/3.12/library/ast.html#ast.FunctionDef), `body` содержит один узел.18061807```pycon1808>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))1809Module(1810    body=[1811        Expr(1812            value=Lambda(1813                args=arguments(1814                    posonlyargs=[],1815                    args=[1816                        arg(arg='x'),1817                        arg(arg='y')],1818                    kwonlyargs=[],1819                    kw_defaults=[],1820                    defaults=[]),1821                body=Constant(value=Ellipsis)))],1822    type_ignores=[])1823```18241825#### `class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)`18261827Аргументы функции.18281829- `posonlyargs`, `args` и `kwonlyargs` – это списки узлов [`arg`](https://python-all.ru/3.12/library/ast.html#ast.arg).1830- `vararg` и `kwarg` – это одиночные узлы [`arg`](https://python-all.ru/3.12/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.12/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                posonlyargs=[],1855                args=[1856                    arg(1857                        arg='a',1858                        annotation=Constant(value='annotation')),1859                    arg(arg='b'),1860                    arg(arg='c')],1861                vararg=arg(arg='d'),1862                kwonlyargs=[1863                    arg(arg='e'),1864                    arg(arg='f')],1865                kw_defaults=[1866                    None,1867                    Constant(value=3)],1868                kwarg=arg(arg='g'),1869                defaults=[1870                    Constant(value=1),1871                    Constant(value=2)]),1872            body=[1873                Pass()],1874            decorator_list=[1875                Name(id='decorator1', ctx=Load()),1876                Name(id='decorator2', ctx=Load())],1877            returns=Constant(value='return annotation'),1878            type_params=[])],1879    type_ignores=[])1880```18811882#### `class ast.Return(value)`18831884Инструкция `return`.18851886```pycon1887>>> print(ast.dump(ast.parse('return 4'), indent=4))1888Module(1889    body=[1890        Return(1891            value=Constant(value=4))],1892    type_ignores=[])1893```18941895#### `class ast.Yield(value)`18961897#### `class ast.YieldFrom(value)`18981899Выражение `yield` или `yield from`. Поскольку это выражения, они должны быть обёрнуты в узел [`Expr`](https://python-all.ru/3.12/library/ast.html#ast.Expr), если возвращаемое значение не используется.19001901```pycon1902>>> print(ast.dump(ast.parse('yield x'), indent=4))1903Module(1904    body=[1905        Expr(1906            value=Yield(1907                value=Name(id='x', ctx=Load())))],1908    type_ignores=[])19091910>>> print(ast.dump(ast.parse('yield from x'), indent=4))1911Module(1912    body=[1913        Expr(1914            value=YieldFrom(1915                value=Name(id='x', ctx=Load())))],1916    type_ignores=[])1917```19181919#### `class ast.Global(names)`19201921#### `class ast.Nonlocal(names)`19221923Инструкции `global` и `nonlocal`. `names` – это список сырых строк.19241925```pycon1926>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))1927Module(1928    body=[1929        Global(1930            names=[1931                'x',1932                'y',1933                'z'])],1934    type_ignores=[])19351936>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))1937Module(1938    body=[1939        Nonlocal(1940            names=[1941                'x',1942                'y',1943                'z'])],1944    type_ignores=[])1945```19461947#### `class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)`19481949Определение класса.19501951- `name` – это сырая строка с именем класса.1952- `bases` – это список узлов для явно указанных базовых классов.1953- `keywords` – это список узлов [`keyword`](https://python-all.ru/3.12/library/ast.html#ast.keyword), в первую очередь для ‘metaclass’. Остальные ключевые слова будут переданы метаклассу, в соответствии с [**PEP 3115**](https://python-all.ru/3.12/library/ast.html).1954- `body` – это список узлов, представляющих код внутри определения класса.1955- `decorator_list` – это список узлов, как и в [`FunctionDef`](https://python-all.ru/3.12/library/ast.html#ast.FunctionDef).1956- `type_params` – это список [параметров типа](https://python-all.ru/3.12/library/ast.html#ast-type-params).19571958```pycon1959>>> print(ast.dump(ast.parse("""\1960... @decorator11961... @decorator21962... class Foo(base1, base2, metaclass=meta):1963...     pass1964... """), indent=4))1965Module(1966    body=[1967        ClassDef(1968            name='Foo',1969            bases=[1970                Name(id='base1', ctx=Load()),1971                Name(id='base2', ctx=Load())],1972            keywords=[1973                keyword(1974                    arg='metaclass',1975                    value=Name(id='meta', ctx=Load()))],1976            body=[1977                Pass()],1978            decorator_list=[1979                Name(id='decorator1', ctx=Load()),1980                Name(id='decorator2', ctx=Load())],1981            type_params=[])],1982    type_ignores=[])1983```19841985Изменено в версии 3.12: Добавлен `type_params`.19861987### async и await19881989#### `class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`19901991Определение функции `async def`. Имеет те же поля, что и [`FunctionDef`](https://python-all.ru/3.12/library/ast.html#ast.FunctionDef).19921993Изменено в версии 3.12: Добавлен `type_params`.19941995#### `class ast.Await(value)`19961997Выражение `await`. `value` – это то, чего оно ожидает. Допустимо только в теле [`AsyncFunctionDef`](https://python-all.ru/3.12/library/ast.html#ast.AsyncFunctionDef).19981999```pycon2000>>> print(ast.dump(ast.parse("""\2001... async def f():2002...     await other_func()2003... """), indent=4))2004Module(2005    body=[2006        AsyncFunctionDef(2007            name='f',2008            args=arguments(2009                posonlyargs=[],2010                args=[],2011                kwonlyargs=[],2012                kw_defaults=[],2013                defaults=[]),2014            body=[2015                Expr(2016                    value=Await(2017                        value=Call(2018                            func=Name(id='other_func', ctx=Load()),2019                            args=[],2020                            keywords=[])))],2021            decorator_list=[],2022            type_params=[])],2023    type_ignores=[])2024```20252026#### `class ast.AsyncFor(target, iter, body, orelse, type_comment)`20272028#### `class ast.AsyncWith(items, body, type_comment)`20292030`async for` циклы и `async with` менеджеры контекста. Они имеют те же поля, что [`For`](https://python-all.ru/3.12/library/ast.html#ast.For) и [`With`](https://python-all.ru/3.12/library/ast.html#ast.With), соответственно. Допустимы только в теле [`AsyncFunctionDef`](https://python-all.ru/3.12/library/ast.html#ast.AsyncFunctionDef).20312032> **Примечание**2033>2034> Когда строка разбирается парсером [`ast.parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse), узлы операторов (подклассы `ast.operator`, `ast.unaryop`, `ast.cmpop`, `ast.boolop` и `ast.expr_context`) на возвращаемом дереве являются синглтонами. Изменения в одном будут отражены во всех других вхождениях того же значения (например, [`ast.Add`](https://python-all.ru/3.12/library/ast.html#ast.Add)).20352036## [`ast`](https://python-all.ru/3.12/library/ast.html#module-ast) Вспомогательные функции20372038Помимо классов узлов, модуль [`ast`](https://python-all.ru/3.12/library/ast.html#module-ast) определяет следующие служебные функции и классы для обхода абстрактных синтаксических деревьев:20392040#### `ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None)`20412042Разбирает исходный код в узел AST. Эквивалентно `compile(source, filename, mode, ast.PyCF_ONLY_AST)`.20432044Если задан `type_comments=True`, парсер изменяется, чтобы проверять и возвращать комментарии типов, как указано в [**PEP 484**](https://python-all.ru/3.12/library/ast.html) и [**PEP 526**](https://python-all.ru/3.12/library/ast.html). Это эквивалентно добавлению [`ast.PyCF_TYPE_COMMENTS`](https://python-all.ru/3.12/library/ast.html#ast.PyCF_TYPE_COMMENTS) к флагам, передаваемым в [`compile()`](https://python-all.ru/3.12/library/functions.html#compile). Это приведёт к сообщению об ошибках синтаксиса для неправильно расположенных комментариев типов. Без этого флага комментарии типов будут игнорироваться, и поле `type_comment` в выбранных узлах AST всегда будет `None`. Кроме того, расположение комментариев `# type: ignore` будет возвращаться как атрибут `type_ignores` объекта [`Module`](https://python-all.ru/3.12/library/ast.html#ast.Module) (иначе это всегда пустой список).20452046Кроме того, если `mode` равно `'func_type'`, синтаксис входных данных изменяется в соответствии с [**PEP 484**](https://python-all.ru/3.12/library/ast.html) «сигнатурными комментариями типов», например `(str, int) -> List[str]`.20472048Установка `feature_version` в кортеж `(major, minor)` приведёт к «наилучшей попытке» разбора с использованием грамматики этой версии Python. Например, установка `feature_version=(3, 9)` будет пытаться запретить разбор инструкций [`match`](https://python-all.ru/3.12/reference/compound_stmts.html#match). В настоящее время `major` должно быть равно `3`. Самая низкая поддерживаемая версия – `(3, 4)` (и это может увеличиться в будущих версиях Python); самая высокая – `sys.version_info[0:2]`. «Наилучшая попытка» означает, что нет гарантии, что разбор (или успех разбора) будет таким же, как при запуске на версии Python, соответствующей `feature_version`.20492050Если исходный код содержит нулевой символ (`\0`), возбуждается [`ValueError`](https://python-all.ru/3.12/library/exceptions.html#ValueError).20512052> **Предупреждение**2053>2054> Обратите внимание, что успешный разбор исходного кода в объект AST не гарантирует, что предоставленный исходный код является корректным кодом Python, который можно выполнить, поскольку этап компиляции может вызывать дополнительные исключения [`SyntaxError`](https://python-all.ru/3.12/library/exceptions.html#SyntaxError). Например, исходный код `return 42` генерирует корректный узел AST для инструкции return, но его нельзя скомпилировать отдельно (он должен находиться внутри узла функции).2055>2056> В частности, [`ast.parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse) не выполняет никаких проверок областей видимости, которые выполняет этап компиляции.20572058> **Предупреждение**2059>2060> Можно вызвать сбой интерпретатора Python с помощью достаточно большой/сложной строки из-за ограничений глубины стека в компиляторе AST Python.20612062Изменено в версии 3.8: Добавлены `type_comments`, `mode='func_type'` и `feature_version`.20632064#### `ast.unparse(ast_obj)`20652066Выполняет обратный разбор объекта [`ast.AST`](https://python-all.ru/3.12/library/ast.html#ast.AST) и генерирует строку с кодом, который при обратном разборе с помощью [`ast.parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse) даст эквивалентный объект [`ast.AST`](https://python-all.ru/3.12/library/ast.html#ast.AST).20672068> **Предупреждение**2069>2070> Полученная строка кода не обязательно будет равна исходному коду, который породил объект [`ast.AST`](https://python-all.ru/3.12/library/ast.html#ast.AST) (без каких-либо оптимизаций компилятора, таких как константные кортежи/frozensets).20712072> **Предупреждение**2073>2074> Попытка выполнить обратный разбор очень сложного выражения приведёт к [`RecursionError`](https://python-all.ru/3.12/library/exceptions.html#RecursionError).20752076Добавлено в версии 3.9.20772078#### `ast.literal_eval(node_or_string)`20792080Вычисляет узел выражения или строку, содержащую только литерал Python или отображение контейнера. Предоставленная строка или узел могут состоять только из следующих структур литералов Python: строки, байты, числа, кортежи, списки, словари, множества, булевы значения, `None` и `Ellipsis`.20812082Это можно использовать для вычисления строк, содержащих значения Python, без необходимости разбирать значения самостоятельно. Он не способен вычислять произвольно сложные выражения, например, с операторами или индексацией.20832084Раньше эта функция документировалась как «безопасная» без определения, что это значит. Это вводило в заблуждение. Она специально разработана так, чтобы не выполнять код Python, в отличие от более общей [`eval()`](https://python-all.ru/3.12/library/functions.html#eval). Нет пространства имён, поиска имён или возможности внешних вызовов. Но она не свободна от атак: относительно небольшой ввод может привести к истощению памяти или истощению стека C, что вызовет сбой процесса. Также существует возможность отказа в обслуживании из-за чрезмерного потребления ЦП на некоторых входных данных. Поэтому вызывать её на недоверенных данных не рекомендуется.20852086> **Предупреждение**2087>2088> Можно вызвать сбой интерпретатора Python из-за ограничений глубины стека в компиляторе AST Python.2089>2090> Она может возбуждать [`ValueError`](https://python-all.ru/3.12/library/exceptions.html#ValueError), [`TypeError`](https://python-all.ru/3.12/library/exceptions.html#TypeError), [`SyntaxError`](https://python-all.ru/3.12/library/exceptions.html#SyntaxError), [`MemoryError`](https://python-all.ru/3.12/library/exceptions.html#MemoryError) и [`RecursionError`](https://python-all.ru/3.12/library/exceptions.html#RecursionError) в зависимости от некорректного ввода.20912092Изменено в версии 3.2: Теперь допускает литералы байтов и множеств.20932094Изменено в версии 3.9: Теперь поддерживает создание пустых множеств с помощью `'set()'`.20952096Изменено в версии 3.10: Для строковых входных данных начальные пробелы и табуляции теперь удаляются.20972098#### `ast.get_docstring(node, clean=True)`20992100Возвращает строку документации для данного *узла* (который должен быть узлом [`FunctionDef`](https://python-all.ru/3.12/library/ast.html#ast.FunctionDef), [`AsyncFunctionDef`](https://python-all.ru/3.12/library/ast.html#ast.AsyncFunctionDef), [`ClassDef`](https://python-all.ru/3.12/library/ast.html#ast.ClassDef) или [`Module`](https://python-all.ru/3.12/library/ast.html#ast.Module)) или `None`, если у него нет строки документации. Если *clean* истинно, очищает отступы строки документации с помощью [`inspect.cleandoc()`](https://python-all.ru/3.12/library/inspect.html#inspect.cleandoc).21012102Изменено в версии 3.5: Теперь поддерживается [`AsyncFunctionDef`](https://python-all.ru/3.12/library/ast.html#ast.AsyncFunctionDef).21032104#### `ast.get_source_segment(source, node, *, padded=False)`21052106Возвращает фрагмент исходного кода из *source*, который породил узел *node*. Если не хватает информации о местоположении ([`lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.lineno), [`end_lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.end_lineno), [`col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.col_offset) или [`end_col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.end_col_offset)), возвращает `None`.21072108Если *padded* равно `True`, первая строка многострочного оператора будет дополнена пробелами, чтобы соответствовать исходной позиции.21092110Добавлено в версии 3.8.21112112#### `ast.fix_missing_locations(node)`21132114При компиляции дерева узлов с помощью [`compile()`](https://python-all.ru/3.12/library/functions.html#compile) компилятор ожидает атрибуты [`lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.lineno) и [`col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.col_offset) для каждого узла, который их поддерживает. Заполнять их вручную для сгенерированных узлов довольно утомительно, поэтому эта вспомогательная функция рекурсивно добавляет эти атрибуты, если их ещё нет, устанавливая их равными значениям родительского узла. Работает рекурсивно, начиная с *node*.21152116#### `ast.increment_lineno(node, n=1)`21172118Увеличивает номер строки и номер конечной строки каждого узла в дереве, начиная с *node*, на *n*. Это полезно для «перемещения кода» в другое место в файле.21192120#### `ast.copy_location(new_node, old_node)`21212122Копирует информацию о местоположении в исходном коде ([`lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.12/library/ast.html#ast.AST.end_col_offset)) из *old\_node* в *new\_node*, если это возможно, и возвращает *new\_node*.21232124#### `ast.iter_fields(node)`21252126Генерирует кортеж из `(fieldname, value)` для каждого поля в `node._fields`, которое присутствует в *node*.21272128#### `ast.iter_child_nodes(node)`21292130Генерирует все непосредственные дочерние узлы *node*, то есть все поля, являющиеся узлами, и все элементы полей, являющихся списками узлов.21312132#### `ast.walk(node)`21332134Рекурсивно генерирует все узлы-потомки в дереве, начиная с *node* (включая сам *node*), в произвольном порядке. Это полезно, если требуется только изменить узлы на месте, а контекст не важен.21352136#### `class ast.NodeVisitor`21372138Базовый класс для обхода узлов, который обходит абстрактное синтаксическое дерево и вызывает функцию-посетитель для каждого найденного узла. Эта функция может вернуть значение, которое передаётся методом [`visit()`](https://python-all.ru/3.12/library/ast.html#ast.NodeVisitor.visit).21392140Этот класс предназначен для наследования; в подклассе добавляются методы-посетители.21412142#### `visit(node)`21432144Посещает узел. Реализация по умолчанию вызывает метод `self.visit_classname`, где *classname* – имя класса узла, или [`generic_visit()`](https://python-all.ru/3.12/library/ast.html#ast.NodeVisitor.generic_visit), если такой метод отсутствует.21452146#### `generic_visit(node)`21472148Этот посетитель вызывает [`visit()`](https://python-all.ru/3.12/library/ast.html#ast.NodeVisitor.visit) для всех дочерних узлов.21492150Обратите внимание, что дочерние узлы тех узлов, для которых определён собственный метод-посетитель, не будут посещены, если посетитель сам не вызовет [`generic_visit()`](https://python-all.ru/3.12/library/ast.html#ast.NodeVisitor.generic_visit) или не обойдёт их самостоятельно.21512152#### `visit_Constant(node)`21532154Обрабатывает все константные узлы.21552156Не используйте [`NodeVisitor`](https://python-all.ru/3.12/library/ast.html#ast.NodeVisitor), если требуется вносить изменения в узлы во время обхода. Для этого существует специальный посетитель ([`NodeTransformer`](https://python-all.ru/3.12/library/ast.html#ast.NodeTransformer)), который допускает модификации.21572158Устарело с версии 3.8: Методы `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` и `visit_Ellipsis()` теперь устарели и не будут вызываться в будущих версиях Python. Добавьте метод [`visit_Constant()`](https://python-all.ru/3.12/library/ast.html#ast.NodeVisitor.visit_Constant) для обработки всех узлов-констант.21592160#### `class ast.NodeTransformer`21612162Подкласс [`NodeVisitor`](https://python-all.ru/3.12/library/ast.html#ast.NodeVisitor), который обходит абстрактное синтаксическое дерево и позволяет изменять узлы.21632164Метод [`NodeTransformer`](https://python-all.ru/3.12/library/ast.html#ast.NodeTransformer) обходит AST и использует возвращаемое значение методов-посетителей для замены или удаления старого узла. Если возвращаемое значение метода-посетителя равно `None`, узел будет удалён из своего местоположения; в противном случае он заменяется возвращённым значением. Возвращённое значение может быть исходным узлом – в этом случае замена не происходит.21652166Вот пример преобразователя, который переписывает все обращения к именам (`foo`) в `data['foo']`:21672168```python2169class RewriteName(NodeTransformer):21702171    def visit_Name(self, node):2172        return Subscript(2173            value=Name(id='data', ctx=Load()),2174            slice=Constant(value=node.id),2175            ctx=node.ctx2176        )2177```21782179Имейте в виду: если у узла, с которым вы работаете, есть дочерние узлы, необходимо либо преобразовать дочерние узлы самостоятельно, либо сначала вызвать для узла метод [`generic_visit()`](https://python-all.ru/3.12/library/ast.html#ast.NodeVisitor.generic_visit).21802181Для узлов, входящих в состав набора инструкций (это относится ко всем узлам инструкций), посетитель может также возвращать список узлов, а не один узел.21822183Если [`NodeTransformer`](https://python-all.ru/3.12/library/ast.html#ast.NodeTransformer) вводит новые узлы (не входившие в исходное дерево) без указания информации о расположении (например, [`lineno`](https://python-all.ru/3.12/library/ast.html#ast.AST.lineno)), следует вызвать [`fix_missing_locations()`](https://python-all.ru/3.12/library/ast.html#ast.fix_missing_locations) для нового поддерева, чтобы пересчитать информацию о расположении:21842185```python2186tree = ast.parse('foo', mode='eval')2187new_tree = fix_missing_locations(RewriteName().visit(tree))2188```21892190Обычно преобразователь используется следующим образом:21912192```python2193node = YourTransformer().visit(node)2194```21952196#### `ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None)`21972198Возвращает форматированный дамп дерева из *node*. Это в основном полезно для отладки. Если *annotate\_fields* равно true (по умолчанию), возвращаемая строка будет показывать имена и значения полей. Если *annotate\_fields* равно false, результирующая строка будет более компактной за счёт опускания однозначных имён полей. Атрибуты, такие как номера строк и смещения столбцов, по умолчанию не выводятся. Если это нужно, *include\_attributes* можно установить в true.21992200Если *indent* – неотрицательное целое число или строка, дерево будет выведено с отступами указанного уровня. Уровень отступа 0, отрицательное значение или `""` вставляет только переводы строк. `None` (по умолчанию) выбирает однострочное представление. Положительный целочисленный отступ добавляет соответствующее количество пробелов на уровень. Если *indent* – строка (например, `"\t"`), эта строка используется для отступа каждого уровня.22012202Изменено в версии 3.9: Добавлена опция *indent*.22032204## Флаги компилятора22052206Следующие флаги могут быть переданы в [`compile()`](https://python-all.ru/3.12/library/functions.html#compile) для изменения эффектов компиляции программы:22072208#### `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`22092210Включает поддержку `await`, `async for`, `async with` и асинхронных включений верхнего уровня.22112212Добавлено в версии 3.8.22132214#### `ast.PyCF_ONLY_AST`22152216Генерирует и возвращает абстрактное синтаксическое дерево вместо скомпилированного объекта кода.22172218#### `ast.PyCF_TYPE_COMMENTS`22192220Включает поддержку комментариев типов в стиле [**PEP 484**](https://python-all.ru/3.12/library/ast.html) и [**PEP 526**](https://python-all.ru/3.12/library/ast.html) (`# type: <type>`, `# type: ignore <stuff>`).22212222Добавлено в версии 3.8.22232224## Использование командной строки22252226Добавлено в версии 3.9.22272228Модуль [`ast`](https://python-all.ru/3.12/library/ast.html#module-ast) может быть выполнен как скрипт из командной строки. Это просто:22292230```sh2231python -m ast [-m <mode>] [-a] [infile]2232```22332234Принимаются следующие опции:22352236#### `-h, --help`22372238Показать справку и выйти.22392240#### `-m <mode>`22412242#### `--mode <mode>`22432244Определяет, какой вид кода должен быть скомпилирован, как аргумент *mode* в [`parse()`](https://python-all.ru/3.12/library/ast.html#ast.parse).22452246#### `--no-type-comments`22472248Не обрабатывать комментарии типов.22492250#### `-a, --include-attributes`22512252Включать атрибуты, такие как номера строк и смещения столбцов.22532254#### `-i <indent>`22552256#### `--indent <indent>`22572258Отступ узлов в AST (количество пробелов).22592260Если указан `infile`, его содержимое разбирается в AST и выводится в stdout. В противном случае содержимое читается из stdin.22612262> **См. также**2263>2264> [Green Tree Snakes](https://python-all.ru/3.12/library/ast.html) – внешний документационный ресурс, содержащий подробности работы с AST Python.2265>2266> [ASTTokens](https://python-all.ru/3.12/library/ast.html) дополняет AST Python позициями токенов и текста в исходном коде, который их породил. Это полезно для инструментов, выполняющих преобразования исходного кода.2267>2268> [leoAst.py](https://python-all.ru/3.12/library/ast.html) объединяет токен-ориентированное и синтаксическое представление программ Python, вставляя двунаправленные связи между токенами и узлами AST.2269>2270> [LibCST](https://python-all.ru/3.12/library/ast.html) разбирает код как конкретное синтаксическое дерево, похожее на AST, и сохраняет все детали форматирования. Это полезно для создания приложений автоматического рефакторинга (codemod) и линтеров.2271>2272> [Parso](https://python-all.ru/3.12/library/ast.html) – это парсер Python, поддерживающий восстановление после ошибок и сквозной разбор для разных версий Python (в нескольких версиях Python). Parso также может выводить несколько синтаксических ошибок в вашем файле Python.2273