ast.md
1> **Источник:** https://python-all.ru/3/library/ast.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# `ast` – Абстрактные синтаксические деревья89**Исходный код:** [Lib/ast.py](https://python-all.ru/src/3.14/Lib/ast.py)1011---1213Модуль `ast` помогает приложениям Python обрабатывать деревья абстрактного синтаксиса языка Python. Абстрактный синтаксис может меняться от версии к версии; с помощью этого модуля можно программно узнать, как выглядит текущая грамматика.1415Абстрактное синтаксическое дерево можно создать, передав [`ast.PyCF_ONLY_AST`](https://python-all.ru/3/library/ast.html#ast.PyCF_ONLY_AST) в качестве флага встроенной функции [`compile()`](https://python-all.ru/3/library/functions.html#compile) или используя вспомогательную функцию [`parse()`](https://python-all.ru/3/library/ast.html#ast.parse) из этого модуля. Результатом будет дерево объектов, классы которых наследуют от [`ast.AST`](https://python-all.ru/3/library/ast.html#ast.AST). Абстрактное синтаксическое дерево можно скомпилировать в объект кода Python с помощью встроенной функции `compile()`.1617## Абстрактная грамматика1819Абстрактная грамматика в настоящее время определяется следующим образом:2021```asdl22-- Встроенные типы ASDL:23-- идентификатор, целое, строка, константа2425module Python26{27 mod = Module(stmt* body, type_ignore* type_ignores)28 | Interactive(stmt* body)29 | Expression(expr body)30 | FunctionType(expr* argtypes, expr returns)3132 stmt = FunctionDef(identifier name, arguments args,33 stmt* body, expr* decorator_list, expr? returns,34 string? type_comment, type_param* type_params)35 | AsyncFunctionDef(identifier name, arguments args,36 stmt* body, expr* decorator_list, expr? returns,37 string? type_comment, type_param* type_params)3839 | ClassDef(identifier name,40 expr* bases,41 keyword* keywords,42 stmt* body,43 expr* decorator_list,44 type_param* type_params)45 | Return(expr? value)4647 | Delete(expr* targets)48 | Assign(expr* targets, expr value, string? type_comment)49 | TypeAlias(expr name, type_param* type_params, expr value)50 | AugAssign(expr target, operator op, expr value)51 -- 'simple' указывает, что аннотируется простое имя без скобок52 | AnnAssign(expr target, expr annotation, expr? value, int simple)5354 -- используется 'orelse', так как else – ключевое слово в целевых языках55 | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)56 | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)57 | While(expr test, stmt* body, stmt* orelse)58 | If(expr test, stmt* body, stmt* orelse)59 | With(withitem* items, stmt* body, string? type_comment)60 | AsyncWith(withitem* items, stmt* body, string? type_comment)6162 | Match(expr subject, match_case* cases)6364 | Raise(expr? exc, expr? cause)65 | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)66 | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)67 | Assert(expr test, expr? msg)6869 | Import(alias* names)70 | ImportFrom(identifier? module, alias* names, int? level)7172 | Global(identifier* names)73 | Nonlocal(identifier* names)74 | Expr(expr value)75 | Pass | Break | Continue7677 -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером78 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)7980 -- BoolOp() может использовать left и right?81 expr = BoolOp(boolop op, expr* values)82 | NamedExpr(expr target, expr value)83 | BinOp(expr left, operator op, expr right)84 | UnaryOp(unaryop op, expr operand)85 | Lambda(arguments args, expr body)86 | IfExp(expr test, expr body, expr orelse)87 | Dict(expr?* keys, expr* values)88 | Set(expr* elts)89 | ListComp(expr elt, comprehension* generators)90 | SetComp(expr elt, comprehension* generators)91 | DictComp(expr key, expr value, comprehension* generators)92 | GeneratorExp(expr elt, comprehension* generators)93 -- грамматика ограничивает, где могут встречаться выражения yield94 | Await(expr value)95 | Yield(expr? value)96 | YieldFrom(expr value)97 -- нужны последовательности для сравнения, чтобы различать98 -- x < 4 < 3 and (x < 4) < 399 | Compare(expr left, cmpop* ops, expr* comparators)100 | Call(expr func, expr* args, keyword* keywords)101 | FormattedValue(expr value, int conversion, expr? format_spec)102 | Interpolation(expr value, constant str, int conversion, expr? format_spec)103 | JoinedStr(expr* values)104 | TemplateStr(expr* values)105 | Constant(constant value, string? kind)106107 -- следующее выражение может появляться в контексте присваивания108 | Attribute(expr value, identifier attr, expr_context ctx)109 | Subscript(expr value, expr slice, expr_context ctx)110 | Starred(expr value, expr_context ctx)111 | Name(identifier id, expr_context ctx)112 | List(expr* elts, expr_context ctx)113 | Tuple(expr* elts, expr_context ctx)114115 -- может встречаться только в Subscript116 | Slice(expr? lower, expr? upper, expr? step)117118 -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером119 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)120121 expr_context = Load | Store | Del122123 boolop = And | Or124125 operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift126 | RShift | BitOr | BitXor | BitAnd | FloorDiv127128 unaryop = Invert | Not | UAdd | USub129130 cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn131132 comprehension = (expr target, expr iter, expr* ifs, int is_async)133134 excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)135 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)136137 arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,138 expr?* kw_defaults, arg? kwarg, expr* defaults)139140 arg = (identifier arg, expr? annotation, string? type_comment)141 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)142143 -- ключевые аргументы, переданные вызову (идентификатор NULL для **kwargs)144 keyword = (identifier? arg, expr value)145 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)146147 -- имя импорта с необязательным псевдонимом 'as'148 alias = (identifier name, identifier? asname)149 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)150151 withitem = (expr context_expr, expr? optional_vars)152153 match_case = (pattern pattern, expr? guard, stmt* body)154155 pattern = MatchValue(expr value)156 | MatchSingleton(constant value)157 | MatchSequence(pattern* patterns)158 | MatchMapping(expr* keys, pattern* patterns, identifier? rest)159 | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)160161 | MatchStar(identifier? name)162 -- необязательный параметр "rest" MatchMapping обрабатывает захват дополнительных ключей отображения163164 | MatchAs(pattern? pattern, identifier? name)165 | MatchOr(pattern* patterns)166167 attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)168169 type_ignore = TypeIgnore(int lineno, string tag)170171 type_param = TypeVar(identifier name, expr? bound, expr? default_value)172 | ParamSpec(identifier name, expr? default_value)173 | TypeVarTuple(identifier name, expr? default_value)174 attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)175}176```177178## Классы узлов179180#### `class ast.AST`181182Это базовый класс для всех узлов AST. Реальные классы узлов унаследованы из файла `Parser/Python.asdl`, который воспроизведён [выше](https://python-all.ru/3/library/ast.html#abstract-grammar). Они определены в C-модуле `_ast` и повторно экспортируются в `ast`.183184Для каждого символа левой части абстрактной грамматики определён один класс (например, `ast.stmt` или `ast.expr`). Кроме того, для каждого конструктора правой части определён один класс; эти классы наследуют от классов для деревьев левой части. Например, [`ast.BinOp`](https://python-all.ru/3/library/ast.html#ast.BinOp) наследует от `ast.expr`. Для продукционных правил с альтернативами (так называемых «сумм») класс левой части является абстрактным: создаются только экземпляры конкретных узлов-конструкторов.185186#### `_fields`187188Каждый конкретный класс имеет атрибут `_fields`, который содержит имена всех дочерних узлов.189190Каждый экземпляр конкретного класса имеет по одному атрибуту для каждого дочернего узла, тип которого определён в грамматике. Например, экземпляры [`ast.BinOp`](https://python-all.ru/3/library/ast.html#ast.BinOp) имеют атрибут `left` типа `ast.expr`.191192Если эти атрибуты помечены как необязательные в грамматике (с помощью вопросительного знака), значением может быть `None`. Если атрибуты могут иметь ноль или более значений (помечены звёздочкой), значения представляются в виде списков Python. Все возможные атрибуты должны присутствовать и иметь корректные значения при компиляции AST с помощью [`compile()`](https://python-all.ru/3/library/functions.html#compile).193194#### `_field_types`195196Атрибут `_field_types` каждого конкретного класса представляет собой словарь, отображающий имена полей (как указано в [`_fields`](https://python-all.ru/3/library/ast.html#ast.AST._fields)) в их типы.197198```pycon199>>> ast.TypeVar._field_types200{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr | None}201```202203Добавлено в версии 3.13.204205#### `lineno`206207#### `col_offset`208209#### `end_lineno`210211#### `end_col_offset`212213Экземпляры подклассов `ast.expr` и `ast.stmt` имеют атрибуты [`lineno`](https://python-all.ru/3/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3/library/ast.html#ast.AST.end_col_offset). Атрибуты `lineno` и `end_lineno` – это номер первой и последней строки исходного текста (нумерация с 1, то есть первая строка – строка 1), а `col_offset` и `end_col_offset` – соответствующие смещения в байтах UTF-8 от первого и последнего токенов, породивших узел. Смещение UTF-8 записывается, потому что парсер использует UTF-8 внутри.214215Обратите внимание, что конечные позиции не требуются компилятором и поэтому являются необязательными. Смещение конца находится *после* последнего символа, например, можно получить фрагмент исходного кода узла выражения из одной строки с помощью `source_line[node.col_offset : node.end_col_offset]`.216217Конструктор класса `ast.T` разбирает свои аргументы следующим образом:218219- Если есть позиционные аргументы, их должно быть столько же, сколько элементов в `T._fields`; они будут присвоены как атрибуты с этими именами.220- Если есть ключевые аргументы, они установят атрибуты с теми же именами в указанные значения.221222Например, чтобы создать и заполнить узел [`ast.UnaryOp`](https://python-all.ru/3/library/ast.html#ast.UnaryOp), можно использовать223224```python225node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),226 lineno=0, col_offset=0)227```228229Если поле, которое является необязательным в грамматике, опущено в конструкторе, оно по умолчанию равно `None`. Если опущено поле-список, оно по умолчанию равно пустому списку. Если опущено поле типа `ast.expr_context`, оно по умолчанию равно [`Load()`](https://python-all.ru/3/library/ast.html#ast.Load). Если опущено любое другое поле, возбуждается [`DeprecationWarning`](https://python-all.ru/3/library/exceptions.html#DeprecationWarning) и узел AST не будет иметь этого поля. В Python 3.15 это условие будет вызывать ошибку.230231Изменено в версии 3.8: Класс [`ast.Constant`](https://python-all.ru/3/library/ast.html#ast.Constant) теперь используется для всех констант.232233Изменено в версии 3.9: Простые индексы представляются своим значением, расширенные срезы представляются кортежами.234235Изменено в версии 3.13: Конструкторы узлов AST были изменены, чтобы предоставлять разумные значения по умолчанию для пропущенных полей: необязательные поля теперь по умолчанию равны `None`, поля-списки по умолчанию равны пустому списку, а поля типа `ast.expr_context` по умолчанию равны [`Load()`](https://python-all.ru/3/library/ast.html#ast.Load). Ранее пропущенные атрибуты отсутствовали у сконструированных узлов (при обращении к ним возбуждалось [`AttributeError`](https://python-all.ru/3/library/exceptions.html#AttributeError)).236237Изменено в версии 3.14: В выводе [`__repr__()`](https://python-all.ru/3/reference/datamodel.html#object.__repr__) узлов [`AST`](https://python-all.ru/3/library/ast.html#ast.AST) теперь содержатся значения полей узла.238239Устарело с версии 3.8, удалено в версии 3.14: В предыдущих версиях Python были доступны классы AST `ast.Num`, `ast.Str`, `ast.Bytes`, `ast.NameConstant` и `ast.Ellipsis`, которые объявлялись устаревшими в Python 3.8. Эти классы были удалены в Python 3.14, а их функциональность заменена на [`ast.Constant`](https://python-all.ru/3/library/ast.html#ast.Constant).240241Устарело с версии 3.9: Старые классы `ast.Index` и `ast.ExtSlice` всё ещё доступны, но будут удалены в будущих выпусках Python. При этом при их создании будет возвращён экземпляр другого класса.242243Устарело с версии 3.13, будет удалено в версии 3.15: В предыдущих версиях Python допускалось создание узлов AST с отсутствующими обязательными полями. Кроме того, конструкторы узлов AST принимали произвольные ключевые аргументы, которые устанавливались как атрибуты узла AST, даже если они не соответствовали ни одному из полей узла AST. Это поведение устарело и будет удалено в Python 3.15.244245> **Примечание**246>247> Описания конкретных классов узлов, приведённые здесь, изначально были адаптированы из замечательного проекта [Green Tree Snakes](https://python-all.ru/3/library/ast.html) и всех его участников.248249### Корневые узлы250251#### `class ast.Module(body, type_ignores)`252253A Python module, as with [file input](https://python-all.ru/3/reference/toplevel_components.html#file-input). Node type generated by [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse) in the default `"exec"` *mode*.254255`body` is a [`list`](https://python-all.ru/3/library/stdtypes.html#list) of the module’s [Statements](https://python-all.ru/3/library/ast.html#ast-statements).256257`type_ignores` – это список [`list`](https://python-all.ru/3/library/stdtypes.html#list) комментариев об игнорировании типов в модуле; подробнее см. в [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse).258259```pycon260>>> print(ast.dump(ast.parse('x = 1'), indent=4))261Module(262 body=[263 Assign(264 targets=[265 Name(id='x', ctx=Store())],266 value=Constant(value=1))])267```268269#### `class ast.Expression(body)`270271A single Python [expression input](https://python-all.ru/3/reference/toplevel_components.html#expression-input). Node type generated by [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse) when *mode* is `"eval"`.272273`body` is a single node, one of the [expression types](https://python-all.ru/3/library/ast.html#ast-expressions).274275```pycon276>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))277Expression(278 body=Constant(value=123))279```280281#### `class ast.Interactive(body)`282283A single [interactive input](https://python-all.ru/3/reference/toplevel_components.html#interactive), like in [Interactive Mode](https://python-all.ru/3/tutorial/appendix.html#tut-interac). Node type generated by [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse) when *mode* is `"single"`.284285`body` is a [`list`](https://python-all.ru/3/library/stdtypes.html#list) of [statement nodes](https://python-all.ru/3/library/ast.html#ast-statements).286287```pycon288>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))289Interactive(290 body=[291 Assign(292 targets=[293 Name(id='x', ctx=Store())],294 value=Constant(value=1)),295 Assign(296 targets=[297 Name(id='y', ctx=Store())],298 value=Constant(value=2))])299```300301#### `class ast.FunctionType(argtypes, returns)`302303A 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/library/ast.html) annotations. Node type generated by [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse) when *mode* is `"func_type"`.304305Такие комментарии о типах выглядели следующим образом:306307```python308def sum_two_number(a, b):309 # type: (int, int) -> int310 return a + b311```312313`argtypes` is a [`list`](https://python-all.ru/3/library/stdtypes.html#list) of [expression nodes](https://python-all.ru/3/library/ast.html#ast-expressions).314315`returns` is a single [expression node](https://python-all.ru/3/library/ast.html#ast-expressions).316317```pycon318>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))319FunctionType(320 argtypes=[321 Name(id='int', ctx=Load()),322 Name(id='str', ctx=Load())],323 returns=Subscript(324 value=Name(id='List', ctx=Load()),325 slice=Name(id='int', ctx=Load()),326 ctx=Load()))327```328329Добавлено в версии 3.8.330331### Литералы332333#### `class ast.Constant(value, kind)`334335Постоянное значение. Атрибут `value` `Constant` литерала содержит представляемый объект Python. Представленными значениями могут быть экземпляры [`str`](https://python-all.ru/3/library/stdtypes.html#str), [`bytes`](https://python-all.ru/3/library/stdtypes.html#bytes), [`int`](https://python-all.ru/3/library/functions.html#int), [`float`](https://python-all.ru/3/library/functions.html#float), [`complex`](https://python-all.ru/3/library/functions.html#complex) и [`bool`](https://python-all.ru/3/library/functions.html#bool), а также константы [`None`](https://python-all.ru/3/library/constants.html#None) и [`Ellipsis`](https://python-all.ru/3/library/constants.html#Ellipsis).336337Атрибут `kind` – необязательная строка. Для строковых литералов с префиксом `u` значение `kind` устанавливается в `'u'`. Для всех остальных констант `kind` равно `None`.338339```pycon340>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))341Expression(342 body=Constant(value=123))343>>> print(ast.dump(ast.parse("u'hello'", mode='eval'), indent=4))344Expression(345 body=Constant(value='hello', kind='u'))346```347348#### `class ast.FormattedValue(value, conversion, format_spec)`349350Узел, представляющий одно поле форматирования в f-строке. Если строка содержит только одно поле форматирования и больше ничего, узел может быть изолированным; в противном случае он встречается внутри [`JoinedStr`](https://python-all.ru/3/library/ast.html#ast.JoinedStr).351352- `value` – это любой узел выражения (например, литерал, переменная или вызов функции).353- `conversion` – целое число:354355 - -1: без форматирования356 - 97 (`ord('a')`): форматирование `!a` [`ASCII`](https://python-all.ru/3/library/functions.html#ascii)357 - 114 (`ord('r')`): форматирование `!r` [`repr()`](https://python-all.ru/3/library/functions.html#repr)358 - 115 (`ord('s')`): форматирование `!s` [`string`](https://python-all.ru/3/library/stdtypes.html#str)359- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно.360361#### `class ast.JoinedStr(values)`362363F-строка, содержащая последовательность [`FormattedValue`](https://python-all.ru/3/library/ast.html#ast.FormattedValue) и [`Constant`](https://python-all.ru/3/library/ast.html#ast.Constant) узлов.364365```pycon366>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))367Expression(368 body=JoinedStr(369 values=[370 Constant(value='sin('),371 FormattedValue(372 value=Name(id='a', ctx=Load()),373 conversion=-1),374 Constant(value=') is '),375 FormattedValue(376 value=Call(377 func=Name(id='sin', ctx=Load()),378 args=[379 Name(id='a', ctx=Load())]),380 conversion=-1,381 format_spec=JoinedStr(382 values=[383 Constant(value='.3')]))]))384```385386#### `class ast.TemplateStr(values, /)`387388Добавлено в версии 3.14.389390Узел, представляющий литерал шаблонной строки, содержащий последовательность [`Interpolation`](https://python-all.ru/3/library/ast.html#ast.Interpolation) и [`Constant`](https://python-all.ru/3/library/ast.html#ast.Constant) узлов. Эти узлы могут быть в любом порядке и не обязаны чередоваться.391392```pycon393>>> expr = ast.parse('t"{name} finished {place:ordinal}"', mode='eval')394>>> print(ast.dump(expr, indent=4))395Expression(396 body=TemplateStr(397 values=[398 Interpolation(399 value=Name(id='name', ctx=Load()),400 str='name',401 conversion=-1),402 Constant(value=' finished '),403 Interpolation(404 value=Name(id='place', ctx=Load()),405 str='place',406 conversion=-1,407 format_spec=JoinedStr(408 values=[409 Constant(value='ordinal')]))]))410```411412#### `class ast.Interpolation(value, str, conversion, format_spec=None)`413414Добавлено в версии 3.14.415416Узел, представляющий одно поле интерполяции в литерале шаблонной строки.417418- `value` – любой узел выражения (например, литерал, переменная или вызов функции). Это имеет то же значение, что и `FormattedValue.value`.419- `str` – константа, содержащая текст выражения интерполяции.420421 Если `str` установлен в `None`, то `value` используется для генерации кода при вызове [`ast.unparse()`](https://python-all.ru/3/library/ast.html#ast.unparse). Это больше не гарантирует, что сгенерированный код идентичен исходному, и предназначено для генерации кода.422- `conversion` – целое число:423424 - -1: без преобразования425 - 97 (`ord('a')`): преобразование `!a` [`ASCII`](https://python-all.ru/3/library/functions.html#ascii)426 - 114 (`ord('r')`): преобразование `!r` [`repr()`](https://python-all.ru/3/library/functions.html#repr)427 - 115 (`ord('s')`): преобразование `!s` [`string`](https://python-all.ru/3/library/stdtypes.html#str)428429 Это имеет то же значение, что и `FormattedValue.conversion`.430- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно. Это имеет то же значение, что и `FormattedValue.format_spec`.431432#### `class ast.List(elts, ctx)`433434#### `class ast.Tuple(elts, ctx)`435436Список или кортеж. `elts` содержит список узлов, представляющих элементы. `ctx` равен [`Store`](https://python-all.ru/3/library/ast.html#ast.Store), если контейнер является целью присваивания (т.е. `(x,y)=something`), и [`Load`](https://python-all.ru/3/library/ast.html#ast.Load) в противном случае.437438```pycon439>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))440Expression(441 body=List(442 elts=[443 Constant(value=1),444 Constant(value=2),445 Constant(value=3)],446 ctx=Load()))447>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))448Expression(449 body=Tuple(450 elts=[451 Constant(value=1),452 Constant(value=2),453 Constant(value=3)],454 ctx=Load()))455```456457#### `class ast.Set(elts)`458459Множество. `elts` содержит список узлов, представляющих элементы множества.460461```pycon462>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))463Expression(464 body=Set(465 elts=[466 Constant(value=1),467 Constant(value=2),468 Constant(value=3)]))469```470471#### `class ast.Dict(keys, values)`472473Словарь. `keys` и `values` содержат списки узлов, представляющих ключи и значения соответственно, в соответствующем порядке (то, что было бы возвращено при вызове `dictionary.keys()` и `dictionary.values()`).474475При распаковке словаря с помощью литералов словаря выражение, которое нужно раскрыть, помещается в список `values`, а `None` – на соответствующую позицию в `keys`.476477```pycon478>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))479Expression(480 body=Dict(481 keys=[482 Constant(value='a'),483 None],484 values=[485 Constant(value=1),486 Name(id='d', ctx=Load())]))487```488489### Переменные490491#### `class ast.Name(id, ctx)`492493Имя переменной. `id` содержит имя в виде строки, а `ctx` – один из следующих типов.494495#### `class ast.Load`496497#### `class ast.Store`498499#### `class ast.Del`500501Ссылки на переменные можно использовать для загрузки значения переменной, для присваивания ей нового значения или для её удаления. Ссылки на переменные получают контекст, чтобы различать эти случаи.502503```pycon504>>> print(ast.dump(ast.parse('a'), indent=4))505Module(506 body=[507 Expr(508 value=Name(id='a', ctx=Load()))])509510>>> print(ast.dump(ast.parse('a = 1'), indent=4))511Module(512 body=[513 Assign(514 targets=[515 Name(id='a', ctx=Store())],516 value=Constant(value=1))])517518>>> print(ast.dump(ast.parse('del a'), indent=4))519Module(520 body=[521 Delete(522 targets=[523 Name(id='a', ctx=Del())])])524```525526#### `class ast.Starred(value, ctx)`527528Ссылка на переменную `*var`. В `value` хранится переменная, обычно узел [`Name`](https://python-all.ru/3/library/ast.html#ast.Name). Этот тип необходимо использовать при построении узла [`Call`](https://python-all.ru/3/library/ast.html#ast.Call) с помощью `*args`.529530```pycon531>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))532Module(533 body=[534 Assign(535 targets=[536 Tuple(537 elts=[538 Name(id='a', ctx=Store()),539 Starred(540 value=Name(id='b', ctx=Store()),541 ctx=Store())],542 ctx=Store())],543 value=Name(id='it', ctx=Load()))])544```545546### Выражения547548#### `class ast.Expr(value)`549550Когда выражение, например вызов функции, выступает в роли самостоятельного оператора и его возвращаемое значение не используется и не сохраняется, оно помещается в этот контейнер. `value` содержит один из остальных узлов этого раздела: узел [`Constant`](https://python-all.ru/3/library/ast.html#ast.Constant), узел [`Name`](https://python-all.ru/3/library/ast.html#ast.Name), [`Lambda`](https://python-all.ru/3/library/ast.html#ast.Lambda), [`Yield`](https://python-all.ru/3/library/ast.html#ast.Yield) или [`YieldFrom`](https://python-all.ru/3/library/ast.html#ast.YieldFrom).551552```pycon553>>> print(ast.dump(ast.parse('-a'), indent=4))554Module(555 body=[556 Expr(557 value=UnaryOp(558 op=USub(),559 operand=Name(id='a', ctx=Load())))])560```561562#### `class ast.UnaryOp(op, operand)`563564Унарная операция. `op` – оператор, а `operand` – любой узел выражения.565566#### `class ast.UAdd`567568#### `class ast.USub`569570#### `class ast.Not`571572#### `class ast.Invert`573574Токены унарных операторов. `Not` – ключевое слово `not`, `Invert` – оператор `~`.575576```pycon577>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))578Expression(579 body=UnaryOp(580 op=Not(),581 operand=Name(id='x', ctx=Load())))582```583584#### `class ast.BinOp(left, op, right)`585586Бинарная операция (например, сложение или деление). `op` – оператор, а `left` и `right` – любые узлы выражений.587588```pycon589>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))590Expression(591 body=BinOp(592 left=Name(id='x', ctx=Load()),593 op=Add(),594 right=Name(id='y', ctx=Load())))595```596597#### `class ast.Add`598599#### `class ast.Sub`600601#### `class ast.Mult`602603#### `class ast.Div`604605#### `class ast.FloorDiv`606607#### `class ast.Mod`608609#### `class ast.Pow`610611#### `class ast.LShift`612613#### `class ast.RShift`614615#### `class ast.BitOr`616617#### `class ast.BitXor`618619#### `class ast.BitAnd`620621#### `class ast.MatMult`622623Токены бинарных операторов.624625#### `class ast.BoolOp(op, values)`626627Логическая операция – 'or' или 'and'. `op` – это [`Or`](https://python-all.ru/3/library/ast.html#ast.Or) или [`And`](https://python-all.ru/3/library/ast.html#ast.And). `values` – участвующие значения. Последовательные операции с одним и тем же оператором, например `a or b or c`, сводятся в один узел с несколькими значениями.628629Это не включает `not`, который является [`UnaryOp`](https://python-all.ru/3/library/ast.html#ast.UnaryOp).630631```pycon632>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))633Expression(634 body=BoolOp(635 op=Or(),636 values=[637 Name(id='x', ctx=Load()),638 Name(id='y', ctx=Load())]))639```640641#### `class ast.And`642643#### `class ast.Or`644645Токены логических операторов.646647#### `class ast.Compare(left, ops, comparators)`648649Сравнение двух или более значений. `left` – первое значение в сравнении, `ops` – список операторов, а `comparators` – список значений после первого элемента сравнения.650651```pycon652>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))653Expression(654 body=Compare(655 left=Constant(value=1),656 ops=[657 LtE(),658 Lt()],659 comparators=[660 Name(id='a', ctx=Load()),661 Constant(value=10)]))662```663664#### `class ast.Eq`665666#### `class ast.NotEq`667668#### `class ast.Lt`669670#### `class ast.LtE`671672#### `class ast.Gt`673674#### `class ast.GtE`675676#### `class ast.Is`677678#### `class ast.IsNot`679680#### `class ast.In`681682#### `class ast.NotIn`683684Токены операторов сравнения.685686#### `class ast.Call(func, args, keywords)`687688Вызов функции. `func` – это функция; обычно это объект [`Name`](https://python-all.ru/3/library/ast.html#ast.Name) или [`Attribute`](https://python-all.ru/3/library/ast.html#ast.Attribute). Об аргументах:689690- `args` содержит список аргументов, переданных по позиции.691- `keywords` содержит список объектов [`keyword`](https://python-all.ru/3/library/ast.html#ast.keyword), представляющих аргументы, переданные по ключевому слову.692693Аргументы `args` и `keywords` необязательны и по умолчанию равны пустым спискам.694695```pycon696>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))697Expression(698 body=Call(699 func=Name(id='func', ctx=Load()),700 args=[701 Name(id='a', ctx=Load()),702 Starred(703 value=Name(id='d', ctx=Load()),704 ctx=Load())],705 keywords=[706 keyword(707 arg='b',708 value=Name(id='c', ctx=Load())),709 keyword(710 value=Name(id='e', ctx=Load()))]))711```712713#### `class ast.keyword(arg, value)`714715Именованный аргумент вызова функции или определения класса. `arg` – это необработанная строка с именем параметра, `value` – узел, который нужно передать.716717#### `class ast.IfExp(test, body, orelse)`718719Выражение, например `a if b else c`. Каждое поле содержит один узел, поэтому в следующем примере все три являются узлами [`Name`](https://python-all.ru/3/library/ast.html#ast.Name).720721```pycon722>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))723Expression(724 body=IfExp(725 test=Name(id='b', ctx=Load()),726 body=Name(id='a', ctx=Load()),727 orelse=Name(id='c', ctx=Load())))728```729730#### `class ast.Attribute(value, attr, ctx)`731732Доступ к атрибуту, например `d.keys`. `value` – это узел, обычно [`Name`](https://python-all.ru/3/library/ast.html#ast.Name). `attr` – это строка с именем атрибута, а `ctx` – [`Load`](https://python-all.ru/3/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3/library/ast.html#ast.Del) в зависимости от того, как используется атрибут.733734```pycon735>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))736Expression(737 body=Attribute(738 value=Name(id='snake', ctx=Load()),739 attr='colour',740 ctx=Load()))741```742743#### `class ast.NamedExpr(target, value)`744745Именованное выражение. Этот узел AST создаётся оператором присваивания (также известным как оператор «морж»). В отличие от узла [`Assign`](https://python-all.ru/3/library/ast.html#ast.Assign), где первый аргумент может быть несколькими узлами, в данном случае и `target`, и `value` должны быть одиночными узлами.746747```pycon748>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))749Expression(750 body=NamedExpr(751 target=Name(id='x', ctx=Store()),752 value=Constant(value=4)))753```754755Добавлено в версии 3.8.756757#### Индексирование758759#### `class ast.Subscript(value, slice, ctx)`760761Индексация, такая как `l[1]`. `value` – индексируемый объект (обычно последовательность или отображение). `slice` – это индекс, срез или ключ. Оно может быть [`Tuple`](https://python-all.ru/3/library/ast.html#ast.Tuple) и содержать [`Slice`](https://python-all.ru/3/library/ast.html#ast.Slice). `ctx` является [`Load`](https://python-all.ru/3/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3/library/ast.html#ast.Del) в зависимости от выполняемого действия при индексации.762763```pycon764>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))765Expression(766 body=Subscript(767 value=Name(id='l', ctx=Load()),768 slice=Tuple(769 elts=[770 Slice(771 lower=Constant(value=1),772 upper=Constant(value=2)),773 Constant(value=3)],774 ctx=Load()),775 ctx=Load()))776```777778#### `class ast.Slice(lower, upper, step)`779780Обычный срез (в виде `lower:upper` или `lower:upper:step`). Может встречаться только внутри поля *slice* узла [`Subscript`](https://python-all.ru/3/library/ast.html#ast.Subscript), либо напрямую, либо как элемент [`Tuple`](https://python-all.ru/3/library/ast.html#ast.Tuple).781782```pycon783>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))784Expression(785 body=Subscript(786 value=Name(id='l', ctx=Load()),787 slice=Slice(788 lower=Constant(value=1),789 upper=Constant(value=2)),790 ctx=Load()))791```792793#### Генераторы коллекций794795#### `class ast.ListComp(elt, generators)`796797#### `class ast.SetComp(elt, generators)`798799#### `class ast.GeneratorExp(elt, generators)`800801#### `class ast.DictComp(key, value, generators)`802803Генераторы списков и множеств, генераторные выражения и генераторы словарей. `elt` (или `key` и `value`) – это один узел, представляющий часть, которая будет вычисляться для каждого элемента.804805`generators` – это список узлов [`comprehension`](https://python-all.ru/3/library/ast.html#ast.comprehension).806807```pycon808>>> print(ast.dump(809... ast.parse('[x for x in numbers]', mode='eval'),810... indent=4,811... ))812Expression(813 body=ListComp(814 elt=Name(id='x', ctx=Load()),815 generators=[816 comprehension(817 target=Name(id='x', ctx=Store()),818 iter=Name(id='numbers', ctx=Load()),819 is_async=0)]))820>>> print(ast.dump(821... ast.parse('{x: x**2 for x in numbers}', mode='eval'),822... indent=4,823... ))824Expression(825 body=DictComp(826 key=Name(id='x', ctx=Load()),827 value=BinOp(828 left=Name(id='x', ctx=Load()),829 op=Pow(),830 right=Constant(value=2)),831 generators=[832 comprehension(833 target=Name(id='x', ctx=Store()),834 iter=Name(id='numbers', ctx=Load()),835 is_async=0)]))836>>> print(ast.dump(837... ast.parse('{x for x in numbers}', mode='eval'),838... indent=4,839... ))840Expression(841 body=SetComp(842 elt=Name(id='x', ctx=Load()),843 generators=[844 comprehension(845 target=Name(id='x', ctx=Store()),846 iter=Name(id='numbers', ctx=Load()),847 is_async=0)]))848```849850#### `class ast.comprehension(target, iter, ifs, is_async)`851852Одно предложение `for` в генераторе коллекции. `target` – это ссылка, используемая для каждого элемента (обычно узел [`Name`](https://python-all.ru/3/library/ast.html#ast.Name) или [`Tuple`](https://python-all.ru/3/library/ast.html#ast.Tuple)). `iter` – объект, по которому выполняется итерация. `ifs` – список проверочных выражений: каждое предложение `for` может содержать несколько `ifs`.853854`is_async` указывает, что генератор коллекции является асинхронным (использует `async for` вместо `for`). Значение – целое число (0 или 1).855856```pycon857>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),858... indent=4)) # несколько включений в одном859Expression(860 body=ListComp(861 elt=Call(862 func=Name(id='ord', ctx=Load()),863 args=[864 Name(id='c', ctx=Load())]),865 generators=[866 comprehension(867 target=Name(id='line', ctx=Store()),868 iter=Name(id='file', ctx=Load()),869 is_async=0),870 comprehension(871 target=Name(id='c', ctx=Store()),872 iter=Name(id='line', ctx=Load()),873 is_async=0)]))874875>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),876... indent=4)) # выражение-генератор877Expression(878 body=GeneratorExp(879 elt=BinOp(880 left=Name(id='n', ctx=Load()),881 op=Pow(),882 right=Constant(value=2)),883 generators=[884 comprehension(885 target=Name(id='n', ctx=Store()),886 iter=Name(id='it', ctx=Load()),887 ifs=[888 Compare(889 left=Name(id='n', ctx=Load()),890 ops=[891 Gt()],892 comparators=[893 Constant(value=5)]),894 Compare(895 left=Name(id='n', ctx=Load()),896 ops=[897 Lt()],898 comparators=[899 Constant(value=10)])],900 is_async=0)]))901902>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),903... indent=4)) # асинхронное включение904Expression(905 body=ListComp(906 elt=Name(id='i', ctx=Load()),907 generators=[908 comprehension(909 target=Name(id='i', ctx=Store()),910 iter=Name(id='soc', ctx=Load()),911 is_async=1)]))912```913914### Инструкции915916#### `class ast.Assign(targets, value, type_comment)`917918Присваивание. `targets` – список узлов, а `value` – один узел.919920Несколько узлов в `targets` обозначают присваивание одного и того же значения каждому. Распаковка представляется помещением узла [`Tuple`](https://python-all.ru/3/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3/library/ast.html#ast.List) внутрь `targets`.921922#### `type_comment`923924`type_comment` – это необязательная строка с аннотацией типа в виде комментария.925926```pycon927>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # множественное присваивание928Module(929 body=[930 Assign(931 targets=[932 Name(id='a', ctx=Store()),933 Name(id='b', ctx=Store())],934 value=Constant(value=1))])935936>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # распаковка937Module(938 body=[939 Assign(940 targets=[941 Tuple(942 elts=[943 Name(id='a', ctx=Store()),944 Name(id='b', ctx=Store())],945 ctx=Store())],946 value=Name(id='c', ctx=Load()))])947```948949#### `class ast.AnnAssign(target, annotation, value, simple)`950951Присваивание с аннотацией типа. `target` – это один узел, который может быть [`Name`](https://python-all.ru/3/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3/library/ast.html#ast.Subscript). `annotation` – аннотация, например узел [`Constant`](https://python-all.ru/3/library/ast.html#ast.Constant) или `Name`. `value` – один необязательный узел.952953`simple` всегда равен либо 0 (обозначает «сложную» цель), либо 1 (обозначает «простую» цель). «Простая» цель состоит только из узла [`Name`](https://python-all.ru/3/library/ast.html#ast.Name), который не находится в круглых скобках; все остальные цели считаются сложными. Только простые цели появляются в словаре [`__annotations__`](https://python-all.ru/3/reference/datamodel.html#object.__annotations__) модулей и классов.954955```pycon956>>> print(ast.dump(ast.parse('c: int'), indent=4))957Module(958 body=[959 AnnAssign(960 target=Name(id='c', ctx=Store()),961 annotation=Name(id='int', ctx=Load()),962 simple=1)])963964>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # аннотация со скобками965Module(966 body=[967 AnnAssign(968 target=Name(id='a', ctx=Store()),969 annotation=Name(id='int', ctx=Load()),970 value=Constant(value=1),971 simple=0)])972973>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # аннотация атрибута974Module(975 body=[976 AnnAssign(977 target=Attribute(978 value=Name(id='a', ctx=Load()),979 attr='b',980 ctx=Store()),981 annotation=Name(id='int', ctx=Load()),982 simple=0)])983984>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # аннотация подписки985Module(986 body=[987 AnnAssign(988 target=Subscript(989 value=Name(id='a', ctx=Load()),990 slice=Constant(value=1),991 ctx=Store()),992 annotation=Name(id='int', ctx=Load()),993 simple=0)])994```995996#### `class ast.AugAssign(target, op, value)`997998Расширенное присваивание, например `a += 1`. В следующем примере `target` – это узел [Имя](https://python-all.ru/3/library/ast.html#ast.Name) для `x` (с контекстом [`Store`](https://python-all.ru/3/library/ast.html#ast.Store)), `op` – это [Сложение](https://python-all.ru/3/library/ast.html#ast.Add), а `value` – это [Константа](https://python-all.ru/3/library/ast.html#ast.Constant) со значением 1.9991000Атрибут `target` не может быть класса [`Tuple`](https://python-all.ru/3/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3/library/ast.html#ast.List), в отличие от целей [`Assign`](https://python-all.ru/3/library/ast.html#ast.Assign).10011002```pycon1003>>> print(ast.dump(ast.parse('x += 2'), indent=4))1004Module(1005 body=[1006 AugAssign(1007 target=Name(id='x', ctx=Store()),1008 op=Add(),1009 value=Constant(value=2))])1010```10111012#### `class ast.Raise(exc, cause)`10131014Инструкция `raise`. `exc` – объект исключения, который необходимо возбудить, обычно [Вызов](https://python-all.ru/3/library/ast.html#ast.Call) или [Имя](https://python-all.ru/3/library/ast.html#ast.Name), или `None` для отдельного `raise`. `cause` – необязательная часть для `y` в `Возбуждение`.10151016```pycon1017>>> print(ast.dump(ast.parse('raise x from y'), indent=4))1018Module(1019 body=[1020 Raise(1021 exc=Name(id='x', ctx=Load()),1022 cause=Name(id='y', ctx=Load()))])1023```10241025#### `class ast.Assert(test, msg)`10261027Утверждение. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3/library/ast.html#ast.Compare). `msg` содержит сообщение об ошибке.10281029```pycon1030>>> print(ast.dump(ast.parse('assert x,y'), indent=4))1031Module(1032 body=[1033 Assert(1034 test=Name(id='x', ctx=Load()),1035 msg=Name(id='y', ctx=Load()))])1036```10371038#### `class ast.Delete(targets)`10391040Представляет инструкцию `del`. `targets` – список узлов, например узлов [`Name`](https://python-all.ru/3/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3/library/ast.html#ast.Subscript).10411042```pycon1043>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))1044Module(1045 body=[1046 Delete(1047 targets=[1048 Name(id='x', ctx=Del()),1049 Name(id='y', ctx=Del()),1050 Name(id='z', ctx=Del())])])1051```10521053#### `class ast.Pass`10541055Инструкция `pass`.10561057```pycon1058>>> print(ast.dump(ast.parse('pass'), indent=4))1059Module(1060 body=[1061 Pass()])1062```10631064#### `class ast.TypeAlias(name, type_params, value)`10651066[Псевдоним типа](https://python-all.ru/3/library/typing.html#type-aliases), созданный с помощью инструкции [`type`](https://python-all.ru/3/reference/simple_stmts.html#type) . `name` – имя псевдонима, `type_params` – список [параметров типа](https://python-all.ru/3/library/ast.html#ast-type-params), а `value` – значение псевдонима типа.10671068```pycon1069>>> print(ast.dump(ast.parse('type Alias = int'), indent=4))1070Module(1071 body=[1072 TypeAlias(1073 name=Name(id='Alias', ctx=Store()),1074 value=Name(id='int', ctx=Load()))])1075```10761077Добавлено в версии 3.12.10781079Другие инструкции, которые применимы только внутри функций или циклов, описаны в других разделах.10801081#### Импорты10821083#### `class ast.Import(names)`10841085Инструкция импорта. `names` – это список узлов [`alias`](https://python-all.ru/3/library/ast.html#ast.alias).10861087```pycon1088>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))1089Module(1090 body=[1091 Import(1092 names=[1093 alias(name='x'),1094 alias(name='y'),1095 alias(name='z')])])1096```10971098#### `class ast.ImportFrom(module, names, level)`10991100Представляет `from x import y`. `module` – это необработанная строка имени from, без начальных точек, или `None` для инструкций вроде `from . import foo`. `level` – целое число, указывающее уровень относительного импорта (0 означает абсолютный импорт).11011102```pycon1103>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))1104Module(1105 body=[1106 ImportFrom(1107 module='y',1108 names=[1109 alias(name='x'),1110 alias(name='y'),1111 alias(name='z')],1112 level=0)])1113```11141115#### `class ast.alias(name, asname)`11161117Оба параметра – необработанные строки имён. `asname` может быть `None`, если должно использоваться обычное имя.11181119```pycon1120>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))1121Module(1122 body=[1123 ImportFrom(1124 module='foo.bar',1125 names=[1126 alias(name='a', asname='b'),1127 alias(name='c')],1128 level=2)])1129```11301131### Управление потоком11321133> **Примечание**1134>1135> Необязательные предложения, такие как `else`, сохраняются как пустой список, если они отсутствуют.11361137#### `class ast.If(test, body, orelse)`11381139Инструкция `if`. `test` содержит один узел, например узел [`Compare`](https://python-all.ru/3/library/ast.html#ast.Compare). `body` и `orelse` содержат по списку узлов.11401141Предложения `elif` не имеют специального представления в AST, а появляются как дополнительные узлы `If` в разделе `orelse` предыдущего.11421143```pycon1144>>> print(ast.dump(ast.parse("""1145... if x:1146... ...1147... elif y:1148... ...1149... else:1150... ...1151... """), indent=4))1152Module(1153 body=[1154 If(1155 test=Name(id='x', ctx=Load()),1156 body=[1157 Expr(1158 value=Constant(value=Ellipsis))],1159 orelse=[1160 If(1161 test=Name(id='y', ctx=Load()),1162 body=[1163 Expr(1164 value=Constant(value=Ellipsis))],1165 orelse=[1166 Expr(1167 value=Constant(value=Ellipsis))])])])1168```11691170#### `class ast.For(target, iter, body, orelse, type_comment)`11711172Цикл `for`. `target` содержит переменную (или переменные), которой присваивает цикл, в виде одного узла [`Name`](https://python-all.ru/3/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3/library/ast.html#ast.Tuple), [`List`](https://python-all.ru/3/library/ast.html#ast.List), [`Attribute`](https://python-all.ru/3/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3/library/ast.html#ast.Subscript). `iter` содержит элемент, по которому выполняется итерация, также в виде одного узла. `body` и `orelse` содержат списки узлов для выполнения. Те, что в `orelse`, выполняются, если цикл завершается нормально, а не по инструкции `break`.11731174#### `type_comment`11751176`type_comment` – это необязательная строка с аннотацией типа в виде комментария.11771178```pycon1179>>> print(ast.dump(ast.parse("""1180... for x in y:1181... ...1182... else:1183... ...1184... """), indent=4))1185Module(1186 body=[1187 For(1188 target=Name(id='x', ctx=Store()),1189 iter=Name(id='y', ctx=Load()),1190 body=[1191 Expr(1192 value=Constant(value=Ellipsis))],1193 orelse=[1194 Expr(1195 value=Constant(value=Ellipsis))])])1196```11971198#### `class ast.While(test, body, orelse)`11991200Цикл `while`. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3/library/ast.html#ast.Compare).12011202```pycon1203>>> print(ast.dump(ast.parse("""1204... while x:1205... ...1206... else:1207... ...1208... """), indent=4))1209Module(1210 body=[1211 While(1212 test=Name(id='x', ctx=Load()),1213 body=[1214 Expr(1215 value=Constant(value=Ellipsis))],1216 orelse=[1217 Expr(1218 value=Constant(value=Ellipsis))])])1219```12201221#### `class ast.Break`12221223#### `class ast.Continue`12241225Инструкции `break` и `continue`.12261227```pycon1228>>> print(ast.dump(ast.parse("""\1229... for a in b:1230... if a > 5:1231... break1232... else:1233... continue1234...1235... """), indent=4))1236Module(1237 body=[1238 For(1239 target=Name(id='a', ctx=Store()),1240 iter=Name(id='b', ctx=Load()),1241 body=[1242 If(1243 test=Compare(1244 left=Name(id='a', ctx=Load()),1245 ops=[1246 Gt()],1247 comparators=[1248 Constant(value=5)]),1249 body=[1250 Break()],1251 orelse=[1252 Continue()])])])1253```12541255#### `class ast.Try(body, handlers, orelse, finalbody)`12561257Блоки `try`. Все атрибуты – списки узлов для выполнения, за исключением `handlers`, который является списком узлов [`ExceptHandler`](https://python-all.ru/3/library/ast.html#ast.ExceptHandler).12581259```pycon1260>>> print(ast.dump(ast.parse("""1261... try:1262... ...1263... except Exception:1264... ...1265... except OtherException as e:1266... ...1267... else:1268... ...1269... finally:1270... ...1271... """), indent=4))1272Module(1273 body=[1274 Try(1275 body=[1276 Expr(1277 value=Constant(value=Ellipsis))],1278 handlers=[1279 ExceptHandler(1280 type=Name(id='Exception', ctx=Load()),1281 body=[1282 Expr(1283 value=Constant(value=Ellipsis))]),1284 ExceptHandler(1285 type=Name(id='OtherException', ctx=Load()),1286 name='e',1287 body=[1288 Expr(1289 value=Constant(value=Ellipsis))])],1290 orelse=[1291 Expr(1292 value=Constant(value=Ellipsis))],1293 finalbody=[1294 Expr(1295 value=Constant(value=Ellipsis))])])1296```12971298#### `class ast.TryStar(body, handlers, orelse, finalbody)`12991300Блоки `try`, за которыми следуют предложения `except*`. Атрибуты такие же, как для [`Try`](https://python-all.ru/3/library/ast.html#ast.Try), но узлы [`ExceptHandler`](https://python-all.ru/3/library/ast.html#ast.ExceptHandler) в `handlers` интерпретируются как блоки `except*`, а не `except`.13011302```pycon1303>>> print(ast.dump(ast.parse("""1304... try:1305... ...1306... except* Exception:1307... ...1308... """), indent=4))1309Module(1310 body=[1311 TryStar(1312 body=[1313 Expr(1314 value=Constant(value=Ellipsis))],1315 handlers=[1316 ExceptHandler(1317 type=Name(id='Exception', ctx=Load()),1318 body=[1319 Expr(1320 value=Constant(value=Ellipsis))])])])1321```13221323Добавлено в версии 3.12.13241325#### `class ast.ExceptHandler(type, name, body)`13261327Одно предложение `except`. `type` – тип исключения, который оно перехватывает, обычно узел [`Name`](https://python-all.ru/3/library/ast.html#ast.Name) (или `None` для универсального предложения `except:`). `name` – необработанная строка для имени, в котором будет сохранено исключение, или `None`, если в предложении нет `as foo`. `body` – список узлов.13281329```pycon1330>>> print(ast.dump(ast.parse("""\1331... try:1332... a + 11333... except TypeError:1334... pass1335... """), indent=4))1336Module(1337 body=[1338 Try(1339 body=[1340 Expr(1341 value=BinOp(1342 left=Name(id='a', ctx=Load()),1343 op=Add(),1344 right=Constant(value=1)))],1345 handlers=[1346 ExceptHandler(1347 type=Name(id='TypeError', ctx=Load()),1348 body=[1349 Pass()])])])1350```13511352#### `class ast.With(items, body, type_comment)`13531354Блок `with`. `items` – это список узлов [`withitem`](https://python-all.ru/3/library/ast.html#ast.withitem), представляющих менеджеры контекста, а `body` – это блок с отступом внутри контекста.13551356#### `type_comment`13571358`type_comment` – это необязательная строка с аннотацией типа в виде комментария.13591360#### `class ast.withitem(context_expr, optional_vars)`13611362Один менеджер контекста в блоке `with`. `context_expr` – это менеджер контекста, часто узел [`Call`](https://python-all.ru/3/library/ast.html#ast.Call). `optional_vars` – это [`Name`](https://python-all.ru/3/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3/library/ast.html#ast.List) для части `as foo`, или `None`, если она не используется.13631364```pycon1365>>> print(ast.dump(ast.parse("""\1366... with a as b, c as d:1367... something(b, d)1368... """), indent=4))1369Module(1370 body=[1371 With(1372 items=[1373 withitem(1374 context_expr=Name(id='a', ctx=Load()),1375 optional_vars=Name(id='b', ctx=Store())),1376 withitem(1377 context_expr=Name(id='c', ctx=Load()),1378 optional_vars=Name(id='d', ctx=Store()))],1379 body=[1380 Expr(1381 value=Call(1382 func=Name(id='something', ctx=Load()),1383 args=[1384 Name(id='b', ctx=Load()),1385 Name(id='d', ctx=Load())]))])])1386```13871388### Сопоставление с образцом13891390#### `class ast.Match(subject, cases)`13911392Оператор `match`. В `subject` хранится subject сопоставления (объект, который сравнивается с вариантами), а `cases` содержит итерируемый набор узлов [`match_case`](https://python-all.ru/3/library/ast.html#ast.match_case) с различными вариантами.13931394Добавлено в версии 3.10.13951396#### `class ast.match_case(pattern, guard, body)`13971398Один вариант (case) в операторе `match`. `pattern` содержит шаблон сопоставления, с которым будет сравниваться subject. Обратите внимание, что узлы [`AST`](https://python-all.ru/3/library/ast.html#ast.AST), создаваемые для шаблонов, отличаются от узлов, создаваемых для выражений, даже при одинаковом синтаксисе.13991400Атрибут `guard` содержит выражение, которое будет вычислено, если шаблон совпадает с subject.14011402`body` содержит список узлов, которые выполняются, если шаблон совпадает и результат вычисления guard-выражения истинен.14031404```pycon1405>>> print(ast.dump(ast.parse("""1406... match x:1407... case [x] if x>0:1408... ...1409... case tuple():1410... ...1411... """), indent=4))1412Module(1413 body=[1414 Match(1415 subject=Name(id='x', ctx=Load()),1416 cases=[1417 match_case(1418 pattern=MatchSequence(1419 patterns=[1420 MatchAs(name='x')]),1421 guard=Compare(1422 left=Name(id='x', ctx=Load()),1423 ops=[1424 Gt()],1425 comparators=[1426 Constant(value=0)]),1427 body=[1428 Expr(1429 value=Constant(value=Ellipsis))]),1430 match_case(1431 pattern=MatchClass(1432 cls=Name(id='tuple', ctx=Load())),1433 body=[1434 Expr(1435 value=Constant(value=Ellipsis))])])])1436```14371438Добавлено в версии 3.10.14391440#### `class ast.MatchValue(value)`14411442Сопоставление с литералом или шаблоном значения, сравниваемым по равенству. `value` – это узел выражения. Допустимые узлы значений ограничены, как описано в документации оператора match. Этот шаблон успешно срабатывает, если subject сопоставления равен вычисленному значению.14431444```pycon1445>>> print(ast.dump(ast.parse("""1446... match x:1447... case "Relevant":1448... ...1449... """), indent=4))1450Module(1451 body=[1452 Match(1453 subject=Name(id='x', ctx=Load()),1454 cases=[1455 match_case(1456 pattern=MatchValue(1457 value=Constant(value='Relevant')),1458 body=[1459 Expr(1460 value=Constant(value=Ellipsis))])])])1461```14621463Добавлено в версии 3.10.14641465#### `class ast.MatchSingleton(value)`14661467Сопоставление с литералом, сравниваемым по идентичности. `value` – это синглтон, с которым производится сравнение: `None`, `True` или `False`. Этот шаблон успешно срабатывает, если subject сопоставления является заданной константой.14681469```pycon1470>>> print(ast.dump(ast.parse("""1471... match x:1472... case None:1473... ...1474... """), indent=4))1475Module(1476 body=[1477 Match(1478 subject=Name(id='x', ctx=Load()),1479 cases=[1480 match_case(1481 pattern=MatchSingleton(value=None),1482 body=[1483 Expr(1484 value=Constant(value=Ellipsis))])])])1485```14861487Добавлено в версии 3.10.14881489#### `class ast.MatchSequence(patterns)`14901491Шаблон последовательности (sequence pattern) в match. `patterns` содержит шаблоны, которые будут сопоставляться с элементами subject, если subject является последовательностью. Сопоставляется с последовательностью переменной длины, если один из подшаблонов является узлом `MatchStar`, в противном случае сопоставляется с последовательностью фиксированной длины.14921493```pycon1494>>> print(ast.dump(ast.parse("""1495... match x:1496... case [1, 2]:1497... ...1498... """), indent=4))1499Module(1500 body=[1501 Match(1502 subject=Name(id='x', ctx=Load()),1503 cases=[1504 match_case(1505 pattern=MatchSequence(1506 patterns=[1507 MatchValue(1508 value=Constant(value=1)),1509 MatchValue(1510 value=Constant(value=2))]),1511 body=[1512 Expr(1513 value=Constant(value=Ellipsis))])])])1514```15151516Добавлено в версии 3.10.15171518#### `class ast.MatchStar(name)`15191520Сопоставляется с остатком последовательности в шаблоне последовательности переменной длины. Если `name` не равно `None`, то при успешном сопоставлении всего шаблона последовательности этому имени привязывается список, содержащий оставшиеся элементы последовательности.15211522```pycon1523>>> print(ast.dump(ast.parse("""1524... match x:1525... case [1, 2, *rest]:1526... ...1527... case [*_]:1528... ...1529... """), indent=4))1530Module(1531 body=[1532 Match(1533 subject=Name(id='x', ctx=Load()),1534 cases=[1535 match_case(1536 pattern=MatchSequence(1537 patterns=[1538 MatchValue(1539 value=Constant(value=1)),1540 MatchValue(1541 value=Constant(value=2)),1542 MatchStar(name='rest')]),1543 body=[1544 Expr(1545 value=Constant(value=Ellipsis))]),1546 match_case(1547 pattern=MatchSequence(1548 patterns=[1549 MatchStar()]),1550 body=[1551 Expr(1552 value=Constant(value=Ellipsis))])])])1553```15541555Добавлено в версии 3.10.15561557#### `class ast.MatchMapping(keys, patterns, rest)`15581559Шаблон отображения (mapping pattern) в match. `keys` – последовательность узлов выражений. `patterns` – соответствующая последовательность узлов шаблонов. `rest` – необязательное имя, которое можно указать для захвата оставшихся элементов отображения. Допустимые ключевые выражения ограничены, как описано в документации оператора match.15601561Этот шаблон успешно срабатывает, если subject является отображением, все вычисленные ключевые выражения присутствуют в отображении, а значение, соответствующее каждому ключу, совпадает с соответствующим подшаблоном. Если `rest` не равно `None`, то при успешном сопоставлении всего шаблона отображения этому имени привязывается словарь, содержащий оставшиеся элементы отображения.15621563```pycon1564>>> print(ast.dump(ast.parse("""1565... match x:1566... case {1: _, 2: _}:1567... ...1568... case {**rest}:1569... ...1570... """), indent=4))1571Module(1572 body=[1573 Match(1574 subject=Name(id='x', ctx=Load()),1575 cases=[1576 match_case(1577 pattern=MatchMapping(1578 keys=[1579 Constant(value=1),1580 Constant(value=2)],1581 patterns=[1582 MatchAs(),1583 MatchAs()]),1584 body=[1585 Expr(1586 value=Constant(value=Ellipsis))]),1587 match_case(1588 pattern=MatchMapping(rest='rest'),1589 body=[1590 Expr(1591 value=Constant(value=Ellipsis))])])])1592```15931594Добавлено в версии 3.10.15951596#### `class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)`15971598Шаблон класса (class pattern) в match. `cls` – выражение, задающее номинальный класс для сопоставления. `patterns` – последовательность узлов шаблонов, которые будут сопоставляться с определённой классом последовательностью атрибутов для сопоставления с образцом. `kwd_attrs` – последовательность дополнительных атрибутов для сопоставления (указанных как ключевые аргументы в шаблоне класса), `kwd_patterns` – соответствующие шаблоны (указанные как значения ключевых слов в шаблоне класса).15991600Этот шаблон успешно срабатывает, если subject является экземпляром указанного класса, все позиционные шаблоны совпадают с соответствующими атрибутами, определёнными классом, и все указанные ключевые атрибуты совпадают со своими шаблонами.16011602Примечание: классы могут определять свойство, возвращающее self, чтобы сопоставлять узел шаблона с сопоставляемым экземпляром. Некоторые встроенные типы также сопоставляются таким образом, как описано в документации оператора match.16031604```pycon1605>>> print(ast.dump(ast.parse("""1606... match x:1607... case Point2D(0, 0):1608... ...1609... case Point3D(x=0, y=0, z=0):1610... ...1611... """), indent=4))1612Module(1613 body=[1614 Match(1615 subject=Name(id='x', ctx=Load()),1616 cases=[1617 match_case(1618 pattern=MatchClass(1619 cls=Name(id='Point2D', ctx=Load()),1620 patterns=[1621 MatchValue(1622 value=Constant(value=0)),1623 MatchValue(1624 value=Constant(value=0))]),1625 body=[1626 Expr(1627 value=Constant(value=Ellipsis))]),1628 match_case(1629 pattern=MatchClass(1630 cls=Name(id='Point3D', ctx=Load()),1631 kwd_attrs=[1632 'x',1633 'y',1634 'z'],1635 kwd_patterns=[1636 MatchValue(1637 value=Constant(value=0)),1638 MatchValue(1639 value=Constant(value=0)),1640 MatchValue(1641 value=Constant(value=0))]),1642 body=[1643 Expr(1644 value=Constant(value=Ellipsis))])])])1645```16461647Добавлено в версии 3.10.16481649#### `class ast.MatchAs(pattern, name)`16501651Сопоставление «as-pattern», шаблон захвата (capture pattern) или шаблон-заменитель (wildcard pattern). `pattern` содержит шаблон match, с которым будет сопоставлен subject. Если шаблон равен `None`, узел представляет собой шаблон захвата (т.е. просто имя) и всегда успешно срабатывает.16521653Атрибут `name` содержит имя, которое будет привязано при успешном сопоставлении шаблона. Если `name` равно `None`, то `pattern` также должно быть `None`, и узел представляет собой шаблон-заменитель (wildcard).16541655```pycon1656>>> print(ast.dump(ast.parse("""1657... match x:1658... case [x] as y:1659... ...1660... case _:1661... ...1662... """), indent=4))1663Module(1664 body=[1665 Match(1666 subject=Name(id='x', ctx=Load()),1667 cases=[1668 match_case(1669 pattern=MatchAs(1670 pattern=MatchSequence(1671 patterns=[1672 MatchAs(name='x')]),1673 name='y'),1674 body=[1675 Expr(1676 value=Constant(value=Ellipsis))]),1677 match_case(1678 pattern=MatchAs(),1679 body=[1680 Expr(1681 value=Constant(value=Ellipsis))])])])1682```16831684Добавлено в версии 3.10.16851686#### `class ast.MatchOr(patterns)`16871688Сопоставление «or-pattern» (шаблон ИЛИ). Or-pattern последовательно сопоставляет каждый из своих подшаблонов с subject, пока один из них не сработает. Тогда считается, что or-pattern сработал. Если ни один из подшаблонов не сработал, or-pattern не срабатывает. Атрибут `patterns` содержит список узлов шаблонов match, которые будут сопоставляться с subject.16891690```pycon1691>>> print(ast.dump(ast.parse("""1692... match x:1693... case [x] | (y):1694... ...1695... """), indent=4))1696Module(1697 body=[1698 Match(1699 subject=Name(id='x', ctx=Load()),1700 cases=[1701 match_case(1702 pattern=MatchOr(1703 patterns=[1704 MatchSequence(1705 patterns=[1706 MatchAs(name='x')]),1707 MatchAs(name='y')]),1708 body=[1709 Expr(1710 value=Constant(value=Ellipsis))])])])1711```17121713Добавлено в версии 3.10.17141715### Аннотации типов17161717#### `class ast.TypeIgnore(lineno, tag)`17181719Комментарий `# type: ignore`, расположенный на строке *lineno*. *tag* – опциональный тег, задаваемый формой `# type: ignore <tag>`.17201721```pycon1722>>> print(ast.dump(ast.parse('x = 1 # type: ignore', type_comments=True), indent=4))1723Module(1724 body=[1725 Assign(1726 targets=[1727 Name(id='x', ctx=Store())],1728 value=Constant(value=1))],1729 type_ignores=[1730 TypeIgnore(lineno=1, tag='')])1731>>> print(ast.dump(ast.parse('x: bool = 1 # type: ignore[assignment]', type_comments=True), indent=4))1732Module(1733 body=[1734 AnnAssign(1735 target=Name(id='x', ctx=Store()),1736 annotation=Name(id='bool', ctx=Load()),1737 value=Constant(value=1),1738 simple=1)],1739 type_ignores=[1740 TypeIgnore(lineno=1, tag='[assignment]')])1741```17421743> **Примечание**1744>1745> Узлы `TypeIgnore` не создаются, когда параметр *type\_comments* установлен в `False` (по умолчанию). Подробнее см. [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse).17461747Добавлено в версии 3.8.17481749### Параметры типа17501751[Параметры типа](https://python-all.ru/3/reference/compound_stmts.html#type-params) могут существовать у классов, функций и псевдонимов типов.17521753#### `class ast.TypeVar(name, bound, default_value)`17541755[`typing.TypeVar`](https://python-all.ru/3/library/typing.html#typing.TypeVar). `name` – это имя переменной типа. `bound` – это граница или ограничения, если они есть. Если `bound` представляет собой [`Tuple`](https://python-all.ru/3/library/ast.html#ast.Tuple), то это ограничения; иначе – граница. `default_value` – значение по умолчанию; если `TypeVar` не имеет значения по умолчанию, то этот атрибут равен `None`.17561757```pycon1758>>> print(ast.dump(ast.parse("type Alias[T: int = bool] = list[T]"), indent=4))1759Module(1760 body=[1761 TypeAlias(1762 name=Name(id='Alias', ctx=Store()),1763 type_params=[1764 TypeVar(1765 name='T',1766 bound=Name(id='int', ctx=Load()),1767 default_value=Name(id='bool', ctx=Load()))],1768 value=Subscript(1769 value=Name(id='list', ctx=Load()),1770 slice=Name(id='T', ctx=Load()),1771 ctx=Load()))])1772```17731774Добавлено в версии 3.12.17751776Изменено в версии 3.13: Добавлен параметр *default\_value*.17771778#### `class ast.ParamSpec(name, default_value)`17791780[`typing.ParamSpec`](https://python-all.ru/3/library/typing.html#typing.ParamSpec). `name` – это имя спецификации параметра. `default_value` – значение по умолчанию; если `ParamSpec` не имеет значения по умолчанию, то этот атрибут устанавливается в `None`.17811782```pycon1783>>> print(ast.dump(ast.parse("type Alias[**P = [int, str]] = Callable[P, int]"), indent=4))1784Module(1785 body=[1786 TypeAlias(1787 name=Name(id='Alias', ctx=Store()),1788 type_params=[1789 ParamSpec(1790 name='P',1791 default_value=List(1792 elts=[1793 Name(id='int', ctx=Load()),1794 Name(id='str', ctx=Load())],1795 ctx=Load()))],1796 value=Subscript(1797 value=Name(id='Callable', ctx=Load()),1798 slice=Tuple(1799 elts=[1800 Name(id='P', ctx=Load()),1801 Name(id='int', ctx=Load())],1802 ctx=Load()),1803 ctx=Load()))])1804```18051806Добавлено в версии 3.12.18071808Изменено в версии 3.13: Добавлен параметр *default\_value*.18091810#### `class ast.TypeVarTuple(name, default_value)`18111812[`typing.TypeVarTuple`](https://python-all.ru/3/library/typing.html#typing.TypeVarTuple). `name` – это имя кортежа переменных типа. `default_value` – значение по умолчанию; если `TypeVarTuple` не имеет значения по умолчанию, то этот атрибут устанавливается в `None`.18131814```pycon1815>>> print(ast.dump(ast.parse("type Alias[*Ts = ()] = tuple[*Ts]"), indent=4))1816Module(1817 body=[1818 TypeAlias(1819 name=Name(id='Alias', ctx=Store()),1820 type_params=[1821 TypeVarTuple(1822 name='Ts',1823 default_value=Tuple(ctx=Load()))],1824 value=Subscript(1825 value=Name(id='tuple', ctx=Load()),1826 slice=Tuple(1827 elts=[1828 Starred(1829 value=Name(id='Ts', ctx=Load()),1830 ctx=Load())],1831 ctx=Load()),1832 ctx=Load()))])1833```18341835Добавлено в версии 3.12.18361837Изменено в версии 3.13: Добавлен параметр *default\_value*.18381839### Определения функций и классов18401841#### `class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`18421843Определение функции.18441845- `name` – это необработанная строка имени функции.1846- `args` – это узел [`arguments`](https://python-all.ru/3/library/ast.html#ast.arguments).1847- `body` – это список узлов внутри функции.1848- `decorator_list` – это список декораторов, которые будут применены; декораторы перечислены от самого внешнего к внутреннему (т.е. первый в списке применяется последним).1849- `returns` – это аннотация возвращаемого значения.1850- `type_params` – это список [параметров типа](https://python-all.ru/3/library/ast.html#ast-type-params).18511852#### `type_comment`18531854`type_comment` – это необязательная строка с аннотацией типа в виде комментария.18551856Изменено в версии 3.12: Добавлен `type_params`.18571858#### `class ast.Lambda(args, body)`18591860`lambda` – это минимальное определение функции, которое можно использовать внутри выражения. В отличие от [`FunctionDef`](https://python-all.ru/3/library/ast.html#ast.FunctionDef), `body` содержит один узел.18611862```pycon1863>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))1864Module(1865 body=[1866 Expr(1867 value=Lambda(1868 args=arguments(1869 args=[1870 arg(arg='x'),1871 arg(arg='y')]),1872 body=Constant(value=Ellipsis)))])1873```18741875#### `class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)`18761877Аргументы функции.18781879- `posonlyargs`, `args` и `kwonlyargs` – это списки узлов [`arg`](https://python-all.ru/3/library/ast.html#ast.arg).1880- `vararg` и `kwarg` – это одиночные узлы [`arg`](https://python-all.ru/3/library/ast.html#ast.arg), ссылающиеся на параметры `*args, **kwargs`.1881- `kw_defaults` – это список значений по умолчанию для keyword-only аргументов. Если один из них равен `None`, соответствующий аргумент обязателен.1882- `defaults` – это список значений по умолчанию для аргументов, которые можно передавать позиционно. Если значений по умолчанию меньше, они соответствуют последним n аргументам.18831884#### `class ast.arg(arg, annotation, type_comment)`18851886Один аргумент в списке. `arg` – это сырая строка с именем аргумента; `annotation` – это его аннотация, например, узел [`Name`](https://python-all.ru/3/library/ast.html#ast.Name).18871888#### `type_comment`18891890`type_comment` – это необязательная строка с аннотацией типа в виде комментария18911892```pycon1893>>> print(ast.dump(ast.parse("""\1894... @decorator11895... @decorator21896... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':1897... pass1898... """), indent=4))1899Module(1900 body=[1901 FunctionDef(1902 name='f',1903 args=arguments(1904 args=[1905 arg(1906 arg='a',1907 annotation=Constant(value='annotation')),1908 arg(arg='b'),1909 arg(arg='c')],1910 vararg=arg(arg='d'),1911 kwonlyargs=[1912 arg(arg='e'),1913 arg(arg='f')],1914 kw_defaults=[1915 None,1916 Constant(value=3)],1917 kwarg=arg(arg='g'),1918 defaults=[1919 Constant(value=1),1920 Constant(value=2)]),1921 body=[1922 Pass()],1923 decorator_list=[1924 Name(id='decorator1', ctx=Load()),1925 Name(id='decorator2', ctx=Load())],1926 returns=Constant(value='return annotation'))])1927```19281929#### `class ast.Return(value)`19301931Инструкция `return`.19321933```pycon1934>>> print(ast.dump(ast.parse('return 4'), indent=4))1935Module(1936 body=[1937 Return(1938 value=Constant(value=4))])1939```19401941#### `class ast.Yield(value)`19421943#### `class ast.YieldFrom(value)`19441945Выражение `yield` или `yield from`. Поскольку это выражения, они должны быть обёрнуты в узел [`Expr`](https://python-all.ru/3/library/ast.html#ast.Expr), если возвращаемое значение не используется.19461947```pycon1948>>> print(ast.dump(ast.parse('yield x'), indent=4))1949Module(1950 body=[1951 Expr(1952 value=Yield(1953 value=Name(id='x', ctx=Load())))])19541955>>> print(ast.dump(ast.parse('yield from x'), indent=4))1956Module(1957 body=[1958 Expr(1959 value=YieldFrom(1960 value=Name(id='x', ctx=Load())))])1961```19621963#### `class ast.Global(names)`19641965#### `class ast.Nonlocal(names)`19661967Инструкции `global` и `nonlocal`. `names` – это список сырых строк.19681969```pycon1970>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))1971Module(1972 body=[1973 Global(1974 names=[1975 'x',1976 'y',1977 'z'])])19781979>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))1980Module(1981 body=[1982 Nonlocal(1983 names=[1984 'x',1985 'y',1986 'z'])])1987```19881989#### `class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)`19901991Определение класса.19921993- `name` – это сырая строка с именем класса.1994- `bases` – это список узлов для явно указанных базовых классов.1995- `keywords` – это список узлов [`keyword`](https://python-all.ru/3/library/ast.html#ast.keyword), в первую очередь для ‘metaclass’. Остальные ключевые слова будут переданы метаклассу, в соответствии с [**PEP 3115**](https://python-all.ru/3/library/ast.html).1996- `body` – это список узлов, представляющих код внутри определения класса.1997- `decorator_list` – это список узлов, как и в [`FunctionDef`](https://python-all.ru/3/library/ast.html#ast.FunctionDef).1998- `type_params` – это список [параметров типа](https://python-all.ru/3/library/ast.html#ast-type-params).19992000```pycon2001>>> print(ast.dump(ast.parse("""\2002... @decorator12003... @decorator22004... class Foo(base1, base2, metaclass=meta):2005... pass2006... """), indent=4))2007Module(2008 body=[2009 ClassDef(2010 name='Foo',2011 bases=[2012 Name(id='base1', ctx=Load()),2013 Name(id='base2', ctx=Load())],2014 keywords=[2015 keyword(2016 arg='metaclass',2017 value=Name(id='meta', ctx=Load()))],2018 body=[2019 Pass()],2020 decorator_list=[2021 Name(id='decorator1', ctx=Load()),2022 Name(id='decorator2', ctx=Load())])])2023```20242025Изменено в версии 3.12: Добавлен `type_params`.20262027### async и await20282029#### `class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`20302031Определение функции `async def`. Имеет те же поля, что и [`FunctionDef`](https://python-all.ru/3/library/ast.html#ast.FunctionDef).20322033Изменено в версии 3.12: Добавлен `type_params`.20342035#### `class ast.Await(value)`20362037Выражение `await`. `value` – это то, чего оно ожидает. Допустимо только в теле [`AsyncFunctionDef`](https://python-all.ru/3/library/ast.html#ast.AsyncFunctionDef).20382039```pycon2040>>> print(ast.dump(ast.parse("""\2041... async def f():2042... await other_func()2043... """), indent=4))2044Module(2045 body=[2046 AsyncFunctionDef(2047 name='f',2048 args=arguments(),2049 body=[2050 Expr(2051 value=Await(2052 value=Call(2053 func=Name(id='other_func', ctx=Load()))))])])2054```20552056#### `class ast.AsyncFor(target, iter, body, orelse, type_comment)`20572058#### `class ast.AsyncWith(items, body, type_comment)`20592060`async for` циклы и `async with` менеджеры контекста. Они имеют те же поля, что [`For`](https://python-all.ru/3/library/ast.html#ast.For) и [`With`](https://python-all.ru/3/library/ast.html#ast.With), соответственно. Допустимы только в теле [`AsyncFunctionDef`](https://python-all.ru/3/library/ast.html#ast.AsyncFunctionDef).20612062> **Примечание**2063>2064> Когда строка разбирается с помощью [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse), узлы операторов (подклассы `ast.operator`, `ast.unaryop`, `ast.cmpop`, `ast.boolop` и `ast.expr_context`) на возвращаемом дереве будут синглтонами. Изменения в одном отразятся во всех других вхождениях того же значения (например, [`ast.Add`](https://python-all.ru/3/library/ast.html#ast.Add)).20652066## `ast` вспомогательные функции20672068Помимо классов узлов, модуль `ast` определяет следующие служебные функции и классы для обхода абстрактных синтаксических деревьев:20692070#### `ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None, optimize=-1)`20712072Разбирает исходный код в узел AST. Эквивалентно `compile(source, filename, mode, flags=FLAGS_VALUE, optimize=optimize)`, где `FLAGS_VALUE` равно `ast.PyCF_ONLY_AST`, если `optimize <= 0`, и `ast.PyCF_OPTIMIZED_AST` в противном случае.20732074Если задан `type_comments=True`, парсер изменяется, чтобы проверять и возвращать комментарии типов, как указано в [**PEP 484**](https://python-all.ru/3/library/ast.html) и [**PEP 526**](https://python-all.ru/3/library/ast.html). Это эквивалентно добавлению [`ast.PyCF_TYPE_COMMENTS`](https://python-all.ru/3/library/ast.html#ast.PyCF_TYPE_COMMENTS) к флагам, передаваемым в [`compile()`](https://python-all.ru/3/library/functions.html#compile). Это приведёт к сообщению об ошибках синтаксиса для неправильно расположенных комментариев типов. Без этого флага комментарии типов будут игнорироваться, и поле `type_comment` в выбранных узлах AST всегда будет `None`. Кроме того, расположение комментариев `# type: ignore` будет возвращаться как атрибут `type_ignores` объекта [`Module`](https://python-all.ru/3/library/ast.html#ast.Module) (иначе это всегда пустой список).20752076Кроме того, если `mode` равно `'func_type'`, синтаксис входных данных изменяется в соответствии с [**PEP 484**](https://python-all.ru/3/library/ast.html) «сигнатурными комментариями типов», например `(str, int) -> List[str]`.20772078Установка `feature_version` в кортеж `(major, minor)` приведёт к «наилучшей попытке» разбора с использованием грамматики этой версии Python. Например, установка `feature_version=(3, 9)` будет пытаться запретить разбор инструкций [`match`](https://python-all.ru/3/reference/compound_stmts.html#match). В настоящее время `major` должно быть равно `3`. Самая низкая поддерживаемая версия – `(3, 7)` (и это может увеличиться в будущих версиях Python); самая высокая – `sys.version_info[0:2]`. «Наилучшая попытка» означает, что нет гарантии, что разбор (или успех разбора) будет таким же, как при запуске на версии Python, соответствующей `feature_version`.20792080Если исходный код содержит нулевой символ (`\0`), возбуждается [`ValueError`](https://python-all.ru/3/library/exceptions.html#ValueError).20812082> **Предупреждение**2083>2084> Обратите внимание, что успешный разбор исходного кода в объект AST не гарантирует, что предоставленный исходный код является корректным кодом Python, который можно выполнить, поскольку этап компиляции может вызывать дополнительные исключения [`SyntaxError`](https://python-all.ru/3/library/exceptions.html#SyntaxError). Например, исходный код `return 42` генерирует корректный узел AST для инструкции return, но его нельзя скомпилировать отдельно (он должен находиться внутри узла функции).2085>2086> В частности, `ast.parse()` не выполняет никаких проверок областей видимости, которые выполняет этап компиляции.20872088> **Предупреждение**2089>2090> Можно вызвать сбой интерпретатора Python с помощью достаточно большой/сложной строки из-за ограничений глубины стека в компиляторе AST Python.20912092Изменено в версии 3.8: Добавлены `type_comments`, `mode='func_type'` и `feature_version`.20932094Изменено в версии 3.13: Минимальная поддерживаемая версия для `feature_version` теперь `(3, 7)`. Был добавлен аргумент `optimize`.20952096#### `ast.unparse(ast_obj)`20972098Выполняет обратный разбор объекта [`ast.AST`](https://python-all.ru/3/library/ast.html#ast.AST) и генерирует строку с кодом, который при обратном разборе с помощью [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse) даст эквивалентный объект `ast.AST`.20992100> **Предупреждение**2101>2102> Полученная строка кода не обязательно будет равна исходному коду, который породил объект [`ast.AST`](https://python-all.ru/3/library/ast.html#ast.AST) (без каких-либо оптимизаций компилятора, таких как константные кортежи/frozensets).21032104> **Предупреждение**2105>2106> Попытка выполнить обратный разбор очень сложного выражения приведёт к [`RecursionError`](https://python-all.ru/3/library/exceptions.html#RecursionError).21072108Добавлено в версии 3.9.21092110#### `ast.literal_eval(node_or_string)`21112112Вычисляет узел выражения или строку, содержащую только литерал Python или отображение контейнера. Предоставленная строка или узел могут состоять только из следующих структур литералов Python: строки, байты, числа, кортежи, списки, словари, множества, булевы значения, `None` и `Ellipsis`.21132114Это можно использовать для вычисления строк, содержащих значения Python, без необходимости разбирать значения самостоятельно. Он не способен вычислять произвольно сложные выражения, например, с операторами или индексацией.21152116Раньше эта функция документировалась как «безопасная» без определения, что это значит. Это вводило в заблуждение. Она специально разработана так, чтобы не выполнять код Python, в отличие от более общей [`eval()`](https://python-all.ru/3/library/functions.html#eval). Нет пространства имён, поиска имён или возможности внешних вызовов. Но она не свободна от атак: относительно небольшой ввод может привести к истощению памяти или истощению стека C, что вызовет сбой процесса. Также существует возможность отказа в обслуживании из-за чрезмерного потребления ЦП на некоторых входных данных. Поэтому вызывать её на недоверенных данных не рекомендуется.21172118> **Предупреждение**2119>2120> Можно вызвать сбой интерпретатора Python из-за ограничений глубины стека в компиляторе AST Python.2121>2122> Она может возбуждать [`ValueError`](https://python-all.ru/3/library/exceptions.html#ValueError), [`TypeError`](https://python-all.ru/3/library/exceptions.html#TypeError), [`SyntaxError`](https://python-all.ru/3/library/exceptions.html#SyntaxError), [`MemoryError`](https://python-all.ru/3/library/exceptions.html#MemoryError) и [`RecursionError`](https://python-all.ru/3/library/exceptions.html#RecursionError) в зависимости от некорректного ввода.21232124Изменено в версии 3.2: Теперь допускает литералы байтов и множеств.21252126Изменено в версии 3.9: Теперь поддерживает создание пустых множеств с помощью `'set()'`.21272128Изменено в версии 3.10: Для строковых входных данных начальные пробелы и табуляции теперь удаляются.21292130#### `ast.get_docstring(node, clean=True)`21312132Возвращает строку документации для данного *узла* (который должен быть узлом [`FunctionDef`](https://python-all.ru/3/library/ast.html#ast.FunctionDef), [`AsyncFunctionDef`](https://python-all.ru/3/library/ast.html#ast.AsyncFunctionDef), [`ClassDef`](https://python-all.ru/3/library/ast.html#ast.ClassDef) или [`Module`](https://python-all.ru/3/library/ast.html#ast.Module)) или `None`, если у него нет строки документации. Если *clean* истинно, очищает отступы строки документации с помощью [`inspect.cleandoc()`](https://python-all.ru/3/library/inspect.html#inspect.cleandoc).21332134Изменено в версии 3.5: Теперь поддерживается [`AsyncFunctionDef`](https://python-all.ru/3/library/ast.html#ast.AsyncFunctionDef).21352136#### `ast.get_source_segment(source, node, *, padded=False)`21372138Возвращает фрагмент исходного кода из *source*, который породил узел *node*. Если не хватает информации о местоположении ([`lineno`](https://python-all.ru/3/library/ast.html#ast.AST.lineno), [`end_lineno`](https://python-all.ru/3/library/ast.html#ast.AST.end_lineno), [`col_offset`](https://python-all.ru/3/library/ast.html#ast.AST.col_offset) или [`end_col_offset`](https://python-all.ru/3/library/ast.html#ast.AST.end_col_offset)), возвращает `None`.21392140Если *padded* равно `True`, первая строка многострочного оператора будет дополнена пробелами, чтобы соответствовать исходной позиции.21412142Добавлено в версии 3.8.21432144#### `ast.fix_missing_locations(node)`21452146При компиляции дерева узлов с помощью [`compile()`](https://python-all.ru/3/library/functions.html#compile) компилятор ожидает атрибуты [`lineno`](https://python-all.ru/3/library/ast.html#ast.AST.lineno) и [`col_offset`](https://python-all.ru/3/library/ast.html#ast.AST.col_offset) для каждого узла, который их поддерживает. Заполнять их вручную для сгенерированных узлов довольно утомительно, поэтому эта вспомогательная функция рекурсивно добавляет эти атрибуты, если их ещё нет, устанавливая их равными значениям родительского узла. Работает рекурсивно, начиная с *node*.21472148#### `ast.increment_lineno(node, n=1)`21492150Увеличивает номер строки и номер конечной строки каждого узла в дереве, начиная с *node*, на *n*. Это полезно для «перемещения кода» в другое место в файле.21512152#### `ast.copy_location(new_node, old_node)`21532154Копирует информацию о местоположении в исходном коде ([`lineno`](https://python-all.ru/3/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3/library/ast.html#ast.AST.end_col_offset)) из *old\_node* в *new\_node*, если это возможно, и возвращает *new\_node*.21552156#### `ast.iter_fields(node)`21572158Генерирует кортеж из `(fieldname, value)` для каждого поля в `node._fields`, которое присутствует в *node*.21592160#### `ast.iter_child_nodes(node)`21612162Генерирует все непосредственные дочерние узлы *node*, то есть все поля, являющиеся узлами, и все элементы полей, являющихся списками узлов.21632164#### `ast.walk(node)`21652166Рекурсивно генерирует все узлы-потомки в дереве, начиная с *node* (включая сам *node*), в произвольном порядке. Это полезно, если требуется только изменить узлы на месте, а контекст не важен.21672168#### `class ast.NodeVisitor`21692170Базовый класс для обхода узлов, который обходит абстрактное синтаксическое дерево и вызывает функцию-посетитель для каждого найденного узла. Эта функция может вернуть значение, которое передаётся методом [`visit()`](https://python-all.ru/3/library/ast.html#ast.NodeVisitor.visit).21712172Этот класс предназначен для наследования; в подклассе добавляются методы-посетители.21732174#### `visit(node)`21752176Посещает узел. Реализация по умолчанию вызывает метод `self.visit_classname`, где *classname* – имя класса узла, или [`generic_visit()`](https://python-all.ru/3/library/ast.html#ast.NodeVisitor.generic_visit), если такой метод отсутствует.21772178#### `generic_visit(node)`21792180Этот посетитель вызывает [`visit()`](https://python-all.ru/3/library/ast.html#ast.NodeVisitor.visit) для всех дочерних узлов.21812182Обратите внимание, что дочерние узлы тех узлов, для которых определён собственный метод-посетитель, не будут посещены, если посетитель сам не вызовет `generic_visit()` или не обойдёт их самостоятельно.21832184#### `visit_Constant(node)`21852186Обрабатывает все константные узлы.21872188Не используйте `NodeVisitor`, если требуется вносить изменения в узлы во время обхода. Для этого существует специальный посетитель ([`NodeTransformer`](https://python-all.ru/3/library/ast.html#ast.NodeTransformer)), который допускает модификации.21892190Устарело с версии 3.8, удалено в версии 3.14: Методы `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` и `visit_Ellipsis()` не будут вызываться в Python 3.14+. Вместо них добавьте метод [`visit_Constant()`](https://python-all.ru/3/library/ast.html#ast.NodeVisitor.visit_Constant) для обработки всех константных узлов.21912192#### `class ast.NodeTransformer`21932194Подкласс [`NodeVisitor`](https://python-all.ru/3/library/ast.html#ast.NodeVisitor), который обходит абстрактное синтаксическое дерево и позволяет изменять узлы.21952196Метод `NodeTransformer` обходит AST и использует возвращаемое значение методов-посетителей для замены или удаления старого узла. Если возвращаемое значение метода-посетителя равно `None`, узел будет удалён из своего местоположения; в противном случае он заменяется возвращённым значением. Возвращённое значение может быть исходным узлом – в этом случае замена не происходит.21972198Вот пример преобразователя, который переписывает все обращения к именам (`foo`) в `data['foo']`:21992200```python2201class RewriteName(NodeTransformer):22022203 def visit_Name(self, node):2204 return Subscript(2205 value=Name(id='data', ctx=Load()),2206 slice=Constant(value=node.id),2207 ctx=node.ctx2208 )2209```22102211Имейте в виду: если у узла, с которым вы работаете, есть дочерние узлы, необходимо либо преобразовать дочерние узлы самостоятельно, либо сначала вызвать для узла метод [`generic_visit()`](https://python-all.ru/3/library/ast.html#ast.NodeVisitor.generic_visit).22122213Для узлов, входящих в состав набора инструкций (это относится ко всем узлам инструкций), посетитель может также возвращать список узлов, а не один узел.22142215Если `NodeTransformer` вводит новые узлы (не входившие в исходное дерево) без указания информации о расположении (например, [`lineno`](https://python-all.ru/3/library/ast.html#ast.AST.lineno)), следует вызвать [`fix_missing_locations()`](https://python-all.ru/3/library/ast.html#ast.fix_missing_locations) для нового поддерева, чтобы пересчитать информацию о расположении:22162217```python2218tree = ast.parse('foo', mode='eval')2219new_tree = fix_missing_locations(RewriteName().visit(tree))2220```22212222Обычно преобразователь используется следующим образом:22232224```python2225node = YourTransformer().visit(node)2226```22272228#### `ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None, show_empty=False)`22292230Возвращает форматированный дамп дерева из *node*. Это в основном полезно для отладки. Если *annotate\_fields* равно true (по умолчанию), возвращаемая строка будет показывать имена и значения полей. Если *annotate\_fields* равно false, результирующая строка будет более компактной за счёт опускания однозначных имён полей. Атрибуты, такие как номера строк и смещения столбцов, по умолчанию не выводятся. Если это нужно, *include\_attributes* можно установить в true.22312232Если *indent* – неотрицательное целое число или строка, дерево будет выведено с отступами указанного уровня. Уровень отступа 0, отрицательное значение или `""` вставляет только переводы строк. `None` (по умолчанию) выбирает однострочное представление. Положительный целочисленный отступ добавляет соответствующее количество пробелов на уровень. Если *indent* – строка (например, `"\t"`), эта строка используется для отступа каждого уровня.22332234Если *show\_empty* равно false (по умолчанию), необязательные пустые списки будут опущены в выводе. Необязательные значения `None` всегда опускаются.22352236Изменено в версии 3.9: Добавлена опция *indent*.22372238Изменено в версии 3.13: Добавлена опция *show\_empty*.22392240```pycon2241>>> print(ast.dump(ast.parse("""\2242... async def f():2243... await other_func()2244... """), indent=4, show_empty=True))2245Module(2246 body=[2247 AsyncFunctionDef(2248 name='f',2249 args=arguments(2250 posonlyargs=[],2251 args=[],2252 kwonlyargs=[],2253 kw_defaults=[],2254 defaults=[]),2255 body=[2256 Expr(2257 value=Await(2258 value=Call(2259 func=Name(id='other_func', ctx=Load()),2260 args=[],2261 keywords=[])))],2262 decorator_list=[],2263 type_params=[])],2264 type_ignores=[])2265```22662267#### `ast.compare(a, b, /, *, compare_attributes=False)`22682269Рекурсивно сравнивает два AST.22702271*compare\_attributes* влияет на то, учитываются ли атрибуты AST при сравнении. Если *compare\_attributes* равно `False` (по умолчанию), атрибуты игнорируются. В противном случае они все должны быть равны. Эта опция полезна для проверки структурного равенства AST при различиях в пробелах или подобных деталях. Атрибуты включают номера строк и смещения столбцов.22722273Добавлено в версии 3.14.22742275## Флаги компилятора22762277Следующие флаги могут быть переданы в [`compile()`](https://python-all.ru/3/library/functions.html#compile) для изменения эффектов компиляции программы:22782279#### `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`22802281Включает поддержку `await`, `async for`, `async with` и асинхронных включений верхнего уровня.22822283Добавлено в версии 3.8.22842285#### `ast.PyCF_ONLY_AST`22862287Генерирует и возвращает абстрактное синтаксическое дерево вместо скомпилированного объекта кода.22882289#### `ast.PyCF_OPTIMIZED_AST`22902291Возвращаемое AST оптимизируется в соответствии с аргументом *optimize* в [`compile()`](https://python-all.ru/3/library/functions.html#compile) или [`ast.parse()`](https://python-all.ru/3/library/ast.html#ast.parse).22922293Добавлено в версии 3.13.22942295#### `ast.PyCF_TYPE_COMMENTS`22962297Включает поддержку комментариев типов в стиле [**PEP 484**](https://python-all.ru/3/library/ast.html) и [**PEP 526**](https://python-all.ru/3/library/ast.html) (`# type: <type>`, `# type: ignore <stuff>`).22982299Добавлено в версии 3.8.23002301## Использование командной строки23022303Добавлено в версии 3.9.23042305Модуль `ast` может быть выполнен как скрипт из командной строки. Это просто:23062307```sh2308python -m ast [-m <mode>] [-a] [infile]2309```23102311Принимаются следующие опции:23122313#### `-h, --help`23142315Показать справку и выйти.23162317#### `-m <mode>`23182319#### `--mode <mode>`23202321Определяет, какой вид кода должен быть скомпилирован, как аргумент *mode* в [`parse()`](https://python-all.ru/3/library/ast.html#ast.parse).23222323#### `--no-type-comments`23242325Не обрабатывать комментарии типов.23262327#### `-a, --include-attributes`23282329Включать атрибуты, такие как номера строк и смещения столбцов.23302331#### `-i <indent>`23322333#### `--indent <indent>`23342335Отступ узлов в AST (количество пробелов).23362337#### `--feature-version <version>`23382339Версия Python в формате 3.x (например, 3.10). По умолчанию используется текущая версия интерпретатора.23402341Добавлено в версии 3.14.23422343#### `-O <level>`23442345#### `--optimize <level>`23462347Уровень оптимизации для парсера. По умолчанию оптимизация отключена.23482349Добавлено в версии 3.14.23502351#### `--show-empty`23522353Показывать пустые списки и поля, которые равны `None`. По умолчанию пустые объекты не показываются.23542355Добавлено в версии 3.14.23562357Если указан `infile`, его содержимое разбирается в AST и выводится в stdout. В противном случае содержимое читается из stdin.23582359> **См. также**2360>2361> [Green Tree Snakes](https://python-all.ru/3/library/ast.html) – внешний документационный ресурс, содержащий подробности работы с AST Python.2362>2363> [ASTTokens](https://python-all.ru/3/library/ast.html) дополняет AST Python позициями токенов и текста в исходном коде, который их породил. Это полезно для инструментов, выполняющих преобразования исходного кода.2364>2365> [leoAst.py](https://python-all.ru/3/library/ast.html) объединяет токен-ориентированное и синтаксическое представление программ Python, вставляя двунаправленные связи между токенами и узлами AST.2366>2367> [LibCST](https://python-all.ru/3/library/ast.html) разбирает код как конкретное синтаксическое дерево, похожее на AST, и сохраняет все детали форматирования. Это полезно для создания приложений автоматического рефакторинга (codemod) и линтеров.2368>2369> [Parso](https://python-all.ru/3/library/ast.html) – это парсер Python, поддерживающий восстановление после ошибок и сквозной разбор для разных версий Python (в нескольких версиях Python). Parso также может выводить несколько синтаксических ошибок в вашем файле Python.2370