ast.md
1> **Источник:** https://python-all.ru/3.16/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/main/Lib/ast.py)1011---1213Модуль `ast` помогает приложениям Python обрабатывать деревья абстрактного синтаксиса языка Python. Абстрактный синтаксис может меняться от версии к версии; с помощью этого модуля можно программно узнать, как выглядит текущая грамматика.1415Абстрактное синтаксическое дерево можно создать, передав [`ast.PyCF_ONLY_AST`](https://python-all.ru/3.16/library/ast.html#ast.PyCF_ONLY_AST) в качестве флага встроенной функции [`compile()`](https://python-all.ru/3.16/library/functions.html#compile) или используя вспомогательную функцию [`parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse) из этого модуля. Результатом будет дерево объектов, классы которых наследуют от [`ast.AST`](https://python-all.ru/3.16/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, int? is_lazy)70 | ImportFrom(identifier? module, alias* names, int? level, int? is_lazy)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.16/library/ast.html#abstract-grammar). Они определены в модуле `_ast` на C и реэкспортируются в `ast`.183184Для каждого символа левой части абстрактной грамматики определён один класс (например, `ast.stmt` или `ast.expr`). Кроме того, для каждого конструктора правой части определён один класс; эти классы наследуют от классов для деревьев левой части. Например, [`ast.BinOp`](https://python-all.ru/3.16/library/ast.html#ast.BinOp) наследует от `ast.expr`. Для продукционных правил с альтернативами (так называемых «сумм») класс левой части является абстрактным: создаются только экземпляры конкретных узлов-конструкторов.185186#### `_fields`187188Каждый конкретный класс имеет атрибут `_fields`, который содержит имена всех дочерних узлов.189190Каждый экземпляр конкретного класса имеет по одному атрибуту для каждого дочернего узла, тип которого определён в грамматике. Например, экземпляры [`ast.BinOp`](https://python-all.ru/3.16/library/ast.html#ast.BinOp) имеют атрибут `left` типа `ast.expr`.191192Если эти атрибуты помечены как необязательные в грамматике (с помощью вопросительного знака), значением может быть `None`. Если атрибуты могут иметь ноль или более значений (помечены звёздочкой), значения представляются в виде списков Python. Все возможные атрибуты должны присутствовать и иметь корректные значения при компиляции AST с помощью [`compile()`](https://python-all.ru/3.16/library/functions.html#compile).193194#### `_field_types`195196Атрибут `_field_types` каждого конкретного класса представляет собой словарь, отображающий имена полей (как указано в [`_fields`](https://python-all.ru/3.16/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.16/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.16/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.16/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.16/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.16/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.16/library/ast.html#ast.Load). Если опущено любое другое поле, возбуждается [`DeprecationWarning`](https://python-all.ru/3.16/library/exceptions.html#DeprecationWarning) и узел AST не будет иметь этого поля. В Python 3.15 это условие будет вызывать ошибку.230231Изменено в версии 3.8: Класс [`ast.Constant`](https://python-all.ru/3.16/library/ast.html#ast.Constant) теперь используется для всех констант.232233Изменено в версии 3.9: Простые индексы представляются своим значением, расширенные срезы представляются кортежами.234235Изменено в версии 3.13: Конструкторы узлов AST были изменены, чтобы предоставлять разумные значения по умолчанию для пропущенных полей: необязательные поля теперь по умолчанию равны `None`, поля-списки по умолчанию равны пустому списку, а поля типа `ast.expr_context` по умолчанию равны [`Load()`](https://python-all.ru/3.16/library/ast.html#ast.Load). Ранее пропущенные атрибуты отсутствовали у сконструированных узлов (при обращении к ним возбуждалось [`AttributeError`](https://python-all.ru/3.16/library/exceptions.html#AttributeError)).236237Изменено в версии 3.14: В выводе [`__repr__()`](https://python-all.ru/3.16/reference/datamodel.html#object.__repr__) узлов [`AST`](https://python-all.ru/3.16/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.16/library/ast.html#ast.Constant).240241Устарело с версии 3.9: Старые классы `ast.Index` и `ast.ExtSlice` всё ещё доступны, но будут удалены в будущих выпусках Python. При этом при их создании будет возвращён экземпляр другого класса.242243Устарело с версии 3.13, удалено в версии 3.15: Предыдущие версии Python позволяли создавать узлы AST, в которых отсутствовали обязательные поля. Кроме того, конструкторы узлов AST допускали произвольные именованные аргументы, которые задавались как атрибуты узла AST, даже если они не соответствовали ни одному из полей узла AST. В таких случаях теперь возникает исключение [`TypeError`](https://python-all.ru/3.16/library/exceptions.html#TypeError).244245Deprecated since version 3.15, will be removed in version 3.20: In the [grammar above](https://python-all.ru/3.16/library/ast.html#abstract-grammar), the AST node classes that correspond to production rules with variants (aka “sums”) are abstract classes. Previous versions of Python allowed for the creation of direct instances of these abstract node classes. This behavior is deprecated and will be removed in Python 3.20.246247> **Примечание**248>249> Описания конкретных классов узлов, приведённые здесь, изначально были адаптированы из замечательного проекта [Green Tree Snakes](https://python-all.ru/3.16/library/ast.html) и всех его участников.250251### Корневые узлы252253#### `class ast.Module(body, type_ignores)`254255A Python module, as with [file input](https://python-all.ru/3.16/reference/toplevel_components.html#file-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse) in the default `"exec"` *mode*.256257`body` is a [`list`](https://python-all.ru/3.16/library/stdtypes.html#list) of the module’s [Statements](https://python-all.ru/3.16/library/ast.html#ast-statements).258259`type_ignores` – это список [`list`](https://python-all.ru/3.16/library/stdtypes.html#list) комментариев об игнорировании типов в модуле; подробнее см. в [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse).260261```pycon262>>> print(ast.dump(ast.parse('x = 1'), indent=4))263Module(264 body=[265 Assign(266 targets=[267 Name(id='x', ctx=Store())],268 value=Constant(value=1))])269```270271#### `class ast.Expression(body)`272273A single Python [expression input](https://python-all.ru/3.16/reference/toplevel_components.html#expression-input). Node type generated by [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse) when *mode* is `"eval"`.274275`body` is a single node, one of the [expression types](https://python-all.ru/3.16/library/ast.html#ast-expressions).276277```pycon278>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))279Expression(280 body=Constant(value=123))281```282283#### `class ast.Interactive(body)`284285A single [interactive input](https://python-all.ru/3.16/reference/toplevel_components.html#interactive), like in [Interactive Mode](https://python-all.ru/3.16/tutorial/appendix.html#tut-interac). Node type generated by [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse) when *mode* is `"single"`.286287`body` is a [`list`](https://python-all.ru/3.16/library/stdtypes.html#list) of [statement nodes](https://python-all.ru/3.16/library/ast.html#ast-statements).288289```pycon290>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))291Interactive(292 body=[293 Assign(294 targets=[295 Name(id='x', ctx=Store())],296 value=Constant(value=1)),297 Assign(298 targets=[299 Name(id='y', ctx=Store())],300 value=Constant(value=2))])301```302303#### `class ast.FunctionType(argtypes, returns)`304305A 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.16/library/ast.html) annotations. Node type generated by [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse) when *mode* is `"func_type"`.306307Такие комментарии о типах выглядели следующим образом:308309```python310def sum_two_number(a, b):311 # type: (int, int) -> int312 return a + b313```314315`argtypes` is a [`list`](https://python-all.ru/3.16/library/stdtypes.html#list) of [expression nodes](https://python-all.ru/3.16/library/ast.html#ast-expressions).316317`returns` is a single [expression node](https://python-all.ru/3.16/library/ast.html#ast-expressions).318319```pycon320>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))321FunctionType(322 argtypes=[323 Name(id='int'),324 Name(id='str')],325 returns=Subscript(326 value=Name(id='List'),327 slice=Name(id='int')))328```329330Добавлено в версии 3.8.331332### Литералы333334#### `class ast.Constant(value, kind)`335336Постоянное значение. Атрибут `value` `Constant` литерала содержит представляемый объект Python. Представленными значениями могут быть экземпляры [`str`](https://python-all.ru/3.16/library/stdtypes.html#str), [`bytes`](https://python-all.ru/3.16/library/stdtypes.html#bytes), [`int`](https://python-all.ru/3.16/library/functions.html#int), [`float`](https://python-all.ru/3.16/library/functions.html#float), [`complex`](https://python-all.ru/3.16/library/functions.html#complex) и [`bool`](https://python-all.ru/3.16/library/functions.html#bool), а также константы [`None`](https://python-all.ru/3.16/library/constants.html#None) и [`Ellipsis`](https://python-all.ru/3.16/library/constants.html#Ellipsis).337338Атрибут `kind` – необязательная строка. Для строковых литералов с префиксом `u` значение `kind` устанавливается в `'u'`. Для всех остальных констант `kind` равно `None`.339340```pycon341>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))342Expression(343 body=Constant(value=123))344>>> print(ast.dump(ast.parse("u'hello'", mode='eval'), indent=4))345Expression(346 body=Constant(value='hello', kind='u'))347```348349#### `class ast.FormattedValue(value, conversion, format_spec)`350351Узел, представляющий одно поле форматирования в f-строке. Если строка содержит только одно поле форматирования и больше ничего, узел может быть изолированным; в противном случае он встречается внутри [`JoinedStr`](https://python-all.ru/3.16/library/ast.html#ast.JoinedStr).352353- `value` – это любой узел выражения (например, литерал, переменная или вызов функции).354- `conversion` – целое число:355356 - -1: без форматирования357 - 97 (`ord('a')`): форматирование `!a` [`ASCII`](https://python-all.ru/3.16/library/functions.html#ascii)358 - 114 (`ord('r')`): форматирование `!r` [`repr()`](https://python-all.ru/3.16/library/functions.html#repr)359 - 115 (`ord('s')`): форматирование `!s` [`string`](https://python-all.ru/3.16/library/stdtypes.html#str)360- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.16/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно.361362#### `class ast.JoinedStr(values)`363364F-строка, содержащая последовательность [`FormattedValue`](https://python-all.ru/3.16/library/ast.html#ast.FormattedValue) и [`Constant`](https://python-all.ru/3.16/library/ast.html#ast.Constant) узлов.365366```pycon367>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))368Expression(369 body=JoinedStr(370 values=[371 Constant(value='sin('),372 FormattedValue(373 value=Name(id='a'),374 conversion=-1),375 Constant(value=') is '),376 FormattedValue(377 value=Call(378 func=Name(id='sin'),379 args=[380 Name(id='a')]),381 conversion=-1,382 format_spec=JoinedStr(383 values=[384 Constant(value='.3')]))]))385```386387#### `class ast.TemplateStr(values, /)`388389Добавлено в версии 3.14.390391Узел, представляющий литерал шаблонной строки, содержащий последовательность [`Interpolation`](https://python-all.ru/3.16/library/ast.html#ast.Interpolation) и [`Constant`](https://python-all.ru/3.16/library/ast.html#ast.Constant) узлов. Эти узлы могут быть в любом порядке и не обязаны чередоваться.392393```pycon394>>> expr = ast.parse('t"{name} finished {place:ordinal}"', mode='eval')395>>> print(ast.dump(expr, indent=4))396Expression(397 body=TemplateStr(398 values=[399 Interpolation(400 value=Name(id='name'),401 str='name',402 conversion=-1),403 Constant(value=' finished '),404 Interpolation(405 value=Name(id='place'),406 str='place',407 conversion=-1,408 format_spec=JoinedStr(409 values=[410 Constant(value='ordinal')]))]))411```412413#### `class ast.Interpolation(value, str, conversion, format_spec=None)`414415Добавлено в версии 3.14.416417Узел, представляющий одно поле интерполяции в литерале шаблонной строки.418419- `value` – любой узел выражения (например, литерал, переменная или вызов функции). Это имеет то же значение, что и `FormattedValue.value`.420- `str` – константа, содержащая текст выражения интерполяции.421422 Если `str` установлен в `None`, то `value` используется для генерации кода при вызове [`ast.unparse()`](https://python-all.ru/3.16/library/ast.html#ast.unparse). Это больше не гарантирует, что сгенерированный код идентичен исходному, и предназначено для генерации кода.423- `conversion` – целое число:424425 - -1: без преобразования426 - 97 (`ord('a')`): преобразование `!a` [`ASCII`](https://python-all.ru/3.16/library/functions.html#ascii)427 - 114 (`ord('r')`): преобразование `!r` [`repr()`](https://python-all.ru/3.16/library/functions.html#repr)428 - 115 (`ord('s')`): преобразование `!s` [`string`](https://python-all.ru/3.16/library/stdtypes.html#str)429430 Это имеет то же значение, что и `FormattedValue.conversion`.431- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.16/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно. Это имеет то же значение, что и `FormattedValue.format_spec`.432433#### `class ast.List(elts, ctx)`434435#### `class ast.Tuple(elts, ctx)`436437Список или кортеж. `elts` содержит список узлов, представляющих элементы. `ctx` равен [`Store`](https://python-all.ru/3.16/library/ast.html#ast.Store), если контейнер является целью присваивания (т.е. `(x,y)=something`), и [`Load`](https://python-all.ru/3.16/library/ast.html#ast.Load) в противном случае.438439```pycon440>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))441Expression(442 body=List(443 elts=[444 Constant(value=1),445 Constant(value=2),446 Constant(value=3)]))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```455456#### `class ast.Set(elts)`457458Множество. `elts` содержит список узлов, представляющих элементы множества.459460```pycon461>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))462Expression(463 body=Set(464 elts=[465 Constant(value=1),466 Constant(value=2),467 Constant(value=3)]))468```469470#### `class ast.Dict(keys, values)`471472Словарь. `keys` и `values` содержат списки узлов, представляющих ключи и значения соответственно, в соответствующем порядке (то, что было бы возвращено при вызове `dictionary.keys()` и `dictionary.values()`).473474При распаковке словаря с помощью литералов словаря выражение, которое нужно раскрыть, помещается в список `values`, а `None` – на соответствующую позицию в `keys`.475476```pycon477>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))478Expression(479 body=Dict(480 keys=[481 Constant(value='a'),482 None],483 values=[484 Constant(value=1),485 Name(id='d')]))486```487488### Переменные489490#### `class ast.Name(id, ctx)`491492Имя переменной. `id` содержит имя в виде строки, а `ctx` – один из следующих типов.493494#### `class ast.Load`495496#### `class ast.Store`497498#### `class ast.Del`499500Ссылки на переменные можно использовать для загрузки значения переменной, для присваивания ей нового значения или для её удаления. Ссылки на переменные получают контекст, чтобы различать эти случаи.501502```pycon503>>> print(ast.dump(ast.parse('a'), indent=4))504Module(505 body=[506 Expr(507 value=Name(id='a'))])508509>>> print(ast.dump(ast.parse('a = 1'), indent=4))510Module(511 body=[512 Assign(513 targets=[514 Name(id='a', ctx=Store())],515 value=Constant(value=1))])516517>>> print(ast.dump(ast.parse('del a'), indent=4))518Module(519 body=[520 Delete(521 targets=[522 Name(id='a', ctx=Del())])])523```524525#### `class ast.Starred(value, ctx)`526527Ссылка на переменную `*var`. В `value` хранится переменная, обычно узел [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name). Этот тип необходимо использовать при построении узла [`Call`](https://python-all.ru/3.16/library/ast.html#ast.Call) с помощью `*args`.528529```pycon530>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))531Module(532 body=[533 Assign(534 targets=[535 Tuple(536 elts=[537 Name(id='a', ctx=Store()),538 Starred(539 value=Name(id='b', ctx=Store()),540 ctx=Store())],541 ctx=Store())],542 value=Name(id='it'))])543```544545### Выражения546547#### `class ast.Expr(value)`548549Когда выражение, например вызов функции, выступает в роли самостоятельного оператора и его возвращаемое значение не используется и не сохраняется, оно помещается в этот контейнер. `value` содержит один из остальных узлов этого раздела: узел [`Constant`](https://python-all.ru/3.16/library/ast.html#ast.Constant), узел [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name), [`Lambda`](https://python-all.ru/3.16/library/ast.html#ast.Lambda), [`Yield`](https://python-all.ru/3.16/library/ast.html#ast.Yield) или [`YieldFrom`](https://python-all.ru/3.16/library/ast.html#ast.YieldFrom).550551```pycon552>>> print(ast.dump(ast.parse('-a'), indent=4))553Module(554 body=[555 Expr(556 value=UnaryOp(557 op=USub(),558 operand=Name(id='a')))])559```560561#### `class ast.UnaryOp(op, operand)`562563Унарная операция. `op` – оператор, а `operand` – любой узел выражения.564565#### `class ast.UAdd`566567#### `class ast.USub`568569#### `class ast.Not`570571#### `class ast.Invert`572573Токены унарных операторов. `Not` – ключевое слово `not`, `Invert` – оператор `~`.574575```pycon576>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))577Expression(578 body=UnaryOp(579 op=Not(),580 operand=Name(id='x')))581```582583#### `class ast.BinOp(left, op, right)`584585Бинарная операция (например, сложение или деление). `op` – оператор, а `left` и `right` – любые узлы выражений.586587```pycon588>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))589Expression(590 body=BinOp(591 left=Name(id='x'),592 op=Add(),593 right=Name(id='y')))594```595596#### `class ast.Add`597598#### `class ast.Sub`599600#### `class ast.Mult`601602#### `class ast.Div`603604#### `class ast.FloorDiv`605606#### `class ast.Mod`607608#### `class ast.Pow`609610#### `class ast.LShift`611612#### `class ast.RShift`613614#### `class ast.BitOr`615616#### `class ast.BitXor`617618#### `class ast.BitAnd`619620#### `class ast.MatMult`621622Токены бинарных операторов.623624#### `class ast.BoolOp(op, values)`625626Логическая операция – 'or' или 'and'. `op` – это [`Or`](https://python-all.ru/3.16/library/ast.html#ast.Or) или [`And`](https://python-all.ru/3.16/library/ast.html#ast.And). `values` – участвующие значения. Последовательные операции с одним и тем же оператором, например `a or b or c`, сводятся в один узел с несколькими значениями.627628Это не включает `not`, который является [`UnaryOp`](https://python-all.ru/3.16/library/ast.html#ast.UnaryOp).629630```pycon631>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))632Expression(633 body=BoolOp(634 op=Or(),635 values=[636 Name(id='x'),637 Name(id='y')]))638```639640#### `class ast.And`641642#### `class ast.Or`643644Токены логических операторов.645646#### `class ast.Compare(left, ops, comparators)`647648Сравнение двух или более значений. `left` – первое значение в сравнении, `ops` – список операторов, а `comparators` – список значений после первого элемента сравнения.649650```pycon651>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))652Expression(653 body=Compare(654 left=Constant(value=1),655 ops=[656 LtE(),657 Lt()],658 comparators=[659 Name(id='a'),660 Constant(value=10)]))661```662663#### `class ast.Eq`664665#### `class ast.NotEq`666667#### `class ast.Lt`668669#### `class ast.LtE`670671#### `class ast.Gt`672673#### `class ast.GtE`674675#### `class ast.Is`676677#### `class ast.IsNot`678679#### `class ast.In`680681#### `class ast.NotIn`682683Токены операторов сравнения.684685#### `class ast.Call(func, args, keywords)`686687Вызов функции. `func` – это функция; обычно это объект [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name) или [`Attribute`](https://python-all.ru/3.16/library/ast.html#ast.Attribute). Об аргументах:688689- `args` содержит список аргументов, переданных по позиции.690- `keywords` содержит список объектов [`keyword`](https://python-all.ru/3.16/library/ast.html#ast.keyword), представляющих аргументы, переданные по ключевому слову.691692Аргументы `args` и `keywords` необязательны и по умолчанию равны пустым спискам.693694```pycon695>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))696Expression(697 body=Call(698 func=Name(id='func'),699 args=[700 Name(id='a'),701 Starred(702 value=Name(id='d'))],703 keywords=[704 keyword(705 arg='b',706 value=Name(id='c')),707 keyword(708 value=Name(id='e'))]))709```710711#### `class ast.keyword(arg, value)`712713Именованный аргумент вызова функции или определения класса. `arg` – это необработанная строка с именем параметра, `value` – узел, который нужно передать.714715#### `class ast.IfExp(test, body, orelse)`716717Выражение, например `a if b else c`. Каждое поле содержит один узел, поэтому в следующем примере все три являются узлами [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name).718719```pycon720>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))721Expression(722 body=IfExp(723 test=Name(id='b'),724 body=Name(id='a'),725 orelse=Name(id='c')))726```727728#### `class ast.Attribute(value, attr, ctx)`729730Доступ к атрибуту, например `d.keys`. `value` – это узел, обычно [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name). `attr` – это строка с именем атрибута, а `ctx` – [`Load`](https://python-all.ru/3.16/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.16/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.16/library/ast.html#ast.Del) в зависимости от того, как используется атрибут.731732```pycon733>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))734Expression(735 body=Attribute(736 value=Name(id='snake'),737 attr='colour'))738```739740#### `class ast.NamedExpr(target, value)`741742Именованное выражение. Этот узел AST создаётся оператором присваивания (также известным как оператор «морж»). В отличие от узла [`Assign`](https://python-all.ru/3.16/library/ast.html#ast.Assign), где первый аргумент может быть несколькими узлами, в данном случае и `target`, и `value` должны быть одиночными узлами.743744```pycon745>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))746Expression(747 body=NamedExpr(748 target=Name(id='x', ctx=Store()),749 value=Constant(value=4)))750```751752Добавлено в версии 3.8.753754#### Индексирование755756#### `class ast.Subscript(value, slice, ctx)`757758Индексация, такая как `l[1]`. `value` – индексируемый объект (обычно последовательность или отображение). `slice` – это индекс, срез или ключ. Оно может быть [`Tuple`](https://python-all.ru/3.16/library/ast.html#ast.Tuple) и содержать [`Slice`](https://python-all.ru/3.16/library/ast.html#ast.Slice). `ctx` является [`Load`](https://python-all.ru/3.16/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.16/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.16/library/ast.html#ast.Del) в зависимости от выполняемого действия при индексации.759760```pycon761>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))762Expression(763 body=Subscript(764 value=Name(id='l'),765 slice=Tuple(766 elts=[767 Slice(768 lower=Constant(value=1),769 upper=Constant(value=2)),770 Constant(value=3)])))771```772773#### `class ast.Slice(lower, upper, step)`774775Обычный срез (в виде `lower:upper` или `lower:upper:step`). Может встречаться только внутри поля *slice* узла [`Subscript`](https://python-all.ru/3.16/library/ast.html#ast.Subscript), либо напрямую, либо как элемент [`Tuple`](https://python-all.ru/3.16/library/ast.html#ast.Tuple).776777```pycon778>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))779Expression(780 body=Subscript(781 value=Name(id='l'),782 slice=Slice(783 lower=Constant(value=1),784 upper=Constant(value=2))))785```786787#### Генераторы коллекций788789#### `class ast.ListComp(elt, generators)`790791#### `class ast.SetComp(elt, generators)`792793#### `class ast.GeneratorExp(elt, generators)`794795#### `class ast.DictComp(key, value, generators)`796797Генераторы списков и множеств, генераторные выражения и генераторы словарей. `elt` (или `key` и `value`) – это один узел, представляющий часть, которая будет вычисляться для каждого элемента.798799`generators` – это список узлов [`comprehension`](https://python-all.ru/3.16/library/ast.html#ast.comprehension).800801```pycon802>>> print(ast.dump(803... ast.parse('[x for x in numbers]', mode='eval'),804... indent=4,805... ))806Expression(807 body=ListComp(808 elt=Name(id='x'),809 generators=[810 comprehension(811 target=Name(id='x', ctx=Store()),812 iter=Name(id='numbers'),813 is_async=0)]))814>>> print(ast.dump(815... ast.parse('{x: x**2 for x in numbers}', mode='eval'),816... indent=4,817... ))818Expression(819 body=DictComp(820 key=Name(id='x'),821 value=BinOp(822 left=Name(id='x'),823 op=Pow(),824 right=Constant(value=2)),825 generators=[826 comprehension(827 target=Name(id='x', ctx=Store()),828 iter=Name(id='numbers'),829 is_async=0)]))830>>> print(ast.dump(831... ast.parse('{x for x in numbers}', mode='eval'),832... indent=4,833... ))834Expression(835 body=SetComp(836 elt=Name(id='x'),837 generators=[838 comprehension(839 target=Name(id='x', ctx=Store()),840 iter=Name(id='numbers'),841 is_async=0)]))842```843844#### `class ast.comprehension(target, iter, ifs, is_async)`845846Одно предложение `for` в генераторе коллекции. `target` – это ссылка, используемая для каждого элемента (обычно узел [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name) или [`Tuple`](https://python-all.ru/3.16/library/ast.html#ast.Tuple)). `iter` – объект, по которому выполняется итерация. `ifs` – список проверочных выражений: каждое предложение `for` может содержать несколько `ifs`.847848`is_async` указывает, что генератор коллекции является асинхронным (использует `async for` вместо `for`). Значение – целое число (0 или 1).849850```pycon851>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),852... indent=4)) # несколько включений в одном853Expression(854 body=ListComp(855 elt=Call(856 func=Name(id='ord'),857 args=[858 Name(id='c')]),859 generators=[860 comprehension(861 target=Name(id='line', ctx=Store()),862 iter=Name(id='file'),863 is_async=0),864 comprehension(865 target=Name(id='c', ctx=Store()),866 iter=Name(id='line'),867 is_async=0)]))868869>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),870... indent=4)) # выражение-генератор871Expression(872 body=GeneratorExp(873 elt=BinOp(874 left=Name(id='n'),875 op=Pow(),876 right=Constant(value=2)),877 generators=[878 comprehension(879 target=Name(id='n', ctx=Store()),880 iter=Name(id='it'),881 ifs=[882 Compare(883 left=Name(id='n'),884 ops=[885 Gt()],886 comparators=[887 Constant(value=5)]),888 Compare(889 left=Name(id='n'),890 ops=[891 Lt()],892 comparators=[893 Constant(value=10)])],894 is_async=0)]))895896>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),897... indent=4)) # асинхронное включение898Expression(899 body=ListComp(900 elt=Name(id='i'),901 generators=[902 comprehension(903 target=Name(id='i', ctx=Store()),904 iter=Name(id='soc'),905 is_async=1)]))906```907908### Инструкции909910#### `class ast.Assign(targets, value, type_comment)`911912Присваивание. `targets` – список узлов, а `value` – один узел.913914Несколько узлов в `targets` обозначают присваивание одного и того же значения каждому. Распаковка представляется помещением узла [`Tuple`](https://python-all.ru/3.16/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.16/library/ast.html#ast.List) внутрь `targets`.915916#### `type_comment`917918`type_comment` – необязательная строка с аннотацией типа в виде комментария.919920```pycon921>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # множественное присваивание922Module(923 body=[924 Assign(925 targets=[926 Name(id='a', ctx=Store()),927 Name(id='b', ctx=Store())],928 value=Constant(value=1))])929930>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # распаковка931Module(932 body=[933 Assign(934 targets=[935 Tuple(936 elts=[937 Name(id='a', ctx=Store()),938 Name(id='b', ctx=Store())],939 ctx=Store())],940 value=Name(id='c'))])941```942943#### `class ast.AnnAssign(target, annotation, value, simple)`944945Присваивание с аннотацией типа. `target` – это один узел, который может быть [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.16/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.16/library/ast.html#ast.Subscript). `annotation` – аннотация, например узел [`Constant`](https://python-all.ru/3.16/library/ast.html#ast.Constant) или `Name`. `value` – один необязательный узел.946947`simple` всегда равен либо 0 (обозначает «сложную» цель), либо 1 (обозначает «простую» цель). «Простая» цель состоит только из узла [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name), который не находится в круглых скобках; все остальные цели считаются сложными. Только простые цели появляются в словаре [`__annotations__`](https://python-all.ru/3.16/reference/datamodel.html#object.__annotations__) модулей и классов.948949```pycon950>>> print(ast.dump(ast.parse('c: int'), indent=4))951Module(952 body=[953 AnnAssign(954 target=Name(id='c', ctx=Store()),955 annotation=Name(id='int'),956 simple=1)])957958>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # аннотация со скобками959Module(960 body=[961 AnnAssign(962 target=Name(id='a', ctx=Store()),963 annotation=Name(id='int'),964 value=Constant(value=1),965 simple=0)])966967>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # аннотация атрибута968Module(969 body=[970 AnnAssign(971 target=Attribute(972 value=Name(id='a'),973 attr='b',974 ctx=Store()),975 annotation=Name(id='int'),976 simple=0)])977978>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # аннотация подписки979Module(980 body=[981 AnnAssign(982 target=Subscript(983 value=Name(id='a'),984 slice=Constant(value=1),985 ctx=Store()),986 annotation=Name(id='int'),987 simple=0)])988```989990#### `class ast.AugAssign(target, op, value)`991992Расширенное присваивание, например `a += 1`. В следующем примере `target` – это узел [Имя](https://python-all.ru/3.16/library/ast.html#ast.Name) для `x` (с контекстом [`Store`](https://python-all.ru/3.16/library/ast.html#ast.Store)), `op` – это [Сложение](https://python-all.ru/3.16/library/ast.html#ast.Add), а `value` – это [Константа](https://python-all.ru/3.16/library/ast.html#ast.Constant) со значением 1.993994Атрибут `target` не может быть класса [`Tuple`](https://python-all.ru/3.16/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.16/library/ast.html#ast.List), в отличие от целей [`Assign`](https://python-all.ru/3.16/library/ast.html#ast.Assign).995996```pycon997>>> print(ast.dump(ast.parse('x += 2'), indent=4))998Module(999 body=[1000 AugAssign(1001 target=Name(id='x', ctx=Store()),1002 op=Add(),1003 value=Constant(value=2))])1004```10051006#### `class ast.Raise(exc, cause)`10071008Инструкция `raise`. `exc` – объект исключения, который необходимо возбудить, обычно [Вызов](https://python-all.ru/3.16/library/ast.html#ast.Call) или [Имя](https://python-all.ru/3.16/library/ast.html#ast.Name), или `None` для отдельного `raise`. `cause` – необязательная часть для `y` в `Возбуждение`.10091010```pycon1011>>> print(ast.dump(ast.parse('raise x from y'), indent=4))1012Module(1013 body=[1014 Raise(1015 exc=Name(id='x'),1016 cause=Name(id='y'))])1017```10181019#### `class ast.Assert(test, msg)`10201021Утверждение. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.16/library/ast.html#ast.Compare). `msg` содержит сообщение об ошибке.10221023```pycon1024>>> print(ast.dump(ast.parse('assert x,y'), indent=4))1025Module(1026 body=[1027 Assert(1028 test=Name(id='x'),1029 msg=Name(id='y'))])1030```10311032#### `class ast.Delete(targets)`10331034Представляет инструкцию `del`. `targets` – список узлов, например узлов [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.16/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.16/library/ast.html#ast.Subscript).10351036```pycon1037>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))1038Module(1039 body=[1040 Delete(1041 targets=[1042 Name(id='x', ctx=Del()),1043 Name(id='y', ctx=Del()),1044 Name(id='z', ctx=Del())])])1045```10461047#### `class ast.Pass`10481049Инструкция `pass`.10501051```pycon1052>>> print(ast.dump(ast.parse('pass'), indent=4))1053Module(1054 body=[1055 Pass()])1056```10571058#### `class ast.TypeAlias(name, type_params, value)`10591060[Псевдоним типа](https://python-all.ru/3.16/library/typing.html#type-aliases), созданный с помощью инструкции [`type`](https://python-all.ru/3.16/reference/simple_stmts.html#type) . `name` – имя псевдонима, `type_params` – список [параметров типа](https://python-all.ru/3.16/library/ast.html#ast-type-params), а `value` – значение псевдонима типа.10611062```pycon1063>>> print(ast.dump(ast.parse('type Alias = int'), indent=4))1064Module(1065 body=[1066 TypeAlias(1067 name=Name(id='Alias', ctx=Store()),1068 value=Name(id='int'))])1069```10701071Добавлено в версии 3.12.10721073Другие инструкции, которые применимы только внутри функций или циклов, описаны в других разделах.10741075#### Импорты10761077#### `class ast.Import(names)`10781079Инструкция импорта. `names` – это список узлов [`alias`](https://python-all.ru/3.16/library/ast.html#ast.alias).10801081```pycon1082>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))1083Module(1084 body=[1085 Import(1086 names=[1087 alias(name='x'),1088 alias(name='y'),1089 alias(name='z')],1090 is_lazy=0)])1091```10921093#### `class ast.ImportFrom(module, names, level)`10941095Представляет `from x import y`. `module` – это необработанная строка имени from, без начальных точек, или `None` для инструкций вроде `from . import foo`. `level` – целое число, указывающее уровень относительного импорта (0 означает абсолютный импорт).10961097```pycon1098>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))1099Module(1100 body=[1101 ImportFrom(1102 module='y',1103 names=[1104 alias(name='x'),1105 alias(name='y'),1106 alias(name='z')],1107 level=0,1108 is_lazy=0)])1109```11101111#### `class ast.alias(name, asname)`11121113Оба параметра – необработанные строки имён. `asname` может быть `None`, если должно использоваться обычное имя.11141115```pycon1116>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))1117Module(1118 body=[1119 ImportFrom(1120 module='foo.bar',1121 names=[1122 alias(name='a', asname='b'),1123 alias(name='c')],1124 level=2,1125 is_lazy=0)])1126```11271128### Управление потоком11291130> **Примечание**1131>1132> Необязательные предложения, такие как `else`, сохраняются как пустой список, если они отсутствуют.11331134#### `class ast.If(test, body, orelse)`11351136Инструкция `if`. `test` содержит один узел, например узел [`Compare`](https://python-all.ru/3.16/library/ast.html#ast.Compare). `body` и `orelse` содержат по списку узлов.11371138Предложения `elif` не имеют специального представления в AST, а появляются как дополнительные узлы `If` в разделе `orelse` предыдущего.11391140```pycon1141>>> print(ast.dump(ast.parse("""1142... if x:1143... ...1144... elif y:1145... ...1146... else:1147... ...1148... """), indent=4))1149Module(1150 body=[1151 If(1152 test=Name(id='x'),1153 body=[1154 Expr(1155 value=Constant(value=Ellipsis))],1156 orelse=[1157 If(1158 test=Name(id='y'),1159 body=[1160 Expr(1161 value=Constant(value=Ellipsis))],1162 orelse=[1163 Expr(1164 value=Constant(value=Ellipsis))])])])1165```11661167#### `class ast.For(target, iter, body, orelse, type_comment)`11681169Цикл `for`. `target` содержит переменную (или переменные), которой присваивает цикл, в виде одного узла [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.16/library/ast.html#ast.Tuple), [`List`](https://python-all.ru/3.16/library/ast.html#ast.List), [`Attribute`](https://python-all.ru/3.16/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.16/library/ast.html#ast.Subscript). `iter` содержит элемент, по которому выполняется итерация, также в виде одного узла. `body` и `orelse` содержат списки узлов для выполнения. Те, что в `orelse`, выполняются, если цикл завершается нормально, а не по инструкции `break`.11701171#### `type_comment`11721173`type_comment` – необязательная строка с аннотацией типа в виде комментария.11741175```pycon1176>>> print(ast.dump(ast.parse("""1177... for x in y:1178... ...1179... else:1180... ...1181... """), indent=4))1182Module(1183 body=[1184 For(1185 target=Name(id='x', ctx=Store()),1186 iter=Name(id='y'),1187 body=[1188 Expr(1189 value=Constant(value=Ellipsis))],1190 orelse=[1191 Expr(1192 value=Constant(value=Ellipsis))])])1193```11941195#### `class ast.While(test, body, orelse)`11961197Цикл `while`. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.16/library/ast.html#ast.Compare).11981199```pycon1200>>> print(ast.dump(ast.parse("""1201... while x:1202... ...1203... else:1204... ...1205... """), indent=4))1206Module(1207 body=[1208 While(1209 test=Name(id='x'),1210 body=[1211 Expr(1212 value=Constant(value=Ellipsis))],1213 orelse=[1214 Expr(1215 value=Constant(value=Ellipsis))])])1216```12171218#### `class ast.Break`12191220#### `class ast.Continue`12211222Инструкции `break` и `continue`.12231224```pycon1225>>> print(ast.dump(ast.parse("""\1226... for a in b:1227... if a > 5:1228... break1229... else:1230... continue1231...1232... """), indent=4))1233Module(1234 body=[1235 For(1236 target=Name(id='a', ctx=Store()),1237 iter=Name(id='b'),1238 body=[1239 If(1240 test=Compare(1241 left=Name(id='a'),1242 ops=[1243 Gt()],1244 comparators=[1245 Constant(value=5)]),1246 body=[1247 Break()],1248 orelse=[1249 Continue()])])])1250```12511252#### `class ast.Try(body, handlers, orelse, finalbody)`12531254Блоки `try`. Все атрибуты – списки узлов для выполнения, за исключением `handlers`, который является списком узлов [`ExceptHandler`](https://python-all.ru/3.16/library/ast.html#ast.ExceptHandler).12551256```pycon1257>>> print(ast.dump(ast.parse("""1258... try:1259... ...1260... except Exception:1261... ...1262... except OtherException as e:1263... ...1264... else:1265... ...1266... finally:1267... ...1268... """), indent=4))1269Module(1270 body=[1271 Try(1272 body=[1273 Expr(1274 value=Constant(value=Ellipsis))],1275 handlers=[1276 ExceptHandler(1277 type=Name(id='Exception'),1278 body=[1279 Expr(1280 value=Constant(value=Ellipsis))]),1281 ExceptHandler(1282 type=Name(id='OtherException'),1283 name='e',1284 body=[1285 Expr(1286 value=Constant(value=Ellipsis))])],1287 orelse=[1288 Expr(1289 value=Constant(value=Ellipsis))],1290 finalbody=[1291 Expr(1292 value=Constant(value=Ellipsis))])])1293```12941295#### `class ast.TryStar(body, handlers, orelse, finalbody)`12961297Блоки `try`, за которыми следуют предложения `except*`. Атрибуты такие же, как для [`Try`](https://python-all.ru/3.16/library/ast.html#ast.Try), но узлы [`ExceptHandler`](https://python-all.ru/3.16/library/ast.html#ast.ExceptHandler) в `handlers` интерпретируются как блоки `except*`, а не `except`.12981299```pycon1300>>> print(ast.dump(ast.parse("""1301... try:1302... ...1303... except* Exception:1304... ...1305... """), indent=4))1306Module(1307 body=[1308 TryStar(1309 body=[1310 Expr(1311 value=Constant(value=Ellipsis))],1312 handlers=[1313 ExceptHandler(1314 type=Name(id='Exception'),1315 body=[1316 Expr(1317 value=Constant(value=Ellipsis))])])])1318```13191320Добавлено в версии 3.12.13211322#### `class ast.ExceptHandler(type, name, body)`13231324Одно предложение `except`. `type` – тип исключения, который оно перехватывает, обычно узел [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name) (или `None` для универсального предложения `except:`). `name` – необработанная строка для имени, в котором будет сохранено исключение, или `None`, если в предложении нет `as foo`. `body` – список узлов.13251326```pycon1327>>> print(ast.dump(ast.parse("""\1328... try:1329... a + 11330... except TypeError:1331... pass1332... """), indent=4))1333Module(1334 body=[1335 Try(1336 body=[1337 Expr(1338 value=BinOp(1339 left=Name(id='a'),1340 op=Add(),1341 right=Constant(value=1)))],1342 handlers=[1343 ExceptHandler(1344 type=Name(id='TypeError'),1345 body=[1346 Pass()])])])1347```13481349#### `class ast.With(items, body, type_comment)`13501351Блок `with`. `items` – это список узлов [`withitem`](https://python-all.ru/3.16/library/ast.html#ast.withitem), представляющих менеджеры контекста, а `body` – это блок с отступом внутри контекста.13521353#### `type_comment`13541355`type_comment` – это необязательная строка, содержащая аннотацию типа в виде комментария.13561357#### `class ast.withitem(context_expr, optional_vars)`13581359Один менеджер контекста в блоке `with`. `context_expr` – это менеджер контекста, часто узел [`Call`](https://python-all.ru/3.16/library/ast.html#ast.Call). `optional_vars` – это [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.16/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.16/library/ast.html#ast.List) для части `as foo`, или `None`, если она не используется.13601361```pycon1362>>> print(ast.dump(ast.parse("""\1363... with a as b, c as d:1364... something(b, d)1365... """), indent=4))1366Module(1367 body=[1368 With(1369 items=[1370 withitem(1371 context_expr=Name(id='a'),1372 optional_vars=Name(id='b', ctx=Store())),1373 withitem(1374 context_expr=Name(id='c'),1375 optional_vars=Name(id='d', ctx=Store()))],1376 body=[1377 Expr(1378 value=Call(1379 func=Name(id='something'),1380 args=[1381 Name(id='b'),1382 Name(id='d')]))])])1383```13841385### Сопоставление с образцом13861387#### `class ast.Match(subject, cases)`13881389Оператор `match`. В `subject` хранится subject сопоставления (объект, который сравнивается с вариантами), а `cases` содержит итерируемый набор узлов [`match_case`](https://python-all.ru/3.16/library/ast.html#ast.match_case) с различными вариантами.13901391Добавлено в версии 3.10.13921393#### `class ast.match_case(pattern, guard, body)`13941395Один вариант (case) в операторе `match`. `pattern` содержит шаблон сопоставления, с которым будет сравниваться subject. Обратите внимание, что узлы [`AST`](https://python-all.ru/3.16/library/ast.html#ast.AST), создаваемые для шаблонов, отличаются от узлов, создаваемых для выражений, даже при одинаковом синтаксисе.13961397Атрибут `guard` содержит выражение, которое будет вычислено, если шаблон совпадает с subject.13981399`body` содержит список узлов, которые выполняются, если шаблон совпадает и результат вычисления guard-выражения истинен.14001401```pycon1402>>> print(ast.dump(ast.parse("""1403... match x:1404... case [x] if x>0:1405... ...1406... case tuple():1407... ...1408... """), indent=4))1409Module(1410 body=[1411 Match(1412 subject=Name(id='x'),1413 cases=[1414 match_case(1415 pattern=MatchSequence(1416 patterns=[1417 MatchAs(name='x')]),1418 guard=Compare(1419 left=Name(id='x'),1420 ops=[1421 Gt()],1422 comparators=[1423 Constant(value=0)]),1424 body=[1425 Expr(1426 value=Constant(value=Ellipsis))]),1427 match_case(1428 pattern=MatchClass(1429 cls=Name(id='tuple')),1430 body=[1431 Expr(1432 value=Constant(value=Ellipsis))])])])1433```14341435Добавлено в версии 3.10.14361437#### `class ast.MatchValue(value)`14381439Сопоставление с литералом или шаблоном значения, сравниваемым по равенству. `value` – это узел выражения. Допустимые узлы значений ограничены, как описано в документации оператора match. Этот шаблон успешно срабатывает, если subject сопоставления равен вычисленному значению.14401441```pycon1442>>> print(ast.dump(ast.parse("""1443... match x:1444... case "Relevant":1445... ...1446... """), indent=4))1447Module(1448 body=[1449 Match(1450 subject=Name(id='x'),1451 cases=[1452 match_case(1453 pattern=MatchValue(1454 value=Constant(value='Relevant')),1455 body=[1456 Expr(1457 value=Constant(value=Ellipsis))])])])1458```14591460Добавлено в версии 3.10.14611462#### `class ast.MatchSingleton(value)`14631464Сопоставление с литералом, сравниваемым по идентичности. `value` – это синглтон, с которым производится сравнение: `None`, `True` или `False`. Этот шаблон успешно срабатывает, если subject сопоставления является заданной константой.14651466```pycon1467>>> print(ast.dump(ast.parse("""1468... match x:1469... case None:1470... ...1471... """), indent=4))1472Module(1473 body=[1474 Match(1475 subject=Name(id='x'),1476 cases=[1477 match_case(1478 pattern=MatchSingleton(value=None),1479 body=[1480 Expr(1481 value=Constant(value=Ellipsis))])])])1482```14831484Добавлено в версии 3.10.14851486#### `class ast.MatchSequence(patterns)`14871488Шаблон последовательности (sequence pattern) в match. `patterns` содержит шаблоны, которые будут сопоставляться с элементами subject, если subject является последовательностью. Сопоставляется с последовательностью переменной длины, если один из подшаблонов является узлом `MatchStar`, в противном случае сопоставляется с последовательностью фиксированной длины.14891490```pycon1491>>> print(ast.dump(ast.parse("""1492... match x:1493... case [1, 2]:1494... ...1495... """), indent=4))1496Module(1497 body=[1498 Match(1499 subject=Name(id='x'),1500 cases=[1501 match_case(1502 pattern=MatchSequence(1503 patterns=[1504 MatchValue(1505 value=Constant(value=1)),1506 MatchValue(1507 value=Constant(value=2))]),1508 body=[1509 Expr(1510 value=Constant(value=Ellipsis))])])])1511```15121513Добавлено в версии 3.10.15141515#### `class ast.MatchStar(name)`15161517Сопоставляется с остатком последовательности в шаблоне последовательности переменной длины. Если `name` не равно `None`, то при успешном сопоставлении всего шаблона последовательности этому имени привязывается список, содержащий оставшиеся элементы последовательности.15181519```pycon1520>>> print(ast.dump(ast.parse("""1521... match x:1522... case [1, 2, *rest]:1523... ...1524... case [*_]:1525... ...1526... """), indent=4))1527Module(1528 body=[1529 Match(1530 subject=Name(id='x'),1531 cases=[1532 match_case(1533 pattern=MatchSequence(1534 patterns=[1535 MatchValue(1536 value=Constant(value=1)),1537 MatchValue(1538 value=Constant(value=2)),1539 MatchStar(name='rest')]),1540 body=[1541 Expr(1542 value=Constant(value=Ellipsis))]),1543 match_case(1544 pattern=MatchSequence(1545 patterns=[1546 MatchStar()]),1547 body=[1548 Expr(1549 value=Constant(value=Ellipsis))])])])1550```15511552Добавлено в версии 3.10.15531554#### `class ast.MatchMapping(keys, patterns, rest)`15551556Шаблон отображения (mapping pattern) в match. `keys` – последовательность узлов выражений. `patterns` – соответствующая последовательность узлов шаблонов. `rest` – необязательное имя, которое можно указать для захвата оставшихся элементов отображения. Допустимые ключевые выражения ограничены, как описано в документации оператора match.15571558Этот шаблон успешно срабатывает, если subject является отображением, все вычисленные ключевые выражения присутствуют в отображении, а значение, соответствующее каждому ключу, совпадает с соответствующим подшаблоном. Если `rest` не равно `None`, то при успешном сопоставлении всего шаблона отображения этому имени привязывается словарь, содержащий оставшиеся элементы отображения.15591560```pycon1561>>> print(ast.dump(ast.parse("""1562... match x:1563... case {1: _, 2: _}:1564... ...1565... case {**rest}:1566... ...1567... """), indent=4))1568Module(1569 body=[1570 Match(1571 subject=Name(id='x'),1572 cases=[1573 match_case(1574 pattern=MatchMapping(1575 keys=[1576 Constant(value=1),1577 Constant(value=2)],1578 patterns=[1579 MatchAs(),1580 MatchAs()]),1581 body=[1582 Expr(1583 value=Constant(value=Ellipsis))]),1584 match_case(1585 pattern=MatchMapping(rest='rest'),1586 body=[1587 Expr(1588 value=Constant(value=Ellipsis))])])])1589```15901591Добавлено в версии 3.10.15921593#### `class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)`15941595Шаблон класса (class pattern) в match. `cls` – выражение, задающее номинальный класс для сопоставления. `patterns` – последовательность узлов шаблонов, которые будут сопоставляться с определённой классом последовательностью атрибутов для сопоставления с образцом. `kwd_attrs` – последовательность дополнительных атрибутов для сопоставления (указанных как ключевые аргументы в шаблоне класса), `kwd_patterns` – соответствующие шаблоны (указанные как значения ключевых слов в шаблоне класса).15961597Этот шаблон успешно срабатывает, если subject является экземпляром указанного класса, все позиционные шаблоны совпадают с соответствующими атрибутами, определёнными классом, и все указанные ключевые атрибуты совпадают со своими шаблонами.15981599Примечание: классы могут определять свойство, возвращающее self, чтобы сопоставлять узел шаблона с сопоставляемым экземпляром. Некоторые встроенные типы также сопоставляются таким образом, как описано в документации оператора match.16001601```pycon1602>>> print(ast.dump(ast.parse("""1603... match x:1604... case Point2D(0, 0):1605... ...1606... case Point3D(x=0, y=0, z=0):1607... ...1608... """), indent=4))1609Module(1610 body=[1611 Match(1612 subject=Name(id='x'),1613 cases=[1614 match_case(1615 pattern=MatchClass(1616 cls=Name(id='Point2D'),1617 patterns=[1618 MatchValue(1619 value=Constant(value=0)),1620 MatchValue(1621 value=Constant(value=0))]),1622 body=[1623 Expr(1624 value=Constant(value=Ellipsis))]),1625 match_case(1626 pattern=MatchClass(1627 cls=Name(id='Point3D'),1628 kwd_attrs=[1629 'x',1630 'y',1631 'z'],1632 kwd_patterns=[1633 MatchValue(1634 value=Constant(value=0)),1635 MatchValue(1636 value=Constant(value=0)),1637 MatchValue(1638 value=Constant(value=0))]),1639 body=[1640 Expr(1641 value=Constant(value=Ellipsis))])])])1642```16431644Добавлено в версии 3.10.16451646#### `class ast.MatchAs(pattern, name)`16471648Сопоставление «as-pattern», шаблон захвата (capture pattern) или шаблон-заменитель (wildcard pattern). `pattern` содержит шаблон match, с которым будет сопоставлен subject. Если шаблон равен `None`, узел представляет собой шаблон захвата (т.е. просто имя) и всегда успешно срабатывает.16491650Атрибут `name` содержит имя, которое будет привязано при успешном сопоставлении шаблона. Если `name` равно `None`, то `pattern` также должно быть `None`, и узел представляет собой шаблон-заменитель (wildcard).16511652```pycon1653>>> print(ast.dump(ast.parse("""1654... match x:1655... case [x] as y:1656... ...1657... case _:1658... ...1659... """), indent=4))1660Module(1661 body=[1662 Match(1663 subject=Name(id='x'),1664 cases=[1665 match_case(1666 pattern=MatchAs(1667 pattern=MatchSequence(1668 patterns=[1669 MatchAs(name='x')]),1670 name='y'),1671 body=[1672 Expr(1673 value=Constant(value=Ellipsis))]),1674 match_case(1675 pattern=MatchAs(),1676 body=[1677 Expr(1678 value=Constant(value=Ellipsis))])])])1679```16801681Добавлено в версии 3.10.16821683#### `class ast.MatchOr(patterns)`16841685Сопоставление «or-pattern» (шаблон ИЛИ). Or-pattern последовательно сопоставляет каждый из своих подшаблонов с subject, пока один из них не сработает. Тогда считается, что or-pattern сработал. Если ни один из подшаблонов не сработал, or-pattern не срабатывает. Атрибут `patterns` содержит список узлов шаблонов match, которые будут сопоставляться с subject.16861687```pycon1688>>> print(ast.dump(ast.parse("""1689... match x:1690... case [x] | (y):1691... ...1692... """), indent=4))1693Module(1694 body=[1695 Match(1696 subject=Name(id='x'),1697 cases=[1698 match_case(1699 pattern=MatchOr(1700 patterns=[1701 MatchSequence(1702 patterns=[1703 MatchAs(name='x')]),1704 MatchAs(name='y')]),1705 body=[1706 Expr(1707 value=Constant(value=Ellipsis))])])])1708```17091710Добавлено в версии 3.10.17111712### Аннотации типов17131714#### `class ast.TypeIgnore(lineno, tag)`17151716Комментарий `# type: ignore`, расположенный на строке *lineno*. *tag* – опциональный тег, задаваемый формой `# type: ignore <tag>`.17171718```pycon1719>>> print(ast.dump(ast.parse('x = 1 # type: ignore', type_comments=True), indent=4))1720Module(1721 body=[1722 Assign(1723 targets=[1724 Name(id='x', ctx=Store())],1725 value=Constant(value=1))],1726 type_ignores=[1727 TypeIgnore(lineno=1, tag='')])1728>>> print(ast.dump(ast.parse('x: bool = 1 # type: ignore[assignment]', type_comments=True), indent=4))1729Module(1730 body=[1731 AnnAssign(1732 target=Name(id='x', ctx=Store()),1733 annotation=Name(id='bool'),1734 value=Constant(value=1),1735 simple=1)],1736 type_ignores=[1737 TypeIgnore(lineno=1, tag='[assignment]')])1738```17391740> **Примечание**1741>1742> Узлы `TypeIgnore` не создаются, когда параметр *type\_comments* установлен в `False` (по умолчанию). Подробнее см. [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse).17431744Добавлено в версии 3.8.17451746### Параметры типа17471748[Параметры типа](https://python-all.ru/3.16/reference/compound_stmts.html#type-params) могут существовать у классов, функций и псевдонимов типов.17491750#### `class ast.TypeVar(name, bound, default_value)`17511752[`typing.TypeVar`](https://python-all.ru/3.16/library/typing.html#typing.TypeVar). `name` – это имя переменной типа. `bound` – это граница или ограничения, если они есть. Если `bound` представляет собой [`Tuple`](https://python-all.ru/3.16/library/ast.html#ast.Tuple), то это ограничения; иначе – граница. `default_value` – значение по умолчанию; если `TypeVar` не имеет значения по умолчанию, то этот атрибут равен `None`.17531754```pycon1755>>> print(ast.dump(ast.parse("type Alias[T: int = bool] = list[T]"), indent=4))1756Module(1757 body=[1758 TypeAlias(1759 name=Name(id='Alias', ctx=Store()),1760 type_params=[1761 TypeVar(1762 name='T',1763 bound=Name(id='int'),1764 default_value=Name(id='bool'))],1765 value=Subscript(1766 value=Name(id='list'),1767 slice=Name(id='T')))])1768```17691770Добавлено в версии 3.12.17711772Изменено в версии 3.13: Добавлен параметр *default\_value*.17731774#### `class ast.ParamSpec(name, default_value)`17751776[`typing.ParamSpec`](https://python-all.ru/3.16/library/typing.html#typing.ParamSpec). `name` – это имя спецификации параметра. `default_value` – значение по умолчанию; если `ParamSpec` не имеет значения по умолчанию, то этот атрибут устанавливается в `None`.17771778```pycon1779>>> print(ast.dump(ast.parse("type Alias[**P = [int, str]] = Callable[P, int]"), indent=4))1780Module(1781 body=[1782 TypeAlias(1783 name=Name(id='Alias', ctx=Store()),1784 type_params=[1785 ParamSpec(1786 name='P',1787 default_value=List(1788 elts=[1789 Name(id='int'),1790 Name(id='str')]))],1791 value=Subscript(1792 value=Name(id='Callable'),1793 slice=Tuple(1794 elts=[1795 Name(id='P'),1796 Name(id='int')])))])1797```17981799Добавлено в версии 3.12.18001801Изменено в версии 3.13: Добавлен параметр *default\_value*.18021803#### `class ast.TypeVarTuple(name, default_value)`18041805[`typing.TypeVarTuple`](https://python-all.ru/3.16/library/typing.html#typing.TypeVarTuple). `name` – это имя кортежа переменных типа. `default_value` – значение по умолчанию; если `TypeVarTuple` не имеет значения по умолчанию, то этот атрибут устанавливается в `None`.18061807```pycon1808>>> print(ast.dump(ast.parse("type Alias[*Ts = ()] = tuple[*Ts]"), indent=4))1809Module(1810 body=[1811 TypeAlias(1812 name=Name(id='Alias', ctx=Store()),1813 type_params=[1814 TypeVarTuple(name='Ts', default_value=Tuple())],1815 value=Subscript(1816 value=Name(id='tuple'),1817 slice=Tuple(1818 elts=[1819 Starred(1820 value=Name(id='Ts'))])))])1821```18221823Добавлено в версии 3.12.18241825Изменено в версии 3.13: Добавлен параметр *default\_value*.18261827### Определения функций и классов18281829#### `class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`18301831Определение функции.18321833- `name` – это необработанная строка имени функции.1834- `args` – это узел [`arguments`](https://python-all.ru/3.16/library/ast.html#ast.arguments).1835- `body` – это список узлов внутри функции.1836- `decorator_list` – это список декораторов, которые будут применены; декораторы перечислены от самого внешнего к внутреннему (т.е. первый в списке применяется последним).1837- `returns` – это аннотация возвращаемого значения.1838- `type_params` – это список [параметров типа](https://python-all.ru/3.16/library/ast.html#ast-type-params).18391840#### `type_comment`18411842`type_comment` – это необязательная строка с аннотацией типа в виде комментария.18431844Изменено в версии 3.12: Добавлен `type_params`.18451846#### `class ast.Lambda(args, body)`18471848`lambda` – это минимальное определение функции, которое можно использовать внутри выражения. В отличие от [`FunctionDef`](https://python-all.ru/3.16/library/ast.html#ast.FunctionDef), `body` содержит один узел.18491850```pycon1851>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))1852Module(1853 body=[1854 Expr(1855 value=Lambda(1856 args=arguments(1857 args=[1858 arg(arg='x'),1859 arg(arg='y')]),1860 body=Constant(value=Ellipsis)))])1861```18621863#### `class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)`18641865Аргументы функции.18661867- `posonlyargs`, `args` и `kwonlyargs` – это списки узлов [`arg`](https://python-all.ru/3.16/library/ast.html#ast.arg).1868- `vararg` и `kwarg` – это одиночные узлы [`arg`](https://python-all.ru/3.16/library/ast.html#ast.arg), ссылающиеся на параметры `*args, **kwargs`.1869- `kw_defaults` – это список значений по умолчанию для keyword-only аргументов. Если один из них равен `None`, соответствующий аргумент обязателен.1870- `defaults` – это список значений по умолчанию для аргументов, которые можно передавать позиционно. Если значений по умолчанию меньше, они соответствуют последним n аргументам.18711872#### `class ast.arg(arg, annotation, type_comment)`18731874Один аргумент в списке. `arg` – это сырая строка с именем аргумента; `annotation` – это его аннотация, например, узел [`Name`](https://python-all.ru/3.16/library/ast.html#ast.Name).18751876#### `type_comment`18771878`type_comment` – это необязательная строка с аннотацией типа в виде комментария18791880```pycon1881>>> print(ast.dump(ast.parse("""\1882... @decorator11883... @decorator21884... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':1885... pass1886... """), indent=4))1887Module(1888 body=[1889 FunctionDef(1890 name='f',1891 args=arguments(1892 args=[1893 arg(1894 arg='a',1895 annotation=Constant(value='annotation')),1896 arg(arg='b'),1897 arg(arg='c')],1898 vararg=arg(arg='d'),1899 kwonlyargs=[1900 arg(arg='e'),1901 arg(arg='f')],1902 kw_defaults=[1903 None,1904 Constant(value=3)],1905 kwarg=arg(arg='g'),1906 defaults=[1907 Constant(value=1),1908 Constant(value=2)]),1909 body=[1910 Pass()],1911 decorator_list=[1912 Name(id='decorator1'),1913 Name(id='decorator2')],1914 returns=Constant(value='return annotation'))])1915```19161917#### `class ast.Return(value)`19181919Инструкция `return`.19201921```pycon1922>>> print(ast.dump(ast.parse('return 4'), indent=4))1923Module(1924 body=[1925 Return(1926 value=Constant(value=4))])1927```19281929#### `class ast.Yield(value)`19301931#### `class ast.YieldFrom(value)`19321933Выражение `yield` или `yield from`. Поскольку это выражения, они должны быть обёрнуты в узел [`Expr`](https://python-all.ru/3.16/library/ast.html#ast.Expr), если возвращаемое значение не используется.19341935```pycon1936>>> print(ast.dump(ast.parse('yield x'), indent=4))1937Module(1938 body=[1939 Expr(1940 value=Yield(1941 value=Name(id='x')))])19421943>>> print(ast.dump(ast.parse('yield from x'), indent=4))1944Module(1945 body=[1946 Expr(1947 value=YieldFrom(1948 value=Name(id='x')))])1949```19501951#### `class ast.Global(names)`19521953#### `class ast.Nonlocal(names)`19541955Инструкции `global` и `nonlocal`. `names` – это список сырых строк.19561957```pycon1958>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))1959Module(1960 body=[1961 Global(1962 names=[1963 'x',1964 'y',1965 'z'])])19661967>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))1968Module(1969 body=[1970 Nonlocal(1971 names=[1972 'x',1973 'y',1974 'z'])])1975```19761977#### `class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)`19781979Определение класса.19801981- `name` – это сырая строка с именем класса.1982- `bases` – это список узлов для явно указанных базовых классов.1983- `keywords` – это список узлов [`keyword`](https://python-all.ru/3.16/library/ast.html#ast.keyword), в первую очередь для ‘metaclass’. Остальные ключевые слова будут переданы метаклассу, в соответствии с [**PEP 3115**](https://python-all.ru/3.16/library/ast.html).1984- `body` – это список узлов, представляющих код внутри определения класса.1985- `decorator_list` – это список узлов, как и в [`FunctionDef`](https://python-all.ru/3.16/library/ast.html#ast.FunctionDef).1986- `type_params` – это список [параметров типа](https://python-all.ru/3.16/library/ast.html#ast-type-params).19871988```pycon1989>>> print(ast.dump(ast.parse("""\1990... @decorator11991... @decorator21992... class Foo(base1, base2, metaclass=meta):1993... pass1994... """), indent=4))1995Module(1996 body=[1997 ClassDef(1998 name='Foo',1999 bases=[2000 Name(id='base1'),2001 Name(id='base2')],2002 keywords=[2003 keyword(2004 arg='metaclass',2005 value=Name(id='meta'))],2006 body=[2007 Pass()],2008 decorator_list=[2009 Name(id='decorator1'),2010 Name(id='decorator2')])])2011```20122013Изменено в версии 3.12: Добавлен `type_params`.20142015### async и await20162017#### `class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)`20182019Определение функции `async def`. Имеет те же поля, что и [`FunctionDef`](https://python-all.ru/3.16/library/ast.html#ast.FunctionDef).20202021Изменено в версии 3.12: Добавлен `type_params`.20222023#### `class ast.Await(value)`20242025Выражение `await`. `value` – это то, чего оно ожидает. Допустимо только в теле [`AsyncFunctionDef`](https://python-all.ru/3.16/library/ast.html#ast.AsyncFunctionDef).20262027```pycon2028>>> print(ast.dump(ast.parse("""\2029... async def f():2030... await other_func()2031... """), indent=4))2032Module(2033 body=[2034 AsyncFunctionDef(2035 name='f',2036 args=arguments(),2037 body=[2038 Expr(2039 value=Await(2040 value=Call(2041 func=Name(id='other_func'))))])])2042```20432044#### `class ast.AsyncFor(target, iter, body, orelse, type_comment)`20452046#### `class ast.AsyncWith(items, body, type_comment)`20472048`async for` циклы и `async with` менеджеры контекста. Они имеют те же поля, что [`For`](https://python-all.ru/3.16/library/ast.html#ast.For) и [`With`](https://python-all.ru/3.16/library/ast.html#ast.With), соответственно. Допустимы только в теле [`AsyncFunctionDef`](https://python-all.ru/3.16/library/ast.html#ast.AsyncFunctionDef).20492050> **Примечание**2051>2052> Когда строка разбирается с помощью [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse), узлы операторов (подклассы `ast.operator`, `ast.unaryop`, `ast.cmpop`, `ast.boolop` и `ast.expr_context`) на возвращаемом дереве будут синглтонами. Изменения в одном отразятся во всех других вхождениях того же значения (например, [`ast.Add`](https://python-all.ru/3.16/library/ast.html#ast.Add)).20532054## `ast` вспомогательные функции20552056Помимо классов узлов, модуль `ast` определяет следующие служебные функции и классы для обхода абстрактных синтаксических деревьев:20572058#### `ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None, optimize=-1, module=None)`20592060Разбирает исходный код в узел AST. Эквивалентно `compile(source, filename, mode, flags=FLAGS_VALUE, optimize=optimize, module=module)`, где `FLAGS_VALUE` равно `ast.PyCF_ONLY_AST`, если `optimize <= 0`, и `ast.PyCF_OPTIMIZED_AST` в противном случае.20612062Если задан `type_comments=True`, парсер изменяется, чтобы проверять и возвращать комментарии типов, как указано в [**PEP 484**](https://python-all.ru/3.16/library/ast.html) и [**PEP 526**](https://python-all.ru/3.16/library/ast.html). Это эквивалентно добавлению [`ast.PyCF_TYPE_COMMENTS`](https://python-all.ru/3.16/library/ast.html#ast.PyCF_TYPE_COMMENTS) к флагам, передаваемым в [`compile()`](https://python-all.ru/3.16/library/functions.html#compile). Это приведёт к сообщению об ошибках синтаксиса для неправильно расположенных комментариев типов. Без этого флага комментарии типов будут игнорироваться, и поле `type_comment` в выбранных узлах AST всегда будет `None`. Кроме того, расположение комментариев `# type: ignore` будет возвращаться как атрибут `type_ignores` объекта [`Module`](https://python-all.ru/3.16/library/ast.html#ast.Module) (иначе это всегда пустой список).20632064Кроме того, если `mode` равно `'func_type'`, синтаксис входных данных изменяется в соответствии с [**PEP 484**](https://python-all.ru/3.16/library/ast.html) «сигнатурными комментариями типов», например `(str, int) -> List[str]`.20652066Установка `feature_version` в кортеж `(major, minor)` приведёт к «наилучшей попытке» разбора с использованием грамматики этой версии Python. Например, установка `feature_version=(3, 9)` будет пытаться запретить разбор инструкций [`match`](https://python-all.ru/3.16/reference/compound_stmts.html#match). В настоящее время `major` должно быть равно `3`. Самая низкая поддерживаемая версия – `(3, 7)` (и это может увеличиться в будущих версиях Python); самая высокая – `sys.version_info[0:2]`. «Наилучшая попытка» означает, что нет гарантии, что разбор (или успех разбора) будет таким же, как при запуске на версии Python, соответствующей `feature_version`.20672068Если исходный код содержит нулевой символ (`\0`), возбуждается [`ValueError`](https://python-all.ru/3.16/library/exceptions.html#ValueError).20692070> **Предупреждение**2071>2072> Обратите внимание, что успешный разбор исходного кода в объект AST не гарантирует, что предоставленный исходный код является корректным кодом Python, который можно выполнить, поскольку этап компиляции может вызывать дополнительные исключения [`SyntaxError`](https://python-all.ru/3.16/library/exceptions.html#SyntaxError). Например, исходный код `return 42` генерирует корректный узел AST для инструкции return, но его нельзя скомпилировать отдельно (он должен находиться внутри узла функции).2073>2074> В частности, `ast.parse()` не выполняет никаких проверок областей видимости, которые выполняет этап компиляции.20752076> **Предупреждение**2077>2078> Можно вызвать сбой интерпретатора Python с помощью достаточно большой/сложной строки из-за ограничений глубины стека в компиляторе AST Python.20792080Изменено в версии 3.8: Добавлены `type_comments`, `mode='func_type'` и `feature_version`.20812082Изменено в версии 3.13: Минимальная поддерживаемая версия для `feature_version` теперь `(3, 7)`. Был добавлен аргумент `optimize`.20832084Добавлено в версии 3.15: Добавлен параметр *module*.20852086#### `ast.unparse(ast_obj)`20872088Выполняет обратный разбор объекта [`ast.AST`](https://python-all.ru/3.16/library/ast.html#ast.AST) и генерирует строку с кодом, который при обратном разборе с помощью [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse) даст эквивалентный объект `ast.AST`.20892090> **Предупреждение**2091>2092> Полученная строка кода не обязательно будет равна исходному коду, который породил объект [`ast.AST`](https://python-all.ru/3.16/library/ast.html#ast.AST) (без каких-либо оптимизаций компилятора, таких как константные кортежи/frozensets).20932094> **Предупреждение**2095>2096> Попытка выполнить обратный разбор очень сложного выражения приведёт к [`RecursionError`](https://python-all.ru/3.16/library/exceptions.html#RecursionError).20972098Добавлено в версии 3.9.20992100#### `ast.literal_eval(node_or_string)`21012102Вычисляет узел выражения или строку, содержащую только литерал Python или отображение контейнера. Предоставленная строка или узел могут состоять только из следующих структур литералов Python: строки, байты, числа, кортежи, списки, словари, множества, булевы значения, `None` и `Ellipsis`.21032104Это можно использовать для вычисления строк, содержащих значения Python, без необходимости разбирать значения самостоятельно. Он не способен вычислять произвольно сложные выражения, например, с операторами или индексацией.21052106Раньше эта функция документировалась как «безопасная» без определения, что это значит. Это вводило в заблуждение. Она специально разработана так, чтобы не выполнять код Python, в отличие от более общей [`eval()`](https://python-all.ru/3.16/library/functions.html#eval). Нет пространства имён, поиска имён или возможности внешних вызовов. Но она не свободна от атак: относительно небольшой ввод может привести к истощению памяти или истощению стека C, что вызовет сбой процесса. Также существует возможность отказа в обслуживании из-за чрезмерного потребления ЦП на некоторых входных данных. Поэтому вызывать её на недоверенных данных не рекомендуется.21072108> **Предупреждение**2109>2110> Можно вызвать сбой интерпретатора Python из-за ограничений глубины стека в компиляторе AST Python.2111>2112> Она может возбуждать [`ValueError`](https://python-all.ru/3.16/library/exceptions.html#ValueError), [`TypeError`](https://python-all.ru/3.16/library/exceptions.html#TypeError), [`SyntaxError`](https://python-all.ru/3.16/library/exceptions.html#SyntaxError), [`MemoryError`](https://python-all.ru/3.16/library/exceptions.html#MemoryError) и [`RecursionError`](https://python-all.ru/3.16/library/exceptions.html#RecursionError) в зависимости от некорректного ввода.21132114Изменено в версии 3.2: Теперь допускает литералы байтов и множеств.21152116Изменено в версии 3.9: Теперь поддерживает создание пустых множеств с помощью `'set()'`.21172118Изменено в версии 3.10: Для строковых входных данных начальные пробелы и табуляции теперь удаляются.21192120#### `ast.get_docstring(node, clean=True)`21212122Возвращает строку документации для данного *узла* (который должен быть узлом [`FunctionDef`](https://python-all.ru/3.16/library/ast.html#ast.FunctionDef), [`AsyncFunctionDef`](https://python-all.ru/3.16/library/ast.html#ast.AsyncFunctionDef), [`ClassDef`](https://python-all.ru/3.16/library/ast.html#ast.ClassDef) или [`Module`](https://python-all.ru/3.16/library/ast.html#ast.Module)) или `None`, если у него нет строки документации. Если *clean* истинно, очищает отступы строки документации с помощью [`inspect.cleandoc()`](https://python-all.ru/3.16/library/inspect.html#inspect.cleandoc).21232124Изменено в версии 3.5: Теперь поддерживается [`AsyncFunctionDef`](https://python-all.ru/3.16/library/ast.html#ast.AsyncFunctionDef).21252126#### `ast.get_source_segment(source, node, *, padded=False)`21272128Возвращает фрагмент исходного кода из *source*, который породил узел *node*. Если не хватает информации о местоположении ([`lineno`](https://python-all.ru/3.16/library/ast.html#ast.AST.lineno), [`end_lineno`](https://python-all.ru/3.16/library/ast.html#ast.AST.end_lineno), [`col_offset`](https://python-all.ru/3.16/library/ast.html#ast.AST.col_offset) или [`end_col_offset`](https://python-all.ru/3.16/library/ast.html#ast.AST.end_col_offset)), возвращает `None`.21292130Если *padded* равно `True`, первая строка многострочного оператора будет дополнена пробелами, чтобы соответствовать исходной позиции.21312132Добавлено в версии 3.8.21332134#### `ast.fix_missing_locations(node)`21352136При компиляции дерева узлов с помощью [`compile()`](https://python-all.ru/3.16/library/functions.html#compile) компилятор ожидает атрибуты [`lineno`](https://python-all.ru/3.16/library/ast.html#ast.AST.lineno) и [`col_offset`](https://python-all.ru/3.16/library/ast.html#ast.AST.col_offset) для каждого узла, который их поддерживает. Заполнять их вручную для сгенерированных узлов довольно утомительно, поэтому эта вспомогательная функция рекурсивно добавляет эти атрибуты, если их ещё нет, устанавливая их равными значениям родительского узла. Работает рекурсивно, начиная с *node*.21372138#### `ast.increment_lineno(node, n=1)`21392140Увеличивает номер строки и номер конечной строки каждого узла в дереве, начиная с *node*, на *n*. Это полезно для «перемещения кода» в другое место в файле.21412142#### `ast.copy_location(new_node, old_node)`21432144Копирует информацию о местоположении в исходном коде ([`lineno`](https://python-all.ru/3.16/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.16/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.16/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.16/library/ast.html#ast.AST.end_col_offset)) из *old\_node* в *new\_node*, если это возможно, и возвращает *new\_node*.21452146#### `ast.iter_fields(node)`21472148Генерирует кортеж из `(fieldname, value)` для каждого поля в `node._fields`, которое присутствует в *node*.21492150#### `ast.iter_child_nodes(node)`21512152Генерирует все непосредственные дочерние узлы *node*, то есть все поля, являющиеся узлами, и все элементы полей, являющихся списками узлов.21532154#### `ast.walk(node)`21552156Рекурсивно генерирует все узлы-потомки в дереве, начиная с *node* (включая сам *node*), в произвольном порядке. Это полезно, если требуется только изменить узлы на месте, а контекст не важен.21572158#### `class ast.NodeVisitor`21592160Базовый класс для обхода узлов, который обходит абстрактное синтаксическое дерево и вызывает функцию-посетитель для каждого найденного узла. Эта функция может вернуть значение, которое передаётся методом [`visit()`](https://python-all.ru/3.16/library/ast.html#ast.NodeVisitor.visit).21612162Этот класс предназначен для наследования; в подклассе добавляются методы-посетители.21632164#### `visit(node)`21652166Посещает узел. Реализация по умолчанию вызывает метод `self.visit_classname`, где *classname* – имя класса узла, или [`generic_visit()`](https://python-all.ru/3.16/library/ast.html#ast.NodeVisitor.generic_visit), если такой метод отсутствует.21672168#### `generic_visit(node)`21692170Этот посетитель вызывает [`visit()`](https://python-all.ru/3.16/library/ast.html#ast.NodeVisitor.visit) для всех дочерних узлов.21712172Обратите внимание, что дочерние узлы тех узлов, для которых определён собственный метод-посетитель, не будут посещены, если посетитель сам не вызовет `generic_visit()` или не обойдёт их самостоятельно.21732174#### `visit_Constant(node)`21752176Обрабатывает все константные узлы.21772178Не используйте `NodeVisitor`, если требуется вносить изменения в узлы во время обхода. Для этого существует специальный посетитель ([`NodeTransformer`](https://python-all.ru/3.16/library/ast.html#ast.NodeTransformer)), который допускает модификации.21792180Устарело с версии 3.8, удалено в версии 3.14: Методы `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` и `visit_Ellipsis()` не будут вызываться в Python 3.14+. Вместо них добавьте метод [`visit_Constant()`](https://python-all.ru/3.16/library/ast.html#ast.NodeVisitor.visit_Constant) для обработки всех константных узлов.21812182#### `class ast.NodeTransformer`21832184Подкласс [`NodeVisitor`](https://python-all.ru/3.16/library/ast.html#ast.NodeVisitor), который обходит абстрактное синтаксическое дерево и позволяет изменять узлы.21852186Метод `NodeTransformer` обходит AST и использует возвращаемое значение методов-посетителей для замены или удаления старого узла. Если возвращаемое значение метода-посетителя равно `None`, узел будет удалён из своего местоположения; в противном случае он заменяется возвращённым значением. Возвращённое значение может быть исходным узлом – в этом случае замена не происходит.21872188Вот пример преобразователя, который переписывает все обращения к именам (`foo`) в `data['foo']`:21892190```python2191class RewriteName(NodeTransformer):21922193 def visit_Name(self, node):2194 return Subscript(2195 value=Name(id='data'),2196 slice=Constant(value=node.id),2197 ctx=node.ctx2198 )2199```22002201Имейте в виду: если у узла, с которым вы работаете, есть дочерние узлы, необходимо либо преобразовать дочерние узлы самостоятельно, либо сначала вызвать для узла метод [`generic_visit()`](https://python-all.ru/3.16/library/ast.html#ast.NodeVisitor.generic_visit).22022203Для узлов, входящих в состав набора инструкций (это относится ко всем узлам инструкций), посетитель может также возвращать список узлов, а не один узел.22042205Если `NodeTransformer` вводит новые узлы (не входившие в исходное дерево) без указания информации о расположении (например, [`lineno`](https://python-all.ru/3.16/library/ast.html#ast.AST.lineno)), следует вызвать [`fix_missing_locations()`](https://python-all.ru/3.16/library/ast.html#ast.fix_missing_locations) для нового поддерева, чтобы пересчитать информацию о расположении:22062207```python2208tree = ast.parse('foo', mode='eval')2209new_tree = fix_missing_locations(RewriteName().visit(tree))2210```22112212Обычно преобразователь используется следующим образом:22132214```python2215node = YourTransformer().visit(node)2216```22172218#### `ast.dump(node, annotate_fields=True, include_attributes=False, *, color=False, indent=None, show_empty=False)`22192220Возвращает форматированный дамп дерева из *node*. Это в основном полезно для отладки. Если *annotate\_fields* равно true (по умолчанию), возвращаемая строка будет показывать имена и значения полей. Если *annotate\_fields* равно false, результирующая строка будет более компактной за счёт опускания однозначных имён полей. Атрибуты, такие как номера строк и смещения столбцов, по умолчанию не выводятся. Если это нужно, *include\_attributes* можно установить в true.22212222Если *color* равно `True`, возвращаемая строка подсвечивается с помощью escape-последовательностей ANSI. Если `False` (по умолчанию), цветной вывод всегда отключён.22232224Если *indent* – неотрицательное целое число или строка, дерево будет выведено с отступами указанного уровня. Уровень отступа 0, отрицательное значение или `""` вставляет только переводы строк. `None` (по умолчанию) выбирает однострочное представление. Положительный целочисленный отступ добавляет соответствующее количество пробелов на уровень. Если *indent* – строка (например, `"\t"`), эта строка используется для отступа каждого уровня.22252226Если *show\_empty* равно false (по умолчанию), необязательные пустые списки и значения `Load()` будут опущены в выводе. Необязательные значения `None` всегда опускаются.22272228```pycon2229>>> tree = ast.parse('print(None)', '?', 'eval')2230>>> print(ast.dump(tree, indent=4))2231Expression(2232 body=Call(2233 func=Name(id='print'),2234 args=[2235 Constant(value=None)]))2236>>> print(ast.dump(tree, indent=4, show_empty=True))2237Expression(2238 body=Call(2239 func=Name(id='print', ctx=Load()),2240 args=[2241 Constant(value=None)],2242 keywords=[]))2243```22442245Изменено в версии 3.9: Добавлена опция *indent*.22462247Изменено в версии 3.13: Добавлена опция *show\_empty*.22482249Изменено в версии 3.15: Необязательные значения `Load()` по умолчанию опускаются.22502251Изменено в версии 3.15: Добавлен параметр *color*.22522253#### `ast.compare(a, b, /, *, compare_attributes=False)`22542255Рекурсивно сравнивает два AST.22562257*compare\_attributes* влияет на то, учитываются ли атрибуты AST при сравнении. Если *compare\_attributes* равно `False` (по умолчанию), атрибуты игнорируются. В противном случае они все должны быть равны. Эта опция полезна для проверки структурного равенства AST при различиях в пробелах или подобных деталях. Атрибуты включают номера строк и смещения столбцов.22582259Добавлено в версии 3.14.22602261## Флаги компилятора22622263Следующие флаги могут быть переданы в [`compile()`](https://python-all.ru/3.16/library/functions.html#compile) для изменения эффектов компиляции программы:22642265#### `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`22662267Включает поддержку `await`, `async for`, `async with` и асинхронных включений верхнего уровня.22682269Добавлено в версии 3.8.22702271#### `ast.PyCF_ONLY_AST`22722273Генерирует и возвращает абстрактное синтаксическое дерево вместо скомпилированного объекта кода.22742275#### `ast.PyCF_OPTIMIZED_AST`22762277Возвращаемое AST оптимизируется в соответствии с аргументом *optimize* в [`compile()`](https://python-all.ru/3.16/library/functions.html#compile) или [`ast.parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse).22782279Добавлено в версии 3.13.22802281#### `ast.PyCF_TYPE_COMMENTS`22822283Включает поддержку комментариев типов в стиле [**PEP 484**](https://python-all.ru/3.16/library/ast.html) и [**PEP 526**](https://python-all.ru/3.16/library/ast.html) (`# type: <type>`, `# type: ignore <stuff>`).22842285Добавлено в версии 3.8.22862287## Использование командной строки22882289Добавлено в версии 3.9.22902291Изменено в версии 3.15: Вывод теперь по умолчанию подсвечивается синтаксис. Это можно [контролировать с помощью переменных окружения](https://python-all.ru/3.16/using/cmdline.html#using-on-controlling-color).22922293Модуль `ast` может быть выполнен как скрипт из командной строки. Это просто:22942295```sh2296python -m ast [-m <mode>] [-a] [infile]2297```22982299Принимаются следующие опции:23002301#### `-h, --help`23022303Показать справку и выйти.23042305#### `-m <mode>`23062307#### `--mode <mode>`23082309Определяет, какой вид кода должен быть скомпилирован, как аргумент *mode* в [`parse()`](https://python-all.ru/3.16/library/ast.html#ast.parse).23102311#### `--no-type-comments`23122313Не обрабатывать комментарии типов.23142315#### `-a, --include-attributes`23162317Включать атрибуты, такие как номера строк и смещения столбцов.23182319#### `-i <indent>`23202321#### `--indent <indent>`23222323Отступ узлов в AST (количество пробелов).23242325#### `--feature-version <version>`23262327Версия Python в формате 3.x (например, 3.10). По умолчанию используется текущая версия интерпретатора.23282329Добавлено в версии 3.14.23302331#### `-O <level>`23322333#### `--optimize <level>`23342335Уровень оптимизации для парсера. По умолчанию оптимизация отключена.23362337Добавлено в версии 3.14.23382339#### `--show-empty`23402341Показывать пустые списки и поля, которые равны `None`. По умолчанию пустые объекты не показываются.23422343Добавлено в версии 3.14.23442345Если указан `infile`, его содержимое разбирается в AST и выводится в stdout. В противном случае содержимое читается из stdin.23462347> **См. также**2348>2349> [Green Tree Snakes](https://python-all.ru/3.16/library/ast.html) – внешний документационный ресурс, содержащий подробности работы с AST Python.2350>2351> [ASTTokens](https://python-all.ru/3.16/library/ast.html) дополняет AST Python позициями токенов и текста в исходном коде, который их породил. Это полезно для инструментов, выполняющих преобразования исходного кода.2352>2353> [leoAst.py](https://python-all.ru/3.16/library/ast.html) объединяет токен-ориентированное и синтаксическое представление программ Python, вставляя двунаправленные связи между токенами и узлами AST.2354>2355> [LibCST](https://python-all.ru/3.16/library/ast.html) разбирает код как конкретное синтаксическое дерево, похожее на AST, и сохраняет все детали форматирования. Это полезно для создания приложений автоматического рефакторинга (codemod) и линтеров.2356>2357> [Parso](https://python-all.ru/3.16/library/ast.html) – это парсер Python, поддерживающий восстановление после ошибок и сквозной разбор для разных версий Python (в нескольких версиях Python). Parso также может выводить несколько синтаксических ошибок в вашем файле Python.2358