ast.md

1> **Источник:** https://python-all.ru/3.11/library/ast.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# [`ast`](https://python-all.ru/3.11/library/ast.html#module-ast) – абстрактные синтаксические деревья89**Исходный код:** [Lib/ast.py](https://python-all.ru/src/3.11/Lib/ast.py)1011---1213Модуль [`ast`](https://python-all.ru/3.11/library/ast.html#module-ast) помогает приложениям Python обрабатывать деревья абстрактного синтаксиса языка Python. Абстрактный синтаксис может меняться от версии к версии; с помощью этого модуля можно программно узнать, как выглядит текущая грамматика.1415Абстрактное синтаксическое дерево можно создать, передав [`ast.PyCF_ONLY_AST`](https://python-all.ru/3.11/library/ast.html#ast.PyCF_ONLY_AST) в качестве флага встроенной функции [`compile()`](https://python-all.ru/3.11/library/functions.html#compile) или используя вспомогательную функцию [`parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse) из этого модуля. Результатом будет дерево объектов, классы которых наследуют от [`ast.AST`](https://python-all.ru/3.11/library/ast.html#ast.AST). Абстрактное синтаксическое дерево можно скомпилировать в объект кода Python с помощью встроенной функции [`compile()`](https://python-all.ru/3.11/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)35          | AsyncFunctionDef(identifier name, arguments args,36                             stmt* body, expr* decorator_list, expr? returns,37                             string? type_comment)3839          | ClassDef(identifier name,40             expr* bases,41             keyword* keywords,42             stmt* body,43             expr* decorator_list)44          | Return(expr? value)4546          | Delete(expr* targets)47          | Assign(expr* targets, expr value, string? type_comment)48          | AugAssign(expr target, operator op, expr value)49          -- 'simple' указывает, что аннотируется простое имя без скобок50          | AnnAssign(expr target, expr annotation, expr? value, int simple)5152          -- используется 'orelse', так как else – ключевое слово в целевых языках53          | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)54          | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)55          | While(expr test, stmt* body, stmt* orelse)56          | If(expr test, stmt* body, stmt* orelse)57          | With(withitem* items, stmt* body, string? type_comment)58          | AsyncWith(withitem* items, stmt* body, string? type_comment)5960          | Match(expr subject, match_case* cases)6162          | Raise(expr? exc, expr? cause)63          | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)64          | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)65          | Assert(expr test, expr? msg)6667          | Import(alias* names)68          | ImportFrom(identifier? module, alias* names, int? level)6970          | Global(identifier* names)71          | Nonlocal(identifier* names)72          | Expr(expr value)73          | Pass | Break | Continue7475          -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером76          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)7778          -- BoolOp() может использовать left и right?79    expr = BoolOp(boolop op, expr* values)80         | NamedExpr(expr target, expr value)81         | BinOp(expr left, operator op, expr right)82         | UnaryOp(unaryop op, expr operand)83         | Lambda(arguments args, expr body)84         | IfExp(expr test, expr body, expr orelse)85         | Dict(expr* keys, expr* values)86         | Set(expr* elts)87         | ListComp(expr elt, comprehension* generators)88         | SetComp(expr elt, comprehension* generators)89         | DictComp(expr key, expr value, comprehension* generators)90         | GeneratorExp(expr elt, comprehension* generators)91         -- грамматика ограничивает, где могут встречаться выражения yield92         | Await(expr value)93         | Yield(expr? value)94         | YieldFrom(expr value)95         -- нужны последовательности для сравнения, чтобы различать96         -- x < 4 < 3 and (x < 4) < 397         | Compare(expr left, cmpop* ops, expr* comparators)98         | Call(expr func, expr* args, keyword* keywords)99         | FormattedValue(expr value, int conversion, expr? format_spec)100         | JoinedStr(expr* values)101         | Constant(constant value, string? kind)102103         -- следующее выражение может появляться в контексте присваивания104         | Attribute(expr value, identifier attr, expr_context ctx)105         | Subscript(expr value, expr slice, expr_context ctx)106         | Starred(expr value, expr_context ctx)107         | Name(identifier id, expr_context ctx)108         | List(expr* elts, expr_context ctx)109         | Tuple(expr* elts, expr_context ctx)110111         -- может встречаться только в Subscript112         | Slice(expr? lower, expr? upper, expr? step)113114          -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером115          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)116117    expr_context = Load | Store | Del118119    boolop = And | Or120121    operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift122                 | RShift | BitOr | BitXor | BitAnd | FloorDiv123124    unaryop = Invert | Not | UAdd | USub125126    cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn127128    comprehension = (expr target, expr iter, expr* ifs, int is_async)129130    excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)131                    attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)132133    arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,134                 expr* kw_defaults, arg? kwarg, expr* defaults)135136    arg = (identifier arg, expr? annotation, string? type_comment)137           attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)138139    -- ключевые аргументы, переданные вызову (идентификатор NULL для **kwargs)140    keyword = (identifier? arg, expr value)141               attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)142143    -- имя импорта с необязательным псевдонимом 'as'144    alias = (identifier name, identifier? asname)145             attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)146147    withitem = (expr context_expr, expr? optional_vars)148149    match_case = (pattern pattern, expr? guard, stmt* body)150151    pattern = MatchValue(expr value)152            | MatchSingleton(constant value)153            | MatchSequence(pattern* patterns)154            | MatchMapping(expr* keys, pattern* patterns, identifier? rest)155            | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)156157            | MatchStar(identifier? name)158            -- необязательный параметр "rest" MatchMapping обрабатывает захват дополнительных ключей отображения159160            | MatchAs(pattern? pattern, identifier? name)161            | MatchOr(pattern* patterns)162163             attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)164165    type_ignore = TypeIgnore(int lineno, string tag)166}167```168169## Классы узлов170171#### `class ast.AST`172173Это базовый класс для всех узлов AST. Реальные классы узлов унаследованы из файла `Parser/Python.asdl`, который воспроизведён [выше](https://python-all.ru/3.11/library/ast.html#abstract-grammar). Они определены в C-модуле `_ast` и повторно экспортируются в [`ast`](https://python-all.ru/3.11/library/ast.html#module-ast).174175Для каждого символа левой части абстрактной грамматики определён один класс (например, `ast.stmt` или `ast.expr`). Кроме того, для каждого конструктора правой части определён один класс; эти классы наследуют от классов для деревьев левой части. Например, [`ast.BinOp`](https://python-all.ru/3.11/library/ast.html#ast.BinOp) наследует от `ast.expr`. Для продукционных правил с альтернативами (так называемых «сумм») класс левой части является абстрактным: создаются только экземпляры конкретных узлов-конструкторов.176177#### `_fields`178179Каждый конкретный класс имеет атрибут [`_fields`](https://python-all.ru/3.11/library/ast.html#ast.AST._fields), который содержит имена всех дочерних узлов.180181Каждый экземпляр конкретного класса имеет по одному атрибуту для каждого дочернего узла, тип которого определён в грамматике. Например, экземпляры [`ast.BinOp`](https://python-all.ru/3.11/library/ast.html#ast.BinOp) имеют атрибут `left` типа `ast.expr`.182183Если эти атрибуты помечены как необязательные в грамматике (с помощью вопросительного знака), значением может быть `None`. Если атрибуты могут иметь ноль или более значений (помечены звёздочкой), значения представляются в виде списков Python. Все возможные атрибуты должны присутствовать и иметь корректные значения при компиляции AST с помощью [`compile()`](https://python-all.ru/3.11/library/functions.html#compile).184185#### `lineno`186187#### `col_offset`188189#### `end_lineno`190191#### `end_col_offset`192193Экземпляры подклассов `ast.expr` и `ast.stmt` имеют атрибуты [`lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.end_col_offset). Атрибуты [`lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.lineno) и [`end_lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.end_lineno) – это номер первой и последней строки исходного текста (нумерация с 1, то есть первая строка – строка 1), а [`col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.col_offset) и [`end_col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.end_col_offset) – соответствующие смещения в байтах UTF-8 от первого и последнего токенов, породивших узел. Смещение UTF-8 записывается, потому что парсер использует UTF-8 внутри.194195Обратите внимание, что конечные позиции не требуются компилятором и поэтому являются необязательными. Смещение конца находится *после* последнего символа, например, можно получить фрагмент исходного кода узла выражения из одной строки с помощью `source_line[node.col_offset : node.end_col_offset]`.196197Конструктор класса `ast.T` разбирает свои аргументы следующим образом:198199- Если есть позиционные аргументы, их должно быть столько же, сколько элементов в `T._fields`; они будут присвоены как атрибуты с этими именами.200- Если есть ключевые аргументы, они установят атрибуты с теми же именами в указанные значения.201202Например, чтобы создать и заполнить узел [`ast.UnaryOp`](https://python-all.ru/3.11/library/ast.html#ast.UnaryOp), можно использовать203204```python205node = ast.UnaryOp()206node.op = ast.USub()207node.operand = ast.Constant()208node.operand.value = 5209node.operand.lineno = 0210node.operand.col_offset = 0211node.lineno = 0212node.col_offset = 0213```214215или более компактный216217```python218node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),219                   lineno=0, col_offset=0)220```221222Изменено в версии 3.8: Класс [`ast.Constant`](https://python-all.ru/3.11/library/ast.html#ast.Constant) теперь используется для всех констант.223224Изменено в версии 3.9: Простые индексы представляются своим значением, расширенные срезы представляются кортежами.225226Устарело с версии 3.8: Старые классы `ast.Num`, `ast.Str`, `ast.Bytes`, `ast.NameConstant` и `ast.Ellipsis` всё ещё доступны, но будут удалены в будущих версиях Python. А пока их создание будет возвращать экземпляр другого класса.227228Устарело с версии 3.9: Старые классы `ast.Index` и `ast.ExtSlice` всё ещё доступны, но будут удалены в будущих выпусках Python. При этом при их создании будет возвращён экземпляр другого класса.229230> **Примечание**231>232> Описания конкретных классов узлов, приведённые здесь, изначально были адаптированы из замечательного проекта [Green Tree Snakes](https://python-all.ru/3.11/library/ast.html) и всех его участников.233234### Корневые узлы235236#### `class ast.Module(body, type_ignores)`237238A Python module, as with [file input](https://python-all.ru/3.11/reference/toplevel_components.html#file-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse) in the default `"exec"` *mode*.239240*body* – это [`list`](https://python-all.ru/3.11/library/stdtypes.html#list) из [Statements](https://python-all.ru/3.11/library/ast.html#ast-statements) модуля.241242*type\_ignores* – это [`list`](https://python-all.ru/3.11/library/stdtypes.html#list) комментариев type ignore модуля; подробнее см. [`ast.parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse).243244```pycon245>>> print(ast.dump(ast.parse('x = 1'), indent=4))246Module(247    body=[248        Assign(249            targets=[250                Name(id='x', ctx=Store())],251            value=Constant(value=1))],252    type_ignores=[])253```254255#### `class ast.Expression(body)`256257A single Python [expression input](https://python-all.ru/3.11/reference/toplevel_components.html#expression-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse) when *mode* is `"eval"`.258259*body* – это один узел, один из [типов выражений](https://python-all.ru/3.11/library/ast.html#ast-expressions).260261```pycon262>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))263Expression(264    body=Constant(value=123))265```266267#### `class ast.Interactive(body)`268269A single [interactive input](https://python-all.ru/3.11/reference/toplevel_components.html#interactive), like in [Interactive Mode](https://python-all.ru/3.11/tutorial/appendix.html#tut-interac). Node type generated by [`ast.parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse) when *mode* is `"single"`.270271*body* – это [`list`](https://python-all.ru/3.11/library/stdtypes.html#list) [узлов инструкций](https://python-all.ru/3.11/library/ast.html#ast-statements).272273```pycon274>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))275Interactive(276    body=[277        Assign(278            targets=[279                Name(id='x', ctx=Store())],280            value=Constant(value=1)),281        Assign(282            targets=[283                Name(id='y', ctx=Store())],284            value=Constant(value=2))])285```286287#### `class ast.FunctionType(argtypes, returns)`288289A 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.11/library/ast.html) annotations. Node type generated by [`ast.parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse) when *mode* is `"func_type"`.290291Такие комментарии о типах выглядели следующим образом:292293```python294def sum_two_number(a, b):295    # type: (int, int) -> int296    return a + b297```298299*argtypes* – это [`list`](https://python-all.ru/3.11/library/stdtypes.html#list) [узлов выражений](https://python-all.ru/3.11/library/ast.html#ast-expressions).300301*returns* – это один [узел выражения](https://python-all.ru/3.11/library/ast.html#ast-expressions).302303```pycon304>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))305FunctionType(306    argtypes=[307        Name(id='int', ctx=Load()),308        Name(id='str', ctx=Load())],309    returns=Subscript(310        value=Name(id='List', ctx=Load()),311        slice=Name(id='int', ctx=Load()),312        ctx=Load()))313```314315Новое в версии 3.8.316317### Литералы318319#### `class ast.Constant(value)`320321Постоянное значение. Атрибут `value` литерала `Constant` содержит объект Python, который он представляет. Представленные значения могут быть простыми типами, такими как число, строка или `None`, а также неизменяемыми контейнерными типами (кортежами и замороженными множествами), если все их элементы постоянны.322323```pycon324>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))325Expression(326    body=Constant(value=123))327```328329#### `class ast.FormattedValue(value, conversion, format_spec)`330331Узел, представляющий одно поле форматирования в f-строке. Если строка содержит только одно поле форматирования и больше ничего, узел может быть изолированным; в противном случае он встречается внутри [`JoinedStr`](https://python-all.ru/3.11/library/ast.html#ast.JoinedStr).332333- `value` – это любой узел выражения (например, литерал, переменная или вызов функции).334- `conversion` – целое число:335336  - -1: без форматирования337  - 115: `!s` форматирование строк338  - 114: `!r` форматирование repr339  - 97: `!a` форматирование ascii340- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.11/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно.341342#### `class ast.JoinedStr(values)`343344F-строка, содержащая последовательность [`FormattedValue`](https://python-all.ru/3.11/library/ast.html#ast.FormattedValue) и [`Constant`](https://python-all.ru/3.11/library/ast.html#ast.Constant) узлов.345346```pycon347>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))348Expression(349    body=JoinedStr(350        values=[351            Constant(value='sin('),352            FormattedValue(353                value=Name(id='a', ctx=Load()),354                conversion=-1),355            Constant(value=') is '),356            FormattedValue(357                value=Call(358                    func=Name(id='sin', ctx=Load()),359                    args=[360                        Name(id='a', ctx=Load())],361                    keywords=[]),362                conversion=-1,363                format_spec=JoinedStr(364                    values=[365                        Constant(value='.3')]))]))366```367368#### `class ast.List(elts, ctx)`369370#### `class ast.Tuple(elts, ctx)`371372Список или кортеж. `elts` содержит список узлов, представляющих элементы. `ctx` равен [`Store`](https://python-all.ru/3.11/library/ast.html#ast.Store), если контейнер является целью присваивания (т.е. `(x,y)=something`), и [`Load`](https://python-all.ru/3.11/library/ast.html#ast.Load) в противном случае.373374```pycon375>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))376Expression(377    body=List(378        elts=[379            Constant(value=1),380            Constant(value=2),381            Constant(value=3)],382        ctx=Load()))383>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))384Expression(385    body=Tuple(386        elts=[387            Constant(value=1),388            Constant(value=2),389            Constant(value=3)],390        ctx=Load()))391```392393#### `class ast.Set(elts)`394395Множество. `elts` содержит список узлов, представляющих элементы множества.396397```pycon398>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))399Expression(400    body=Set(401        elts=[402            Constant(value=1),403            Constant(value=2),404            Constant(value=3)]))405```406407#### `class ast.Dict(keys, values)`408409Словарь. `keys` и `values` содержат списки узлов, представляющих ключи и значения соответственно, в соответствующем порядке (то, что было бы возвращено при вызове `dictionary.keys()` и `dictionary.values()`).410411При распаковке словаря с помощью литералов словаря выражение, которое нужно раскрыть, помещается в список `values`, а `None` – на соответствующую позицию в `keys`.412413```pycon414>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))415Expression(416    body=Dict(417        keys=[418            Constant(value='a'),419            None],420        values=[421            Constant(value=1),422            Name(id='d', ctx=Load())]))423```424425### Переменные426427#### `class ast.Name(id, ctx)`428429Имя переменной. `id` содержит имя в виде строки, а `ctx` – один из следующих типов.430431#### `class ast.Load`432433#### `class ast.Store`434435#### `class ast.Del`436437Ссылки на переменные можно использовать для загрузки значения переменной, для присваивания ей нового значения или для её удаления. Ссылки на переменные получают контекст, чтобы различать эти случаи.438439```pycon440>>> print(ast.dump(ast.parse('a'), indent=4))441Module(442    body=[443        Expr(444            value=Name(id='a', ctx=Load()))],445    type_ignores=[])446447>>> print(ast.dump(ast.parse('a = 1'), indent=4))448Module(449    body=[450        Assign(451            targets=[452                Name(id='a', ctx=Store())],453            value=Constant(value=1))],454    type_ignores=[])455456>>> print(ast.dump(ast.parse('del a'), indent=4))457Module(458    body=[459        Delete(460            targets=[461                Name(id='a', ctx=Del())])],462    type_ignores=[])463```464465#### `class ast.Starred(value, ctx)`466467Ссылка на переменную `*var`. В `value` хранится переменная, обычно узел [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name). Этот тип необходимо использовать при построении узла [`Call`](https://python-all.ru/3.11/library/ast.html#ast.Call) с помощью `*args`.468469```pycon470>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))471Module(472    body=[473        Assign(474            targets=[475                Tuple(476                    elts=[477                        Name(id='a', ctx=Store()),478                        Starred(479                            value=Name(id='b', ctx=Store()),480                            ctx=Store())],481                    ctx=Store())],482            value=Name(id='it', ctx=Load()))],483    type_ignores=[])484```485486### Выражения487488#### `class ast.Expr(value)`489490Когда выражение, например вызов функции, выступает в роли самостоятельного оператора и его возвращаемое значение не используется и не сохраняется, оно помещается в этот контейнер. `value` содержит один из остальных узлов этого раздела: узел [`Constant`](https://python-all.ru/3.11/library/ast.html#ast.Constant), узел [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name), [`Lambda`](https://python-all.ru/3.11/library/ast.html#ast.Lambda), [`Yield`](https://python-all.ru/3.11/library/ast.html#ast.Yield) или [`YieldFrom`](https://python-all.ru/3.11/library/ast.html#ast.YieldFrom).491492```pycon493>>> print(ast.dump(ast.parse('-a'), indent=4))494Module(495    body=[496        Expr(497            value=UnaryOp(498                op=USub(),499                operand=Name(id='a', ctx=Load())))],500    type_ignores=[])501```502503#### `class ast.UnaryOp(op, operand)`504505Унарная операция. `op` – оператор, а `operand` – любой узел выражения.506507#### `class ast.UAdd`508509#### `class ast.USub`510511#### `class ast.Not`512513#### `class ast.Invert`514515Токены унарных операторов. [`Not`](https://python-all.ru/3.11/library/ast.html#ast.Not) – ключевое слово `not`, [`Invert`](https://python-all.ru/3.11/library/ast.html#ast.Invert) – оператор `~`.516517```pycon518>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))519Expression(520    body=UnaryOp(521        op=Not(),522        operand=Name(id='x', ctx=Load())))523```524525#### `class ast.BinOp(left, op, right)`526527Бинарная операция (например, сложение или деление). `op` – оператор, а `left` и `right` – любые узлы выражений.528529```pycon530>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))531Expression(532    body=BinOp(533        left=Name(id='x', ctx=Load()),534        op=Add(),535        right=Name(id='y', ctx=Load())))536```537538#### `class ast.Add`539540#### `class ast.Sub`541542#### `class ast.Mult`543544#### `class ast.Div`545546#### `class ast.FloorDiv`547548#### `class ast.Mod`549550#### `class ast.Pow`551552#### `class ast.LShift`553554#### `class ast.RShift`555556#### `class ast.BitOr`557558#### `class ast.BitXor`559560#### `class ast.BitAnd`561562#### `class ast.MatMult`563564Токены бинарных операторов.565566#### `class ast.BoolOp(op, values)`567568Логическая операция – 'or' или 'and'. `op` – это [`Or`](https://python-all.ru/3.11/library/ast.html#ast.Or) или [`And`](https://python-all.ru/3.11/library/ast.html#ast.And). `values` – участвующие значения. Последовательные операции с одним и тем же оператором, например `a or b or c`, сводятся в один узел с несколькими значениями.569570Это не включает `not`, который является [`UnaryOp`](https://python-all.ru/3.11/library/ast.html#ast.UnaryOp).571572```pycon573>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))574Expression(575    body=BoolOp(576        op=Or(),577        values=[578            Name(id='x', ctx=Load()),579            Name(id='y', ctx=Load())]))580```581582#### `class ast.And`583584#### `class ast.Or`585586Токены логических операторов.587588#### `class ast.Compare(left, ops, comparators)`589590Сравнение двух или более значений. `left` – первое значение в сравнении, `ops` – список операторов, а `comparators` – список значений после первого элемента сравнения.591592```pycon593>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))594Expression(595    body=Compare(596        left=Constant(value=1),597        ops=[598            LtE(),599            Lt()],600        comparators=[601            Name(id='a', ctx=Load()),602            Constant(value=10)]))603```604605#### `class ast.Eq`606607#### `class ast.NotEq`608609#### `class ast.Lt`610611#### `class ast.LtE`612613#### `class ast.Gt`614615#### `class ast.GtE`616617#### `class ast.Is`618619#### `class ast.IsNot`620621#### `class ast.In`622623#### `class ast.NotIn`624625Токены операторов сравнения.626627#### `class ast.Call(func, args, keywords)`628629Вызов функции. `func` – это функция; обычно это объект [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name) или [`Attribute`](https://python-all.ru/3.11/library/ast.html#ast.Attribute). Об аргументах:630631- `args` содержит список аргументов, переданных по позиции.632- `keywords` содержит список объектов [`keyword`](https://python-all.ru/3.11/library/ast.html#ast.keyword), представляющих аргументы, переданные по ключевому слову.633634При создании узла `Call` обязательны `args` и `keywords`, но они могут быть пустыми списками.635636```pycon637>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))638Expression(639    body=Call(640        func=Name(id='func', ctx=Load()),641        args=[642            Name(id='a', ctx=Load()),643            Starred(644                value=Name(id='d', ctx=Load()),645                ctx=Load())],646        keywords=[647            keyword(648                arg='b',649                value=Name(id='c', ctx=Load())),650            keyword(651                value=Name(id='e', ctx=Load()))]))652```653654#### `class ast.keyword(arg, value)`655656Именованный аргумент вызова функции или определения класса. `arg` – это необработанная строка с именем параметра, `value` – узел, который нужно передать.657658#### `class ast.IfExp(test, body, orelse)`659660Выражение, например `a if b else c`. Каждое поле содержит один узел, поэтому в следующем примере все три являются узлами [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name).661662```pycon663>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))664Expression(665    body=IfExp(666        test=Name(id='b', ctx=Load()),667        body=Name(id='a', ctx=Load()),668        orelse=Name(id='c', ctx=Load())))669```670671#### `class ast.Attribute(value, attr, ctx)`672673Доступ к атрибуту, например `d.keys`. `value` – это узел, обычно [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name). `attr` – это строка с именем атрибута, а `ctx` – [`Load`](https://python-all.ru/3.11/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.11/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.11/library/ast.html#ast.Del) в зависимости от того, как используется атрибут.674675```pycon676>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))677Expression(678    body=Attribute(679        value=Name(id='snake', ctx=Load()),680        attr='colour',681        ctx=Load()))682```683684#### `class ast.NamedExpr(target, value)`685686> Именованное выражение. Этот узел AST создаётся оператором присваивания (также известным как оператор «морж»). В отличие от узла [`Assign`](https://python-all.ru/3.11/library/ast.html#ast.Assign), где первый аргумент может быть несколькими узлами, в данном случае и `target`, и `value` должны быть одиночными узлами.687688```pycon689>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))690Expression(691    body=NamedExpr(692        target=Name(id='x', ctx=Store()),693        value=Constant(value=4)))694```695696#### Индексирование697698#### `class ast.Subscript(value, slice, ctx)`699700Индексация, такая как `l[1]`. `value` – индексируемый объект (обычно последовательность или отображение). `slice` – это индекс, срез или ключ. Оно может быть [`Tuple`](https://python-all.ru/3.11/library/ast.html#ast.Tuple) и содержать [`Slice`](https://python-all.ru/3.11/library/ast.html#ast.Slice). `ctx` является [`Load`](https://python-all.ru/3.11/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.11/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.11/library/ast.html#ast.Del) в зависимости от выполняемого действия при индексации.701702```pycon703>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))704Expression(705    body=Subscript(706        value=Name(id='l', ctx=Load()),707        slice=Tuple(708            elts=[709                Slice(710                    lower=Constant(value=1),711                    upper=Constant(value=2)),712                Constant(value=3)],713            ctx=Load()),714        ctx=Load()))715```716717#### `class ast.Slice(lower, upper, step)`718719Обычный срез (в виде `lower:upper` или `lower:upper:step`). Может встречаться только внутри поля *slice* узла [`Subscript`](https://python-all.ru/3.11/library/ast.html#ast.Subscript), либо напрямую, либо как элемент [`Tuple`](https://python-all.ru/3.11/library/ast.html#ast.Tuple).720721```pycon722>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))723Expression(724    body=Subscript(725        value=Name(id='l', ctx=Load()),726        slice=Slice(727            lower=Constant(value=1),728            upper=Constant(value=2)),729        ctx=Load()))730```731732#### Генераторы коллекций733734#### `class ast.ListComp(elt, generators)`735736#### `class ast.SetComp(elt, generators)`737738#### `class ast.GeneratorExp(elt, generators)`739740#### `class ast.DictComp(key, value, generators)`741742Генераторы списков и множеств, генераторные выражения и генераторы словарей. `elt` (или `key` и `value`) – это один узел, представляющий часть, которая будет вычисляться для каждого элемента.743744`generators` – это список узлов [`comprehension`](https://python-all.ru/3.11/library/ast.html#ast.comprehension).745746```pycon747>>> print(ast.dump(ast.parse('[x for x in numbers]', mode='eval'), indent=4))748Expression(749    body=ListComp(750        elt=Name(id='x', ctx=Load()),751        generators=[752            comprehension(753                target=Name(id='x', ctx=Store()),754                iter=Name(id='numbers', ctx=Load()),755                ifs=[],756                is_async=0)]))757>>> print(ast.dump(ast.parse('{x: x**2 for x in numbers}', mode='eval'), indent=4))758Expression(759    body=DictComp(760        key=Name(id='x', ctx=Load()),761        value=BinOp(762            left=Name(id='x', ctx=Load()),763            op=Pow(),764            right=Constant(value=2)),765        generators=[766            comprehension(767                target=Name(id='x', ctx=Store()),768                iter=Name(id='numbers', ctx=Load()),769                ifs=[],770                is_async=0)]))771>>> print(ast.dump(ast.parse('{x for x in numbers}', mode='eval'), indent=4))772Expression(773    body=SetComp(774        elt=Name(id='x', ctx=Load()),775        generators=[776            comprehension(777                target=Name(id='x', ctx=Store()),778                iter=Name(id='numbers', ctx=Load()),779                ifs=[],780                is_async=0)]))781```782783#### `class ast.comprehension(target, iter, ifs, is_async)`784785Одно предложение `for` в генераторе коллекции. `target` – это ссылка, используемая для каждого элемента (обычно узел [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name) или [`Tuple`](https://python-all.ru/3.11/library/ast.html#ast.Tuple)). `iter` – объект, по которому выполняется итерация. `ifs` – список проверочных выражений: каждое предложение `for` может содержать несколько `ifs`.786787`is_async` указывает, что генератор коллекции является асинхронным (использует `async for` вместо `for`). Значение – целое число (0 или 1).788789```pycon790>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),791...                indent=4)) # несколько включений в одном792Expression(793    body=ListComp(794        elt=Call(795            func=Name(id='ord', ctx=Load()),796            args=[797                Name(id='c', ctx=Load())],798            keywords=[]),799        generators=[800            comprehension(801                target=Name(id='line', ctx=Store()),802                iter=Name(id='file', ctx=Load()),803                ifs=[],804                is_async=0),805            comprehension(806                target=Name(id='c', ctx=Store()),807                iter=Name(id='line', ctx=Load()),808                ifs=[],809                is_async=0)]))810811>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),812...                indent=4)) # выражение-генератор813Expression(814    body=GeneratorExp(815        elt=BinOp(816            left=Name(id='n', ctx=Load()),817            op=Pow(),818            right=Constant(value=2)),819        generators=[820            comprehension(821                target=Name(id='n', ctx=Store()),822                iter=Name(id='it', ctx=Load()),823                ifs=[824                    Compare(825                        left=Name(id='n', ctx=Load()),826                        ops=[827                            Gt()],828                        comparators=[829                            Constant(value=5)]),830                    Compare(831                        left=Name(id='n', ctx=Load()),832                        ops=[833                            Lt()],834                        comparators=[835                            Constant(value=10)])],836                is_async=0)]))837838>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),839...                indent=4)) # асинхронное включение840Expression(841    body=ListComp(842        elt=Name(id='i', ctx=Load()),843        generators=[844            comprehension(845                target=Name(id='i', ctx=Store()),846                iter=Name(id='soc', ctx=Load()),847                ifs=[],848                is_async=1)]))849```850851### Инструкции852853#### `class ast.Assign(targets, value, type_comment)`854855Присваивание. `targets` – список узлов, а `value` – один узел.856857Несколько узлов в `targets` обозначают присваивание одного и того же значения каждому. Распаковка представляется помещением узла [`Tuple`](https://python-all.ru/3.11/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.11/library/ast.html#ast.List) внутрь `targets`.858859#### `type_comment`860861`type_comment` – это необязательная строка с аннотацией типа в виде комментария.862863```pycon864>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # множественное присваивание865Module(866    body=[867        Assign(868            targets=[869                Name(id='a', ctx=Store()),870                Name(id='b', ctx=Store())],871            value=Constant(value=1))],872    type_ignores=[])873874>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # распаковка875Module(876    body=[877        Assign(878            targets=[879                Tuple(880                    elts=[881                        Name(id='a', ctx=Store()),882                        Name(id='b', ctx=Store())],883                    ctx=Store())],884            value=Name(id='c', ctx=Load()))],885    type_ignores=[])886```887888#### `class ast.AnnAssign(target, annotation, value, simple)`889890Присваивание с аннотацией типа. `target` – это один узел, которым может быть [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.11/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.11/library/ast.html#ast.Subscript). `annotation` – это аннотация, например узел [`Constant`](https://python-all.ru/3.11/library/ast.html#ast.Constant) или [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name). `value` – единственный необязательный узел. `simple` – целое число-флаг, равное True для узла [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name) в `target`, которые не появляются в круглых скобках и поэтому являются чистыми именами, а не выражениями.891892```pycon893>>> print(ast.dump(ast.parse('c: int'), indent=4))894Module(895    body=[896        AnnAssign(897            target=Name(id='c', ctx=Store()),898            annotation=Name(id='int', ctx=Load()),899            simple=1)],900    type_ignores=[])901902>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # аннотация со скобками903Module(904    body=[905        AnnAssign(906            target=Name(id='a', ctx=Store()),907            annotation=Name(id='int', ctx=Load()),908            value=Constant(value=1),909            simple=0)],910    type_ignores=[])911912>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # аннотация атрибута913Module(914    body=[915        AnnAssign(916            target=Attribute(917                value=Name(id='a', ctx=Load()),918                attr='b',919                ctx=Store()),920            annotation=Name(id='int', ctx=Load()),921            simple=0)],922    type_ignores=[])923924>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # аннотация подписки925Module(926    body=[927        AnnAssign(928            target=Subscript(929                value=Name(id='a', ctx=Load()),930                slice=Constant(value=1),931                ctx=Store()),932            annotation=Name(id='int', ctx=Load()),933            simple=0)],934    type_ignores=[])935```936937#### `class ast.AugAssign(target, op, value)`938939Расширенное присваивание, например `a += 1`. В следующем примере `target` – это узел [Имя](https://python-all.ru/3.11/library/ast.html#ast.Name) для `x` (с контекстом [`Store`](https://python-all.ru/3.11/library/ast.html#ast.Store)), `op` – это [Сложение](https://python-all.ru/3.11/library/ast.html#ast.Add), а `value` – это [Константа](https://python-all.ru/3.11/library/ast.html#ast.Constant) со значением 1.940941Атрибут `target` не может быть класса [`Tuple`](https://python-all.ru/3.11/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.11/library/ast.html#ast.List), в отличие от целей [`Assign`](https://python-all.ru/3.11/library/ast.html#ast.Assign).942943```pycon944>>> print(ast.dump(ast.parse('x += 2'), indent=4))945Module(946    body=[947        AugAssign(948            target=Name(id='x', ctx=Store()),949            op=Add(),950            value=Constant(value=2))],951    type_ignores=[])952```953954#### `class ast.Raise(exc, cause)`955956Инструкция `raise`. `exc` – объект исключения, который необходимо возбудить, обычно [Вызов](https://python-all.ru/3.11/library/ast.html#ast.Call) или [Имя](https://python-all.ru/3.11/library/ast.html#ast.Name), или `None` для отдельного `raise`. `cause` – необязательная часть для `y` в `Возбуждение`.957958```pycon959>>> print(ast.dump(ast.parse('raise x from y'), indent=4))960Module(961    body=[962        Raise(963            exc=Name(id='x', ctx=Load()),964            cause=Name(id='y', ctx=Load()))],965    type_ignores=[])966```967968#### `class ast.Assert(test, msg)`969970Утверждение. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.11/library/ast.html#ast.Compare). `msg` содержит сообщение об ошибке.971972```pycon973>>> print(ast.dump(ast.parse('assert x,y'), indent=4))974Module(975    body=[976        Assert(977            test=Name(id='x', ctx=Load()),978            msg=Name(id='y', ctx=Load()))],979    type_ignores=[])980```981982#### `class ast.Delete(targets)`983984Представляет инструкцию `del`. `targets` – список узлов, например узлов [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.11/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.11/library/ast.html#ast.Subscript).985986```pycon987>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))988Module(989    body=[990        Delete(991            targets=[992                Name(id='x', ctx=Del()),993                Name(id='y', ctx=Del()),994                Name(id='z', ctx=Del())])],995    type_ignores=[])996```997998#### `class ast.Pass`9991000Инструкция `pass`.10011002```pycon1003>>> print(ast.dump(ast.parse('pass'), indent=4))1004Module(1005    body=[1006        Pass()],1007    type_ignores=[])1008```10091010Другие инструкции, которые применимы только внутри функций или циклов, описаны в других разделах.10111012#### Импорты10131014#### `class ast.Import(names)`10151016Инструкция импорта. `names` – это список узлов [`alias`](https://python-all.ru/3.11/library/ast.html#ast.alias).10171018```pycon1019>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))1020Module(1021    body=[1022        Import(1023            names=[1024                alias(name='x'),1025                alias(name='y'),1026                alias(name='z')])],1027    type_ignores=[])1028```10291030#### `class ast.ImportFrom(module, names, level)`10311032Представляет `from x import y`. `module` – это необработанная строка имени from, без начальных точек, или `None` для инструкций вроде `from . import foo`. `level` – целое число, указывающее уровень относительного импорта (0 означает абсолютный импорт).10331034```pycon1035>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))1036Module(1037    body=[1038        ImportFrom(1039            module='y',1040            names=[1041                alias(name='x'),1042                alias(name='y'),1043                alias(name='z')],1044            level=0)],1045    type_ignores=[])1046```10471048#### `class ast.alias(name, asname)`10491050Оба параметра – необработанные строки имён. `asname` может быть `None`, если должно использоваться обычное имя.10511052```pycon1053>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))1054Module(1055    body=[1056        ImportFrom(1057            module='foo.bar',1058            names=[1059                alias(name='a', asname='b'),1060                alias(name='c')],1061            level=2)],1062    type_ignores=[])1063```10641065### Управление потоком10661067> **Примечание**1068>1069> Необязательные предложения, такие как `else`, сохраняются как пустой список, если они отсутствуют.10701071#### `class ast.If(test, body, orelse)`10721073Инструкция `if`. `test` содержит один узел, например узел [`Compare`](https://python-all.ru/3.11/library/ast.html#ast.Compare). `body` и `orelse` содержат по списку узлов.10741075Предложения `elif` не имеют специального представления в AST, а появляются как дополнительные узлы [`If`](https://python-all.ru/3.11/library/ast.html#ast.If) в разделе `orelse` предыдущего.10761077```pycon1078>>> print(ast.dump(ast.parse("""1079... if x:1080...    ...1081... elif y:1082...    ...1083... else:1084...    ...1085... """), indent=4))1086Module(1087    body=[1088        If(1089            test=Name(id='x', ctx=Load()),1090            body=[1091                Expr(1092                    value=Constant(value=Ellipsis))],1093            orelse=[1094                If(1095                    test=Name(id='y', ctx=Load()),1096                    body=[1097                        Expr(1098                            value=Constant(value=Ellipsis))],1099                    orelse=[1100                        Expr(1101                            value=Constant(value=Ellipsis))])])],1102    type_ignores=[])1103```11041105#### `class ast.For(target, iter, body, orelse, type_comment)`11061107Цикл `for`. `target` содержит переменную (или переменные), которой присваивает цикл, в виде одного узла [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.11/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.11/library/ast.html#ast.List). `iter` содержит элемент, по которому выполняется итерация, также в виде одного узла. `body` и `orelse` содержат списки узлов для выполнения. Узлы в `orelse` выполняются, если цикл завершается нормально, а не через оператор `break`.11081109#### `type_comment`11101111`type_comment` – это необязательная строка с аннотацией типа в виде комментария.11121113```pycon1114>>> print(ast.dump(ast.parse("""1115... for x in y:1116...     ...1117... else:1118...     ...1119... """), indent=4))1120Module(1121    body=[1122        For(1123            target=Name(id='x', ctx=Store()),1124            iter=Name(id='y', ctx=Load()),1125            body=[1126                Expr(1127                    value=Constant(value=Ellipsis))],1128            orelse=[1129                Expr(1130                    value=Constant(value=Ellipsis))])],1131    type_ignores=[])1132```11331134#### `class ast.While(test, body, orelse)`11351136Цикл `while`. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.11/library/ast.html#ast.Compare).11371138```pycon1139>> print(ast.dump(ast.parse("""1140... while x:1141...    ...1142... else:1143...    ...1144... """), indent=4))1145Module(1146    body=[1147        While(1148            test=Name(id='x', ctx=Load()),1149            body=[1150                Expr(1151                    value=Constant(value=Ellipsis))],1152            orelse=[1153                Expr(1154                    value=Constant(value=Ellipsis))])],1155    type_ignores=[])1156```11571158#### `class ast.Break`11591160#### `class ast.Continue`11611162Инструкции `break` и `continue`.11631164```pycon1165>>> print(ast.dump(ast.parse("""\1166... for a in b:1167...     if a > 5:1168...         break1169...     else:1170...         continue1171...1172... """), indent=4))1173Module(1174    body=[1175        For(1176            target=Name(id='a', ctx=Store()),1177            iter=Name(id='b', ctx=Load()),1178            body=[1179                If(1180                    test=Compare(1181                        left=Name(id='a', ctx=Load()),1182                        ops=[1183                            Gt()],1184                        comparators=[1185                            Constant(value=5)]),1186                    body=[1187                        Break()],1188                    orelse=[1189                        Continue()])],1190            orelse=[])],1191    type_ignores=[])1192```11931194#### `class ast.Try(body, handlers, orelse, finalbody)`11951196Блоки `try`. Все атрибуты – списки узлов для выполнения, за исключением `handlers`, который является списком узлов [`ExceptHandler`](https://python-all.ru/3.11/library/ast.html#ast.ExceptHandler).11971198```pycon1199>>> print(ast.dump(ast.parse("""1200... try:1201...    ...1202... except Exception:1203...    ...1204... except OtherException as e:1205...    ...1206... else:1207...    ...1208... finally:1209...    ...1210... """), indent=4))1211Module(1212    body=[1213        Try(1214            body=[1215                Expr(1216                    value=Constant(value=Ellipsis))],1217            handlers=[1218                ExceptHandler(1219                    type=Name(id='Exception', ctx=Load()),1220                    body=[1221                        Expr(1222                            value=Constant(value=Ellipsis))]),1223                ExceptHandler(1224                    type=Name(id='OtherException', ctx=Load()),1225                    name='e',1226                    body=[1227                        Expr(1228                            value=Constant(value=Ellipsis))])],1229            orelse=[1230                Expr(1231                    value=Constant(value=Ellipsis))],1232            finalbody=[1233                Expr(1234                    value=Constant(value=Ellipsis))])],1235    type_ignores=[])1236```12371238#### `class ast.TryStar(body, handlers, orelse, finalbody)`12391240Блоки `try`, за которыми следуют предложения `except*`. Атрибуты такие же, как для [`Try`](https://python-all.ru/3.11/library/ast.html#ast.Try), но узлы [`ExceptHandler`](https://python-all.ru/3.11/library/ast.html#ast.ExceptHandler) в `handlers` интерпретируются как блоки `except*`, а не `except`.12411242```pycon1243>>> print(ast.dump(ast.parse("""1244... try:1245...    ...1246... except* Exception:1247...    ...1248... """), indent=4))1249Module(1250    body=[1251        TryStar(1252            body=[1253                Expr(1254                    value=Constant(value=Ellipsis))],1255            handlers=[1256                ExceptHandler(1257                    type=Name(id='Exception', ctx=Load()),1258                    body=[1259                        Expr(1260                            value=Constant(value=Ellipsis))])],1261            orelse=[],1262            finalbody=[])],1263    type_ignores=[])1264```12651266#### `class ast.ExceptHandler(type, name, body)`12671268Одно предложение `except`. `type` – тип исключения, который оно перехватывает, обычно узел [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name) (или `None` для универсального предложения `except:`). `name` – необработанная строка для имени, в котором будет сохранено исключение, или `None`, если в предложении нет `as foo`. `body` – список узлов.12691270```pycon1271>>> print(ast.dump(ast.parse("""\1272... try:1273...     a + 11274... except TypeError:1275...     pass1276... """), indent=4))1277Module(1278    body=[1279        Try(1280            body=[1281                Expr(1282                    value=BinOp(1283                        left=Name(id='a', ctx=Load()),1284                        op=Add(),1285                        right=Constant(value=1)))],1286            handlers=[1287                ExceptHandler(1288                    type=Name(id='TypeError', ctx=Load()),1289                    body=[1290                        Pass()])],1291            orelse=[],1292            finalbody=[])],1293    type_ignores=[])1294```12951296#### `class ast.With(items, body, type_comment)`12971298Блок `with`. `items` – это список узлов [`withitem`](https://python-all.ru/3.11/library/ast.html#ast.withitem), представляющих менеджеры контекста, а `body` – это блок с отступом внутри контекста.12991300#### `type_comment`13011302`type_comment` – это необязательная строка с аннотацией типа в виде комментария.13031304#### `class ast.withitem(context_expr, optional_vars)`13051306Один менеджер контекста в блоке `with`. `context_expr` – это менеджер контекста, часто узел [`Call`](https://python-all.ru/3.11/library/ast.html#ast.Call). `optional_vars` – это [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.11/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.11/library/ast.html#ast.List) для части `as foo`, или `None`, если она не используется.13071308```pycon1309>>> print(ast.dump(ast.parse("""\1310... with a as b, c as d:1311...    something(b, d)1312... """), indent=4))1313Module(1314    body=[1315        With(1316            items=[1317                withitem(1318                    context_expr=Name(id='a', ctx=Load()),1319                    optional_vars=Name(id='b', ctx=Store())),1320                withitem(1321                    context_expr=Name(id='c', ctx=Load()),1322                    optional_vars=Name(id='d', ctx=Store()))],1323            body=[1324                Expr(1325                    value=Call(1326                        func=Name(id='something', ctx=Load()),1327                        args=[1328                            Name(id='b', ctx=Load()),1329                            Name(id='d', ctx=Load())],1330                        keywords=[]))])],1331    type_ignores=[])1332```13331334### Сопоставление с образцом13351336#### `class ast.Match(subject, cases)`13371338Оператор `match`. В `subject` хранится subject сопоставления (объект, который сравнивается с вариантами), а `cases` содержит итерируемый набор узлов [`match_case`](https://python-all.ru/3.11/library/ast.html#ast.match_case) с различными вариантами.13391340#### `class ast.match_case(pattern, guard, body)`13411342Один вариант (case) в операторе `match`. `pattern` содержит шаблон сопоставления, с которым будет сравниваться subject. Обратите внимание, что узлы [`AST`](https://python-all.ru/3.11/library/ast.html#ast.AST), создаваемые для шаблонов, отличаются от узлов, создаваемых для выражений, даже при одинаковом синтаксисе.13431344Атрибут `guard` содержит выражение, которое будет вычислено, если шаблон совпадает с subject.13451346`body` содержит список узлов, которые выполняются, если шаблон совпадает и результат вычисления guard-выражения истинен.13471348```pycon1349>>> print(ast.dump(ast.parse("""1350... match x:1351...     case [x] if x>0:1352...         ...1353...     case tuple():1354...         ...1355... """), indent=4))1356Module(1357    body=[1358        Match(1359            subject=Name(id='x', ctx=Load()),1360            cases=[1361                match_case(1362                    pattern=MatchSequence(1363                        patterns=[1364                            MatchAs(name='x')]),1365                    guard=Compare(1366                        left=Name(id='x', ctx=Load()),1367                        ops=[1368                            Gt()],1369                        comparators=[1370                            Constant(value=0)]),1371                    body=[1372                        Expr(1373                            value=Constant(value=Ellipsis))]),1374                match_case(1375                    pattern=MatchClass(1376                        cls=Name(id='tuple', ctx=Load()),1377                        patterns=[],1378                        kwd_attrs=[],1379                        kwd_patterns=[]),1380                    body=[1381                        Expr(1382                            value=Constant(value=Ellipsis))])])],1383    type_ignores=[])1384```13851386#### `class ast.MatchValue(value)`13871388Сопоставление с литералом или шаблоном значения, сравниваемым по равенству. `value` – это узел выражения. Допустимые узлы значений ограничены, как описано в документации оператора match. Этот шаблон успешно срабатывает, если subject сопоставления равен вычисленному значению.13891390```pycon1391>>> print(ast.dump(ast.parse("""1392... match x:1393...     case "Relevant":1394...         ...1395... """), indent=4))1396Module(1397    body=[1398        Match(1399            subject=Name(id='x', ctx=Load()),1400            cases=[1401                match_case(1402                    pattern=MatchValue(1403                        value=Constant(value='Relevant')),1404                    body=[1405                        Expr(1406                            value=Constant(value=Ellipsis))])])],1407    type_ignores=[])1408```14091410#### `class ast.MatchSingleton(value)`14111412Сопоставление с литералом, сравниваемым по идентичности. `value` – это синглтон, с которым производится сравнение: `None`, `True` или `False`. Этот шаблон успешно срабатывает, если subject сопоставления является заданной константой.14131414```pycon1415>>> print(ast.dump(ast.parse("""1416... match x:1417...     case None:1418...         ...1419... """), indent=4))1420Module(1421    body=[1422        Match(1423            subject=Name(id='x', ctx=Load()),1424            cases=[1425                match_case(1426                    pattern=MatchSingleton(value=None),1427                    body=[1428                        Expr(1429                            value=Constant(value=Ellipsis))])])],1430    type_ignores=[])1431```14321433#### `class ast.MatchSequence(patterns)`14341435Шаблон последовательности (sequence pattern) в match. `patterns` содержит шаблоны, которые будут сопоставляться с элементами subject, если subject является последовательностью. Сопоставляется с последовательностью переменной длины, если один из подшаблонов является узлом `MatchStar`, в противном случае сопоставляется с последовательностью фиксированной длины.14361437```pycon1438>>> print(ast.dump(ast.parse("""1439... match x:1440...     case [1, 2]:1441...         ...1442... """), indent=4))1443Module(1444    body=[1445        Match(1446            subject=Name(id='x', ctx=Load()),1447            cases=[1448                match_case(1449                    pattern=MatchSequence(1450                        patterns=[1451                            MatchValue(1452                                value=Constant(value=1)),1453                            MatchValue(1454                                value=Constant(value=2))]),1455                    body=[1456                        Expr(1457                            value=Constant(value=Ellipsis))])])],1458    type_ignores=[])1459```14601461#### `class ast.MatchStar(name)`14621463Сопоставляется с остатком последовательности в шаблоне последовательности переменной длины. Если `name` не равно `None`, то при успешном сопоставлении всего шаблона последовательности этому имени привязывается список, содержащий оставшиеся элементы последовательности.14641465```pycon1466>>> print(ast.dump(ast.parse("""1467... match x:1468...     case [1, 2, *rest]:1469...         ...1470...     case [*_]:1471...         ...1472... """), indent=4))1473Module(1474    body=[1475        Match(1476            subject=Name(id='x', ctx=Load()),1477            cases=[1478                match_case(1479                    pattern=MatchSequence(1480                        patterns=[1481                            MatchValue(1482                                value=Constant(value=1)),1483                            MatchValue(1484                                value=Constant(value=2)),1485                            MatchStar(name='rest')]),1486                    body=[1487                        Expr(1488                            value=Constant(value=Ellipsis))]),1489                match_case(1490                    pattern=MatchSequence(1491                        patterns=[1492                            MatchStar()]),1493                    body=[1494                        Expr(1495                            value=Constant(value=Ellipsis))])])],1496    type_ignores=[])1497```14981499#### `class ast.MatchMapping(keys, patterns, rest)`15001501Шаблон отображения (mapping pattern) в match. `keys` – последовательность узлов выражений. `patterns` – соответствующая последовательность узлов шаблонов. `rest` – необязательное имя, которое можно указать для захвата оставшихся элементов отображения. Допустимые ключевые выражения ограничены, как описано в документации оператора match.15021503Этот шаблон успешно срабатывает, если subject является отображением, все вычисленные ключевые выражения присутствуют в отображении, а значение, соответствующее каждому ключу, совпадает с соответствующим подшаблоном. Если `rest` не равно `None`, то при успешном сопоставлении всего шаблона отображения этому имени привязывается словарь, содержащий оставшиеся элементы отображения.15041505```pycon1506>>> print(ast.dump(ast.parse("""1507... match x:1508...     case {1: _, 2: _}:1509...         ...1510...     case {**rest}:1511...         ...1512... """), indent=4))1513Module(1514    body=[1515        Match(1516            subject=Name(id='x', ctx=Load()),1517            cases=[1518                match_case(1519                    pattern=MatchMapping(1520                        keys=[1521                            Constant(value=1),1522                            Constant(value=2)],1523                        patterns=[1524                            MatchAs(),1525                            MatchAs()]),1526                    body=[1527                        Expr(1528                            value=Constant(value=Ellipsis))]),1529                match_case(1530                    pattern=MatchMapping(keys=[], patterns=[], rest='rest'),1531                    body=[1532                        Expr(1533                            value=Constant(value=Ellipsis))])])],1534    type_ignores=[])1535```15361537#### `class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)`15381539Шаблон класса (class pattern) в match. `cls` – выражение, задающее номинальный класс для сопоставления. `patterns` – последовательность узлов шаблонов, которые будут сопоставляться с определённой классом последовательностью атрибутов для сопоставления с образцом. `kwd_attrs` – последовательность дополнительных атрибутов для сопоставления (указанных как ключевые аргументы в шаблоне класса), `kwd_patterns` – соответствующие шаблоны (указанные как значения ключевых слов в шаблоне класса).15401541Этот шаблон успешно срабатывает, если subject является экземпляром указанного класса, все позиционные шаблоны совпадают с соответствующими атрибутами, определёнными классом, и все указанные ключевые атрибуты совпадают со своими шаблонами.15421543Примечание: классы могут определять свойство, возвращающее self, чтобы сопоставлять узел шаблона с сопоставляемым экземпляром. Некоторые встроенные типы также сопоставляются таким образом, как описано в документации оператора match.15441545```pycon1546>>> print(ast.dump(ast.parse("""1547... match x:1548...     case Point2D(0, 0):1549...         ...1550...     case Point3D(x=0, y=0, z=0):1551...         ...1552... """), indent=4))1553Module(1554    body=[1555        Match(1556            subject=Name(id='x', ctx=Load()),1557            cases=[1558                match_case(1559                    pattern=MatchClass(1560                        cls=Name(id='Point2D', ctx=Load()),1561                        patterns=[1562                            MatchValue(1563                                value=Constant(value=0)),1564                            MatchValue(1565                                value=Constant(value=0))],1566                        kwd_attrs=[],1567                        kwd_patterns=[]),1568                    body=[1569                        Expr(1570                            value=Constant(value=Ellipsis))]),1571                match_case(1572                    pattern=MatchClass(1573                        cls=Name(id='Point3D', ctx=Load()),1574                        patterns=[],1575                        kwd_attrs=[1576                            'x',1577                            'y',1578                            'z'],1579                        kwd_patterns=[1580                            MatchValue(1581                                value=Constant(value=0)),1582                            MatchValue(1583                                value=Constant(value=0)),1584                            MatchValue(1585                                value=Constant(value=0))]),1586                    body=[1587                        Expr(1588                            value=Constant(value=Ellipsis))])])],1589    type_ignores=[])1590```15911592#### `class ast.MatchAs(pattern, name)`15931594Сопоставление «as-pattern», шаблон захвата (capture pattern) или шаблон-заменитель (wildcard pattern). `pattern` содержит шаблон match, с которым будет сопоставлен subject. Если шаблон равен `None`, узел представляет собой шаблон захвата (т.е. просто имя) и всегда успешно срабатывает.15951596Атрибут `name` содержит имя, которое будет привязано при успешном сопоставлении шаблона. Если `name` равно `None`, то `pattern` также должно быть `None`, и узел представляет собой шаблон-заменитель (wildcard).15971598```pycon1599>>> print(ast.dump(ast.parse("""1600... match x:1601...     case [x] as y:1602...         ...1603...     case _:1604...         ...1605... """), indent=4))1606Module(1607    body=[1608        Match(1609            subject=Name(id='x', ctx=Load()),1610            cases=[1611                match_case(1612                    pattern=MatchAs(1613                        pattern=MatchSequence(1614                            patterns=[1615                                MatchAs(name='x')]),1616                        name='y'),1617                    body=[1618                        Expr(1619                            value=Constant(value=Ellipsis))]),1620                match_case(1621                    pattern=MatchAs(),1622                    body=[1623                        Expr(1624                            value=Constant(value=Ellipsis))])])],1625    type_ignores=[])1626```16271628#### `class ast.MatchOr(patterns)`16291630Сопоставление «or-pattern» (шаблон ИЛИ). Or-pattern последовательно сопоставляет каждый из своих подшаблонов с subject, пока один из них не сработает. Тогда считается, что or-pattern сработал. Если ни один из подшаблонов не сработал, or-pattern не срабатывает. Атрибут `patterns` содержит список узлов шаблонов match, которые будут сопоставляться с subject.16311632```pycon1633>>> print(ast.dump(ast.parse("""1634... match x:1635...     case [x] | (y):1636...         ...1637... """), indent=4))1638Module(1639    body=[1640        Match(1641            subject=Name(id='x', ctx=Load()),1642            cases=[1643                match_case(1644                    pattern=MatchOr(1645                        patterns=[1646                            MatchSequence(1647                                patterns=[1648                                    MatchAs(name='x')]),1649                            MatchAs(name='y')]),1650                    body=[1651                        Expr(1652                            value=Constant(value=Ellipsis))])])],1653    type_ignores=[])1654```16551656### Определения функций и классов16571658#### `class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment)`16591660Определение функции.16611662- `name` – это необработанная строка имени функции.1663- `args` – это узел [`arguments`](https://python-all.ru/3.11/library/ast.html#ast.arguments).1664- `body` – это список узлов внутри функции.1665- `decorator_list` – это список декораторов, которые будут применены; декораторы перечислены от самого внешнего к внутреннему (т.е. первый в списке применяется последним).1666- `returns` – это аннотация возвращаемого значения.16671668#### `type_comment`16691670`type_comment` – это необязательная строка с аннотацией типа в виде комментария.16711672#### `class ast.Lambda(args, body)`16731674`lambda` – это минимальное определение функции, которое можно использовать внутри выражения. В отличие от [`FunctionDef`](https://python-all.ru/3.11/library/ast.html#ast.FunctionDef), `body` содержит один узел.16751676```pycon1677>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))1678Module(1679    body=[1680        Expr(1681            value=Lambda(1682                args=arguments(1683                    posonlyargs=[],1684                    args=[1685                        arg(arg='x'),1686                        arg(arg='y')],1687                    kwonlyargs=[],1688                    kw_defaults=[],1689                    defaults=[]),1690                body=Constant(value=Ellipsis)))],1691    type_ignores=[])1692```16931694#### `class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)`16951696Аргументы функции.16971698- `posonlyargs`, `args` и `kwonlyargs` – это списки узлов [`arg`](https://python-all.ru/3.11/library/ast.html#ast.arg).1699- `vararg` и `kwarg` – это одиночные узлы [`arg`](https://python-all.ru/3.11/library/ast.html#ast.arg), ссылающиеся на параметры `*args, **kwargs`.1700- `kw_defaults` – это список значений по умолчанию для keyword-only аргументов. Если один из них равен `None`, соответствующий аргумент обязателен.1701- `defaults` – это список значений по умолчанию для аргументов, которые можно передавать позиционно. Если значений по умолчанию меньше, они соответствуют последним n аргументам.17021703#### `class ast.arg(arg, annotation, type_comment)`17041705Один аргумент в списке. `arg` – это сырая строка с именем аргумента; `annotation` – это его аннотация, например, узел [`Name`](https://python-all.ru/3.11/library/ast.html#ast.Name).17061707#### `type_comment`17081709`type_comment` – это необязательная строка с аннотацией типа в виде комментария17101711```pycon1712>>> print(ast.dump(ast.parse("""\1713... @decorator11714... @decorator21715... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':1716...     pass1717... """), indent=4))1718Module(1719    body=[1720        FunctionDef(1721            name='f',1722            args=arguments(1723                posonlyargs=[],1724                args=[1725                    arg(1726                        arg='a',1727                        annotation=Constant(value='annotation')),1728                    arg(arg='b'),1729                    arg(arg='c')],1730                vararg=arg(arg='d'),1731                kwonlyargs=[1732                    arg(arg='e'),1733                    arg(arg='f')],1734                kw_defaults=[1735                    None,1736                    Constant(value=3)],1737                kwarg=arg(arg='g'),1738                defaults=[1739                    Constant(value=1),1740                    Constant(value=2)]),1741            body=[1742                Pass()],1743            decorator_list=[1744                Name(id='decorator1', ctx=Load()),1745                Name(id='decorator2', ctx=Load())],1746            returns=Constant(value='return annotation'))],1747    type_ignores=[])1748```17491750#### `class ast.Return(value)`17511752Инструкция `return`.17531754```pycon1755>>> print(ast.dump(ast.parse('return 4'), indent=4))1756Module(1757    body=[1758        Return(1759            value=Constant(value=4))],1760    type_ignores=[])1761```17621763#### `class ast.Yield(value)`17641765#### `class ast.YieldFrom(value)`17661767Выражение `yield` или `yield from`. Поскольку это выражения, их необходимо обернуть в узел [`Expr`](https://python-all.ru/3.11/library/ast.html#ast.Expr), если возвращаемое значение не используется.17681769```pycon1770>>> print(ast.dump(ast.parse('yield x'), indent=4))1771Module(1772    body=[1773        Expr(1774            value=Yield(1775                value=Name(id='x', ctx=Load())))],1776    type_ignores=[])17771778>>> print(ast.dump(ast.parse('yield from x'), indent=4))1779Module(1780    body=[1781        Expr(1782            value=YieldFrom(1783                value=Name(id='x', ctx=Load())))],1784    type_ignores=[])1785```17861787#### `class ast.Global(names)`17881789#### `class ast.Nonlocal(names)`17901791Инструкции `global` и `nonlocal`. `names` – это список сырых строк.17921793```pycon1794>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))1795Module(1796    body=[1797        Global(1798            names=[1799                'x',1800                'y',1801                'z'])],1802    type_ignores=[])18031804>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))1805Module(1806    body=[1807        Nonlocal(1808            names=[1809                'x',1810                'y',1811                'z'])],1812    type_ignores=[])1813```18141815#### `class ast.ClassDef(name, bases, keywords, body, decorator_list)`18161817Определение класса.18181819- `name` – это сырая строка с именем класса.1820- `bases` – это список узлов для явно указанных базовых классов.1821- `keywords` – это список узлов [`keyword`](https://python-all.ru/3.11/library/ast.html#ast.keyword), в основном для «metaclass». Остальные ключевые слова будут переданы метаклассу в соответствии с [PEP-3115](https://python-all.ru/3.11/library/ast.html).1822- `body` – это список узлов, представляющих код внутри определения класса.1823- `decorator_list` – это список узлов, как и в [`FunctionDef`](https://python-all.ru/3.11/library/ast.html#ast.FunctionDef).18241825```pycon1826>>> print(ast.dump(ast.parse("""\1827... @decorator11828... @decorator21829... class Foo(base1, base2, metaclass=meta):1830...     pass1831... """), indent=4))1832Module(1833    body=[1834        ClassDef(1835            name='Foo',1836            bases=[1837                Name(id='base1', ctx=Load()),1838                Name(id='base2', ctx=Load())],1839            keywords=[1840                keyword(1841                    arg='metaclass',1842                    value=Name(id='meta', ctx=Load()))],1843            body=[1844                Pass()],1845            decorator_list=[1846                Name(id='decorator1', ctx=Load()),1847                Name(id='decorator2', ctx=Load())])],1848    type_ignores=[])1849```18501851### async и await18521853#### `class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment)`18541855Определение функции `async def`. Имеет те же поля, что и [`FunctionDef`](https://python-all.ru/3.11/library/ast.html#ast.FunctionDef).18561857#### `class ast.Await(value)`18581859Выражение `await`. `value` – это то, чего оно ожидает. Допустимо только в теле [`AsyncFunctionDef`](https://python-all.ru/3.11/library/ast.html#ast.AsyncFunctionDef).18601861```pycon1862>>> print(ast.dump(ast.parse("""\1863... async def f():1864...     await other_func()1865... """), indent=4))1866Module(1867    body=[1868        AsyncFunctionDef(1869            name='f',1870            args=arguments(1871                posonlyargs=[],1872                args=[],1873                kwonlyargs=[],1874                kw_defaults=[],1875                defaults=[]),1876            body=[1877                Expr(1878                    value=Await(1879                        value=Call(1880                            func=Name(id='other_func', ctx=Load()),1881                            args=[],1882                            keywords=[])))],1883            decorator_list=[])],1884    type_ignores=[])1885```18861887#### `class ast.AsyncFor(target, iter, body, orelse, type_comment)`18881889#### `class ast.AsyncWith(items, body, type_comment)`18901891`async for` циклы и `async with` менеджеры контекста. Они имеют те же поля, что [`For`](https://python-all.ru/3.11/library/ast.html#ast.For) и [`With`](https://python-all.ru/3.11/library/ast.html#ast.With), соответственно. Допустимы только в теле [`AsyncFunctionDef`](https://python-all.ru/3.11/library/ast.html#ast.AsyncFunctionDef).18921893> **Примечание**1894>1895> Когда строка разбирается парсером [`ast.parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse), узлы операторов (подклассы `ast.operator`, `ast.unaryop`, `ast.cmpop`, `ast.boolop` и `ast.expr_context`) на возвращаемом дереве являются синглтонами. Изменения в одном будут отражены во всех других вхождениях того же значения (например, [`ast.Add`](https://python-all.ru/3.11/library/ast.html#ast.Add)).18961897## [`ast`](https://python-all.ru/3.11/library/ast.html#module-ast) Вспомогательные функции18981899Помимо классов узлов, модуль [`ast`](https://python-all.ru/3.11/library/ast.html#module-ast) определяет следующие служебные функции и классы для обхода абстрактных синтаксических деревьев:19001901#### `ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None)`19021903Разбирает исходный код в узел AST. Эквивалентно `compile(source, filename, mode, ast.PyCF_ONLY_AST)`.19041905Если задан `type_comments=True`, парсер изменяется, чтобы проверять и возвращать комментарии типов, как указано в [**PEP 484**](https://python-all.ru/3.11/library/ast.html) и [**PEP 526**](https://python-all.ru/3.11/library/ast.html). Это эквивалентно добавлению [`ast.PyCF_TYPE_COMMENTS`](https://python-all.ru/3.11/library/ast.html#ast.PyCF_TYPE_COMMENTS) к флагам, передаваемым в [`compile()`](https://python-all.ru/3.11/library/functions.html#compile). Это приведёт к сообщению об ошибках синтаксиса для неправильно расположенных комментариев типов. Без этого флага комментарии типов будут игнорироваться, и поле `type_comment` в выбранных узлах AST всегда будет `None`. Кроме того, расположение комментариев `# type: ignore` будет возвращаться как атрибут `type_ignores` объекта [`Module`](https://python-all.ru/3.11/library/ast.html#ast.Module) (иначе это всегда пустой список).19061907Кроме того, если `mode` равно `'func_type'`, синтаксис входных данных изменяется в соответствии с [**PEP 484**](https://python-all.ru/3.11/library/ast.html) «сигнатурными комментариями типов», например `(str, int) -> List[str]`.19081909Установка `feature_version` в кортеж `(major, minor)` приведёт к «наилучшей попытке» разбора с использованием грамматики этой версии Python. Например, установка `feature_version=(3, 9)` будет пытаться запретить разбор инструкций [`match`](https://python-all.ru/3.11/reference/compound_stmts.html#match). В настоящее время `major` должно быть равно `3`. Самая низкая поддерживаемая версия – `(3, 4)` (и это может увеличиться в будущих версиях Python); самая высокая – `sys.version_info[0:2]`. «Наилучшая попытка» означает, что нет гарантии, что разбор (или успех разбора) будет таким же, как при запуске на версии Python, соответствующей `feature_version`.19101911Если исходный код содержит нулевой символ (`\0`), возбуждается [`ValueError`](https://python-all.ru/3.11/library/exceptions.html#ValueError).19121913> **Предупреждение**1914>1915> Обратите внимание, что успешный разбор исходного кода в объект AST не гарантирует, что предоставленный исходный код является корректным кодом Python, который можно выполнить, поскольку этап компиляции может вызывать дополнительные исключения [`SyntaxError`](https://python-all.ru/3.11/library/exceptions.html#SyntaxError). Например, исходный код `return 42` генерирует корректный узел AST для инструкции return, но его нельзя скомпилировать отдельно (он должен находиться внутри узла функции).1916>1917> В частности, [`ast.parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse) не выполняет никаких проверок областей видимости, которые выполняет этап компиляции.19181919> **Предупреждение**1920>1921> Можно вызвать сбой интерпретатора Python с помощью достаточно большой/сложной строки из-за ограничений глубины стека в компиляторе AST Python.19221923Изменено в версии 3.8: Добавлены `type_comments`, `mode='func_type'` и `feature_version`.19241925#### `ast.unparse(ast_obj)`19261927Выполняет обратный разбор объекта [`ast.AST`](https://python-all.ru/3.11/library/ast.html#ast.AST) и генерирует строку с кодом, который при обратном разборе с помощью [`ast.parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse) даст эквивалентный объект [`ast.AST`](https://python-all.ru/3.11/library/ast.html#ast.AST).19281929> **Предупреждение**1930>1931> Полученная строка кода не обязательно будет равна исходному коду, который породил объект [`ast.AST`](https://python-all.ru/3.11/library/ast.html#ast.AST) (без каких-либо оптимизаций компилятора, таких как константные кортежи/frozensets).19321933> **Предупреждение**1934>1935> Попытка выполнить обратный разбор очень сложного выражения приведёт к [`RecursionError`](https://python-all.ru/3.11/library/exceptions.html#RecursionError).19361937Новое в версии 3.9.19381939#### `ast.literal_eval(node_or_string)`19401941Вычисляет узел выражения или строку, содержащую только литерал Python или отображение контейнера. Предоставленная строка или узел могут состоять только из следующих структур литералов Python: строки, байты, числа, кортежи, списки, словари, множества, булевы значения, `None` и `Ellipsis`.19421943Это можно использовать для вычисления строк, содержащих значения Python, без необходимости разбирать значения самостоятельно. Он не способен вычислять произвольно сложные выражения, например, с операторами или индексацией.19441945Раньше эта функция документировалась как «безопасная» без определения, что это значит. Это вводило в заблуждение. Она специально разработана так, чтобы не выполнять код Python, в отличие от более общей [`eval()`](https://python-all.ru/3.11/library/functions.html#eval). Нет пространства имён, поиска имён или возможности внешних вызовов. Но она не свободна от атак: относительно небольшой ввод может привести к истощению памяти или истощению стека C, что вызовет сбой процесса. Также существует возможность отказа в обслуживании из-за чрезмерного потребления ЦП на некоторых входных данных. Поэтому вызывать её на недоверенных данных не рекомендуется.19461947> **Предупреждение**1948>1949> Можно вызвать сбой интерпретатора Python из-за ограничений глубины стека в компиляторе AST Python.1950>1951> Она может возбуждать [`ValueError`](https://python-all.ru/3.11/library/exceptions.html#ValueError), [`TypeError`](https://python-all.ru/3.11/library/exceptions.html#TypeError), [`SyntaxError`](https://python-all.ru/3.11/library/exceptions.html#SyntaxError), [`MemoryError`](https://python-all.ru/3.11/library/exceptions.html#MemoryError) и [`RecursionError`](https://python-all.ru/3.11/library/exceptions.html#RecursionError) в зависимости от некорректного ввода.19521953Изменено в версии 3.2: Теперь допускает литералы байтов и множеств.19541955Изменено в версии 3.9: Теперь поддерживает создание пустых множеств с помощью `'set()'`.19561957Изменено в версии 3.10: Для строковых входных данных начальные пробелы и табуляции теперь удаляются.19581959#### `ast.get_docstring(node, clean=True)`19601961Возвращает строку документации для данного *узла* (который должен быть узлом [`FunctionDef`](https://python-all.ru/3.11/library/ast.html#ast.FunctionDef), [`AsyncFunctionDef`](https://python-all.ru/3.11/library/ast.html#ast.AsyncFunctionDef), [`ClassDef`](https://python-all.ru/3.11/library/ast.html#ast.ClassDef) или [`Module`](https://python-all.ru/3.11/library/ast.html#ast.Module)) или `None`, если у него нет строки документации. Если *clean* истинно, очищает отступы строки документации с помощью [`inspect.cleandoc()`](https://python-all.ru/3.11/library/inspect.html#inspect.cleandoc).19621963Изменено в версии 3.5: Теперь поддерживается [`AsyncFunctionDef`](https://python-all.ru/3.11/library/ast.html#ast.AsyncFunctionDef).19641965#### `ast.get_source_segment(source, node, *, padded=False)`19661967Возвращает фрагмент исходного кода из *source*, который породил узел *node*. Если не хватает информации о местоположении ([`lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.lineno), [`end_lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.end_lineno), [`col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.col_offset) или [`end_col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.end_col_offset)), возвращает `None`.19681969Если *padded* равно `True`, первая строка многострочного оператора будет дополнена пробелами, чтобы соответствовать исходной позиции.19701971Новое в версии 3.8.19721973#### `ast.fix_missing_locations(node)`19741975При компиляции дерева узлов с помощью [`compile()`](https://python-all.ru/3.11/library/functions.html#compile) компилятор ожидает атрибуты [`lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.lineno) и [`col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.col_offset) для каждого узла, который их поддерживает. Заполнять их вручную для сгенерированных узлов довольно утомительно, поэтому эта вспомогательная функция рекурсивно добавляет эти атрибуты, если их ещё нет, устанавливая их равными значениям родительского узла. Работает рекурсивно, начиная с *node*.19761977#### `ast.increment_lineno(node, n=1)`19781979Увеличивает номер строки и номер конечной строки каждого узла в дереве, начиная с *node*, на *n*. Это полезно для «перемещения кода» в другое место в файле.19801981#### `ast.copy_location(new_node, old_node)`19821983Копирует информацию о местоположении в исходном коде ([`lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.11/library/ast.html#ast.AST.end_col_offset)) из *old\_node* в *new\_node*, если это возможно, и возвращает *new\_node*.19841985#### `ast.iter_fields(node)`19861987Генерирует кортеж из `(fieldname, value)` для каждого поля в `node._fields`, которое присутствует в *node*.19881989#### `ast.iter_child_nodes(node)`19901991Генерирует все непосредственные дочерние узлы *node*, то есть все поля, являющиеся узлами, и все элементы полей, являющихся списками узлов.19921993#### `ast.walk(node)`19941995Рекурсивно генерирует все узлы-потомки в дереве, начиная с *node* (включая сам *node*), в произвольном порядке. Это полезно, если требуется только изменить узлы на месте, а контекст не важен.19961997#### `class ast.NodeVisitor`19981999Базовый класс для обхода узлов, который обходит абстрактное синтаксическое дерево и вызывает функцию-посетитель для каждого найденного узла. Эта функция может вернуть значение, которое передаётся методом [`visit()`](https://python-all.ru/3.11/library/ast.html#ast.NodeVisitor.visit).20002001Этот класс предназначен для наследования; в подклассе добавляются методы-посетители.20022003#### `visit(node)`20042005Посещает узел. Реализация по умолчанию вызывает метод `self.visit_classname`, где *classname* – имя класса узла, или [`generic_visit()`](https://python-all.ru/3.11/library/ast.html#ast.NodeVisitor.generic_visit), если такой метод отсутствует.20062007#### `generic_visit(node)`20082009Этот посетитель вызывает [`visit()`](https://python-all.ru/3.11/library/ast.html#ast.NodeVisitor.visit) для всех дочерних узлов.20102011Обратите внимание, что дочерние узлы тех узлов, для которых определён собственный метод-посетитель, не будут посещены, если посетитель сам не вызовет [`generic_visit()`](https://python-all.ru/3.11/library/ast.html#ast.NodeVisitor.generic_visit) или не обойдёт их самостоятельно.20122013#### `visit_Constant(node)`20142015Обрабатывает все константные узлы.20162017Не используйте [`NodeVisitor`](https://python-all.ru/3.11/library/ast.html#ast.NodeVisitor), если требуется вносить изменения в узлы во время обхода. Для этого существует специальный посетитель ([`NodeTransformer`](https://python-all.ru/3.11/library/ast.html#ast.NodeTransformer)), который допускает модификации.20182019Устарело с версии 3.8: Методы `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` и `visit_Ellipsis()` теперь устарели и не будут вызываться в будущих версиях Python. Добавьте метод [`visit_Constant()`](https://python-all.ru/3.11/library/ast.html#ast.NodeVisitor.visit_Constant) для обработки всех узлов-констант.20202021#### `class ast.NodeTransformer`20222023Подкласс [`NodeVisitor`](https://python-all.ru/3.11/library/ast.html#ast.NodeVisitor), который обходит абстрактное синтаксическое дерево и позволяет изменять узлы.20242025Метод [`NodeTransformer`](https://python-all.ru/3.11/library/ast.html#ast.NodeTransformer) обходит AST и использует возвращаемое значение методов-посетителей для замены или удаления старого узла. Если возвращаемое значение метода-посетителя равно `None`, узел будет удалён из своего местоположения; в противном случае он заменяется возвращённым значением. Возвращённое значение может быть исходным узлом – в этом случае замена не происходит.20262027Вот пример преобразователя, который переписывает все обращения к именам (`foo`) в `data['foo']`:20282029```python2030class RewriteName(NodeTransformer):20312032    def visit_Name(self, node):2033        return Subscript(2034            value=Name(id='data', ctx=Load()),2035            slice=Constant(value=node.id),2036            ctx=node.ctx2037        )2038```20392040Имейте в виду: если у узла, с которым вы работаете, есть дочерние узлы, необходимо либо преобразовать дочерние узлы самостоятельно, либо сначала вызвать для узла метод [`generic_visit()`](https://python-all.ru/3.11/library/ast.html#ast.NodeVisitor.generic_visit).20412042Для узлов, входящих в состав набора инструкций (это относится ко всем узлам инструкций), посетитель может также возвращать список узлов, а не один узел.20432044Если [`NodeTransformer`](https://python-all.ru/3.11/library/ast.html#ast.NodeTransformer) вводит новые узлы (не входившие в исходное дерево) без указания информации о расположении (например, [`lineno`](https://python-all.ru/3.11/library/ast.html#ast.AST.lineno)), следует вызвать [`fix_missing_locations()`](https://python-all.ru/3.11/library/ast.html#ast.fix_missing_locations) для нового поддерева, чтобы пересчитать информацию о расположении:20452046```python2047tree = ast.parse('foo', mode='eval')2048new_tree = fix_missing_locations(RewriteName().visit(tree))2049```20502051Обычно преобразователь используется следующим образом:20522053```python2054node = YourTransformer().visit(node)2055```20562057#### `ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None)`20582059Возвращает форматированный дамп дерева из *node*. Это в основном полезно для отладки. Если *annotate\_fields* равно true (по умолчанию), возвращаемая строка будет показывать имена и значения полей. Если *annotate\_fields* равно false, результирующая строка будет более компактной за счёт опускания однозначных имён полей. Атрибуты, такие как номера строк и смещения столбцов, по умолчанию не выводятся. Если это нужно, *include\_attributes* можно установить в true.20602061Если *indent* – неотрицательное целое число или строка, дерево будет выведено с отступами указанного уровня. Уровень отступа 0, отрицательное значение или `""` вставляет только переводы строк. `None` (по умолчанию) выбирает однострочное представление. Положительный целочисленный отступ добавляет соответствующее количество пробелов на уровень. Если *indent* – строка (например, `"\t"`), эта строка используется для отступа каждого уровня.20622063Изменено в версии 3.9: Добавлена опция *indent*.20642065## Флаги компилятора20662067Следующие флаги могут быть переданы в [`compile()`](https://python-all.ru/3.11/library/functions.html#compile) для изменения эффектов компиляции программы:20682069#### `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`20702071Включает поддержку `await`, `async for`, `async with` и асинхронных включений верхнего уровня.20722073Новое в версии 3.8.20742075#### `ast.PyCF_ONLY_AST`20762077Генерирует и возвращает абстрактное синтаксическое дерево вместо скомпилированного объекта кода.20782079#### `ast.PyCF_TYPE_COMMENTS`20802081Включает поддержку комментариев типов в стиле [**PEP 484**](https://python-all.ru/3.11/library/ast.html) и [**PEP 526**](https://python-all.ru/3.11/library/ast.html) (`# type: <type>`, `# type: ignore <stuff>`).20822083Новое в версии 3.8.20842085## Использование командной строки20862087Новое в версии 3.9.20882089Модуль [`ast`](https://python-all.ru/3.11/library/ast.html#module-ast) может быть выполнен как скрипт из командной строки. Это просто:20902091```sh2092python -m ast [-m <mode>] [-a] [infile]2093```20942095Принимаются следующие опции:20962097#### `-h, --help`20982099Показать справку и выйти.21002101#### `-m <mode>`21022103#### `--mode <mode>`21042105Определяет, какой вид кода должен быть скомпилирован, как аргумент *mode* в [`parse()`](https://python-all.ru/3.11/library/ast.html#ast.parse).21062107#### `--no-type-comments`21082109Не обрабатывать комментарии типов.21102111#### `-a, --include-attributes`21122113Включать атрибуты, такие как номера строк и смещения столбцов.21142115#### `-i <indent>`21162117#### `--indent <indent>`21182119Отступ узлов в AST (количество пробелов).21202121Если указан `infile`, его содержимое разбирается в AST и выводится в stdout. В противном случае содержимое читается из stdin.21222123> **См. также**2124>2125> [Green Tree Snakes](https://python-all.ru/3.11/library/ast.html) – внешний документационный ресурс, содержащий подробности работы с AST Python.2126>2127> [ASTTokens](https://python-all.ru/3.11/library/ast.html) дополняет AST Python позициями токенов и текста в исходном коде, который их породил. Это полезно для инструментов, выполняющих преобразования исходного кода.2128>2129> [leoAst.py](https://python-all.ru/3.11/library/ast.html) объединяет представления программ на Python на основе токенов и синтаксических деревьев, вставляя двусторонние связи между токенами и узлами AST.2130>2131> [LibCST](https://python-all.ru/3.11/library/ast.html) разбирает код как конкретное синтаксическое дерево, похожее на AST, и сохраняет все детали форматирования. Это полезно для создания приложений автоматического рефакторинга (codemod) и линтеров.2132>2133> [Parso](https://python-all.ru/3.11/library/ast.html) – это синтаксический анализатор Python, поддерживающий восстановление после ошибок и сквозной разбор для разных версий Python (на нескольких версиях Python). Parso также может перечислять несколько синтаксических ошибок в файле Python.2134