ast.md
1> **Источник:** https://python-all.ru/3.9/library/ast.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# [`ast`](https://python-all.ru/3.9/library/ast.html#module-ast) – абстрактные синтаксические деревья89**Исходный код:** [Lib/ast.py](https://python-all.ru/src/3.9/Lib/ast.py)1011---1213Модуль [`ast`](https://python-all.ru/3.9/library/ast.html#module-ast) помогает приложениям Python обрабатывать деревья абстрактного синтаксиса языка Python. Абстрактный синтаксис может меняться от версии к версии; с помощью этого модуля можно программно узнать, как выглядит текущая грамматика.1415Абстрактное синтаксическое дерево можно создать, передав [`ast.PyCF_ONLY_AST`](https://python-all.ru/3.9/library/ast.html#ast.PyCF_ONLY_AST) в качестве флага встроенной функции [`compile()`](https://python-all.ru/3.9/library/functions.html#compile) или используя вспомогательную функцию [`parse()`](https://python-all.ru/3.9/library/ast.html#ast.parse) из этого модуля. Результатом будет дерево объектов, классы которых наследуют от [`ast.AST`](https://python-all.ru/3.9/library/ast.html#ast.AST). Абстрактное синтаксическое дерево можно скомпилировать в объект кода Python с помощью встроенной функции [`compile()`](https://python-all.ru/3.9/library/functions.html#compile).1617## Абстрактная грамматика1819Абстрактная грамматика в настоящее время определяется следующим образом:2021```asdl22-- Встроенные типы ASDL:23-- идентификатор, целое, строка, константа2425module Python26{27 mod = Module(stmt* body, type_ignore* type_ignores)28 | Interactive(stmt* body)29 | Expression(expr body)30 | FunctionType(expr* argtypes, expr returns)3132 stmt = FunctionDef(identifier name, arguments args,33 stmt* body, expr* decorator_list, expr? returns,34 string? type_comment)35 | AsyncFunctionDef(identifier name, arguments args,36 stmt* body, expr* decorator_list, expr? returns,37 string? type_comment)3839 | ClassDef(identifier name,40 expr* bases,41 keyword* keywords,42 stmt* body,43 expr* decorator_list)44 | Return(expr? value)4546 | Delete(expr* targets)47 | Assign(expr* targets, expr value, string? type_comment)48 | AugAssign(expr target, operator op, expr value)49 -- 'simple' указывает, что аннотируется простое имя без скобок50 | AnnAssign(expr target, expr annotation, expr? value, int simple)5152 -- используется 'orelse', так как else – ключевое слово в целевых языках53 | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)54 | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)55 | While(expr test, stmt* body, stmt* orelse)56 | If(expr test, stmt* body, stmt* orelse)57 | With(withitem* items, stmt* body, string? type_comment)58 | AsyncWith(withitem* items, stmt* body, string? type_comment)5960 | Raise(expr? exc, expr? cause)61 | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)62 | Assert(expr test, expr? msg)6364 | Import(alias* names)65 | ImportFrom(identifier? module, alias* names, int? level)6667 | Global(identifier* names)68 | Nonlocal(identifier* names)69 | Expr(expr value)70 | Pass | Break | Continue7172 -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером73 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)7475 -- BoolOp() может использовать left и right?76 expr = BoolOp(boolop op, expr* values)77 | NamedExpr(expr target, expr value)78 | BinOp(expr left, operator op, expr right)79 | UnaryOp(unaryop op, expr operand)80 | Lambda(arguments args, expr body)81 | IfExp(expr test, expr body, expr orelse)82 | Dict(expr* keys, expr* values)83 | Set(expr* elts)84 | ListComp(expr elt, comprehension* generators)85 | SetComp(expr elt, comprehension* generators)86 | DictComp(expr key, expr value, comprehension* generators)87 | GeneratorExp(expr elt, comprehension* generators)88 -- грамматика ограничивает, где могут встречаться выражения yield89 | Await(expr value)90 | Yield(expr? value)91 | YieldFrom(expr value)92 -- нужны последовательности для сравнения, чтобы различать93 -- x < 4 < 3 and (x < 4) < 394 | Compare(expr left, cmpop* ops, expr* comparators)95 | Call(expr func, expr* args, keyword* keywords)96 | FormattedValue(expr value, int? conversion, expr? format_spec)97 | JoinedStr(expr* values)98 | Constant(constant value, string? kind)99100 -- следующее выражение может появляться в контексте присваивания101 | Attribute(expr value, identifier attr, expr_context ctx)102 | Subscript(expr value, expr slice, expr_context ctx)103 | Starred(expr value, expr_context ctx)104 | Name(identifier id, expr_context ctx)105 | List(expr* elts, expr_context ctx)106 | Tuple(expr* elts, expr_context ctx)107108 -- может встречаться только в Subscript109 | Slice(expr? lower, expr? upper, expr? step)110111 -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером112 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)113114 expr_context = Load | Store | Del115116 boolop = And | Or117118 operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift119 | RShift | BitOr | BitXor | BitAnd | FloorDiv120121 unaryop = Invert | Not | UAdd | USub122123 cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn124125 comprehension = (expr target, expr iter, expr* ifs, int is_async)126127 excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)128 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)129130 arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,131 expr* kw_defaults, arg? kwarg, expr* defaults)132133 arg = (identifier arg, expr? annotation, string? type_comment)134 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)135136 -- ключевые аргументы, переданные вызову (идентификатор NULL для **kwargs)137 keyword = (identifier? arg, expr value)138 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)139140 -- имя импорта с необязательным псевдонимом 'as'141 alias = (identifier name, identifier? asname)142143 withitem = (expr context_expr, expr? optional_vars)144145 type_ignore = TypeIgnore(int lineno, string tag)146}147```148149## Классы узлов150151#### `class ast.AST`152153Это базовый класс всех узлов AST. Конкретные классы узлов порождаются из файла `Parser/Python.asdl`, который воспроизведён [ниже](https://python-all.ru/3.9/library/ast.html#abstract-grammar). Они определены в C-модуле `_ast` и реэкспортированы в [`ast`](https://python-all.ru/3.9/library/ast.html#module-ast).154155Для каждого символа левой части абстрактной грамматики определён один класс (например, `ast.stmt` или `ast.expr`). Кроме того, для каждого конструктора правой части определён один класс; эти классы наследуют от классов для деревьев левой части. Например, [`ast.BinOp`](https://python-all.ru/3.9/library/ast.html#ast.BinOp) наследует от `ast.expr`. Для продукционных правил с альтернативами (так называемых «сумм») класс левой части является абстрактным: создаются только экземпляры конкретных узлов-конструкторов.156157#### `_fields`158159Каждый конкретный класс имеет атрибут [`_fields`](https://python-all.ru/3.9/library/ast.html#ast.AST._fields), который содержит имена всех дочерних узлов.160161Каждый экземпляр конкретного класса имеет по одному атрибуту для каждого дочернего узла, тип которого определён в грамматике. Например, экземпляры [`ast.BinOp`](https://python-all.ru/3.9/library/ast.html#ast.BinOp) имеют атрибут `left` типа `ast.expr`.162163Если эти атрибуты помечены как необязательные в грамматике (с помощью вопросительного знака), значением может быть `None`. Если атрибуты могут иметь ноль или более значений (помечены звёздочкой), значения представляются в виде списков Python. Все возможные атрибуты должны присутствовать и иметь корректные значения при компиляции AST с помощью [`compile()`](https://python-all.ru/3.9/library/functions.html#compile).164165#### `lineno`166167#### `col_offset`168169#### `end_lineno`170171#### `end_col_offset`172173Экземпляры подклассов `ast.expr` и `ast.stmt` имеют атрибуты [`lineno`](https://python-all.ru/3.9/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.9/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.9/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.9/library/ast.html#ast.AST.end_col_offset). [`lineno`](https://python-all.ru/3.9/library/ast.html#ast.AST.lineno) и [`end_lineno`](https://python-all.ru/3.9/library/ast.html#ast.AST.end_lineno) – это номера первой и последней строк фрагмента исходного текста (нумерация с 1, то есть первая строка – строка 1), а [`col_offset`](https://python-all.ru/3.9/library/ast.html#ast.AST.col_offset) и [`end_col_offset`](https://python-all.ru/3.9/library/ast.html#ast.AST.end_col_offset) – соответствующие смещения в байтах UTF-8 для первого и последнего токенов, породивших узел. Смещение в UTF-8 записывается, потому что парсер использует UTF-8 внутри.174175Обратите внимание, что конечные позиции не требуются компилятором и поэтому являются необязательными. Смещение конца находится *после* последнего символа, например, можно получить фрагмент исходного кода узла выражения из одной строки с помощью `source_line[node.col_offset : node.end_col_offset]`.176177Конструктор класса `ast.T` разбирает свои аргументы следующим образом:178179- Если есть позиционные аргументы, их должно быть столько же, сколько элементов в `T._fields`; они будут присвоены как атрибуты с этими именами.180- Если есть ключевые аргументы, они установят атрибуты с теми же именами в указанные значения.181182Например, чтобы создать и заполнить узел [`ast.UnaryOp`](https://python-all.ru/3.9/library/ast.html#ast.UnaryOp), можно использовать183184```python185node = ast.UnaryOp()186node.op = ast.USub()187node.operand = ast.Constant()188node.operand.value = 5189node.operand.lineno = 0190node.operand.col_offset = 0191node.lineno = 0192node.col_offset = 0193```194195или более компактный196197```python198node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),199 lineno=0, col_offset=0)200```201202Изменено в версии 3.8: Класс [`ast.Constant`](https://python-all.ru/3.9/library/ast.html#ast.Constant) теперь используется для всех констант.203204Изменено в версии 3.9: Простые индексы представляются своим значением, расширенные срезы представляются кортежами.205206Устарело с версии 3.8: Старые классы `ast.Num`, `ast.Str`, `ast.Bytes`, `ast.NameConstant` и `ast.Ellipsis` всё ещё доступны, но будут удалены в будущих версиях Python. А пока их создание будет возвращать экземпляр другого класса.207208Устарело с версии 3.9: Старые классы `ast.Index` и `ast.ExtSlice` всё ещё доступны, но будут удалены в будущих выпусках Python. При этом при их создании будет возвращён экземпляр другого класса.209210> **Примечание**211>212> Описания конкретных классов узлов, приведённые здесь, изначально были адаптированы из замечательного проекта [Green Tree Snakes](https://python-all.ru/3.9/library/ast.html) и всех его участников.213214### Литералы215216#### `class ast.Constant(value)`217218Постоянное значение. Атрибут `value` литерала `Constant` содержит объект Python, который он представляет. Представленные значения могут быть простыми типами, такими как число, строка или `None`, а также неизменяемыми контейнерными типами (кортежами и замороженными множествами), если все их элементы постоянны.219220```pycon221>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))222Expression(223 body=Constant(value=123))224```225226#### `class ast.FormattedValue(value, conversion, format_spec)`227228Узел, представляющий одно поле форматирования в f-строке. Если строка содержит только одно поле форматирования и больше ничего, узел может быть изолированным; в противном случае он встречается внутри [`JoinedStr`](https://python-all.ru/3.9/library/ast.html#ast.JoinedStr).229230- `value` – это любой узел выражения (например, литерал, переменная или вызов функции).231- `conversion` – целое число:232233 - -1: без форматирования234 - 115: `!s` форматирование строк235 - 114: `!r` форматирование repr236 - 97: `!a` форматирование ascii237- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.9/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно.238239#### `class ast.JoinedStr(values)`240241F-строка, содержащая последовательность [`FormattedValue`](https://python-all.ru/3.9/library/ast.html#ast.FormattedValue) и [`Constant`](https://python-all.ru/3.9/library/ast.html#ast.Constant) узлов.242243```pycon244>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))245Expression(246 body=JoinedStr(247 values=[248 Constant(value='sin('),249 FormattedValue(250 value=Name(id='a', ctx=Load()),251 conversion=-1),252 Constant(value=') is '),253 FormattedValue(254 value=Call(255 func=Name(id='sin', ctx=Load()),256 args=[257 Name(id='a', ctx=Load())],258 keywords=[]),259 conversion=-1,260 format_spec=JoinedStr(261 values=[262 Constant(value='.3')]))]))263```264265#### `class ast.List(elts, ctx)`266267#### `class ast.Tuple(elts, ctx)`268269Список или кортеж. `elts` содержит список узлов, представляющих элементы. `ctx` равен [`Store`](https://python-all.ru/3.9/library/ast.html#ast.Store), если контейнер является целью присваивания (т.е. `(x,y)=something`), и [`Load`](https://python-all.ru/3.9/library/ast.html#ast.Load) в противном случае.270271```pycon272>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))273Expression(274 body=List(275 elts=[276 Constant(value=1),277 Constant(value=2),278 Constant(value=3)],279 ctx=Load()))280>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))281Expression(282 body=Tuple(283 elts=[284 Constant(value=1),285 Constant(value=2),286 Constant(value=3)],287 ctx=Load()))288```289290#### `class ast.Set(elts)`291292Множество. `elts` содержит список узлов, представляющих элементы множества.293294```pycon295>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))296Expression(297 body=Set(298 elts=[299 Constant(value=1),300 Constant(value=2),301 Constant(value=3)]))302```303304#### `class ast.Dict(keys, values)`305306Словарь. `keys` и `values` содержат списки узлов, представляющих ключи и значения соответственно, в соответствующем порядке (то, что было бы возвращено при вызове `dictionary.keys()` и `dictionary.values()`).307308При распаковке словаря с помощью литералов словаря выражение, которое нужно раскрыть, помещается в список `values`, а `None` – на соответствующую позицию в `keys`.309310```pycon311>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))312Expression(313 body=Dict(314 keys=[315 Constant(value='a'),316 None],317 values=[318 Constant(value=1),319 Name(id='d', ctx=Load())]))320```321322### Переменные323324#### `class ast.Name(id, ctx)`325326Имя переменной. `id` содержит имя в виде строки, а `ctx` – один из следующих типов.327328#### `class ast.Load`329330#### `class ast.Store`331332#### `class ast.Del`333334Ссылки на переменные можно использовать для загрузки значения переменной, для присваивания ей нового значения или для её удаления. Ссылки на переменные получают контекст, чтобы различать эти случаи.335336```pycon337>>> print(ast.dump(ast.parse('a'), indent=4))338Module(339 body=[340 Expr(341 value=Name(id='a', ctx=Load()))],342 type_ignores=[])343344>>> print(ast.dump(ast.parse('a = 1'), indent=4))345Module(346 body=[347 Assign(348 targets=[349 Name(id='a', ctx=Store())],350 value=Constant(value=1))],351 type_ignores=[])352353>>> print(ast.dump(ast.parse('del a'), indent=4))354Module(355 body=[356 Delete(357 targets=[358 Name(id='a', ctx=Del())])],359 type_ignores=[])360```361362#### `class ast.Starred(value, ctx)`363364Ссылка на переменную `*var`. В `value` хранится переменная, обычно узел [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name). Этот тип необходимо использовать при построении узла [`Call`](https://python-all.ru/3.9/library/ast.html#ast.Call) с помощью `*args`.365366```pycon367>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))368Module(369 body=[370 Assign(371 targets=[372 Tuple(373 elts=[374 Name(id='a', ctx=Store()),375 Starred(376 value=Name(id='b', ctx=Store()),377 ctx=Store())],378 ctx=Store())],379 value=Name(id='it', ctx=Load()))],380 type_ignores=[])381```382383### Выражения384385#### `class ast.Expr(value)`386387Когда выражение, например вызов функции, выступает в роли самостоятельного оператора и его возвращаемое значение не используется и не сохраняется, оно помещается в этот контейнер. `value` содержит один из остальных узлов этого раздела: узел [`Constant`](https://python-all.ru/3.9/library/ast.html#ast.Constant), узел [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name), [`Lambda`](https://python-all.ru/3.9/library/ast.html#ast.Lambda), [`Yield`](https://python-all.ru/3.9/library/ast.html#ast.Yield) или [`YieldFrom`](https://python-all.ru/3.9/library/ast.html#ast.YieldFrom).388389```pycon390>>> print(ast.dump(ast.parse('-a'), indent=4))391Module(392 body=[393 Expr(394 value=UnaryOp(395 op=USub(),396 operand=Name(id='a', ctx=Load())))],397 type_ignores=[])398```399400#### `class ast.UnaryOp(op, operand)`401402Унарная операция. `op` – оператор, а `operand` – любой узел выражения.403404#### `class ast.UAdd`405406#### `class ast.USub`407408#### `class ast.Not`409410#### `class ast.Invert`411412Токены унарных операторов. [`Not`](https://python-all.ru/3.9/library/ast.html#ast.Not) – ключевое слово `not`, [`Invert`](https://python-all.ru/3.9/library/ast.html#ast.Invert) – оператор `~`.413414```pycon415>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))416Expression(417 body=UnaryOp(418 op=Not(),419 operand=Name(id='x', ctx=Load())))420```421422#### `class ast.BinOp(left, op, right)`423424Бинарная операция (например, сложение или деление). `op` – оператор, а `left` и `right` – любые узлы выражений.425426```pycon427>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))428Expression(429 body=BinOp(430 left=Name(id='x', ctx=Load()),431 op=Add(),432 right=Name(id='y', ctx=Load())))433```434435#### `class ast.Add`436437#### `class ast.Sub`438439#### `class ast.Mult`440441#### `class ast.Div`442443#### `class ast.FloorDiv`444445#### `class ast.Mod`446447#### `class ast.Pow`448449#### `class ast.LShift`450451#### `class ast.RShift`452453#### `class ast.BitOr`454455#### `class ast.BitXor`456457#### `class ast.BitAnd`458459#### `class ast.MatMult`460461Токены бинарных операторов.462463#### `class ast.BoolOp(op, values)`464465Логическая операция – 'or' или 'and'. `op` – это [`Or`](https://python-all.ru/3.9/library/ast.html#ast.Or) или [`And`](https://python-all.ru/3.9/library/ast.html#ast.And). `values` – участвующие значения. Последовательные операции с одним и тем же оператором, например `a or b or c`, сводятся в один узел с несколькими значениями.466467Это не включает `not`, который является [`UnaryOp`](https://python-all.ru/3.9/library/ast.html#ast.UnaryOp).468469```pycon470>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))471Expression(472 body=BoolOp(473 op=Or(),474 values=[475 Name(id='x', ctx=Load()),476 Name(id='y', ctx=Load())]))477```478479#### `class ast.And`480481#### `class ast.Or`482483Токены логических операторов.484485#### `class ast.Compare(left, ops, comparators)`486487Сравнение двух или более значений. `left` – первое значение в сравнении, `ops` – список операторов, а `comparators` – список значений после первого элемента сравнения.488489```pycon490>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))491Expression(492 body=Compare(493 left=Constant(value=1),494 ops=[495 LtE(),496 Lt()],497 comparators=[498 Name(id='a', ctx=Load()),499 Constant(value=10)]))500```501502#### `class ast.Eq`503504#### `class ast.NotEq`505506#### `class ast.Lt`507508#### `class ast.LtE`509510#### `class ast.Gt`511512#### `class ast.GtE`513514#### `class ast.Is`515516#### `class ast.IsNot`517518#### `class ast.In`519520#### `class ast.NotIn`521522Токены операторов сравнения.523524#### `class ast.Call(func, args, keywords, starargs, kwargs)`525526Вызов функции. `func` – это функция; обычно это объект [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name) или [`Attribute`](https://python-all.ru/3.9/library/ast.html#ast.Attribute). Об аргументах:527528- `args` содержит список аргументов, переданных по позиции.529- `keywords` содержит список объектов [`keyword`](https://python-all.ru/3.9/library/keyword.html#module-keyword), представляющих аргументы, переданные по ключевому слову.530531При создании узла `Call`, `args` и `keywords` обязательны, но они могут быть пустыми списками. `starargs` и `kwargs` необязательны.532533```pycon534>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))535Expression(536 body=Call(537 func=Name(id='func', ctx=Load()),538 args=[539 Name(id='a', ctx=Load()),540 Starred(541 value=Name(id='d', ctx=Load()),542 ctx=Load())],543 keywords=[544 keyword(545 arg='b',546 value=Name(id='c', ctx=Load())),547 keyword(548 value=Name(id='e', ctx=Load()))]))549```550551#### `class ast.keyword(arg, value)`552553Именованный аргумент вызова функции или определения класса. `arg` – это необработанная строка с именем параметра, `value` – узел, который нужно передать.554555#### `class ast.IfExp(test, body, orelse)`556557Выражение, например `a if b else c`. Каждое поле содержит один узел, поэтому в следующем примере все три являются узлами [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name).558559```pycon560>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))561Expression(562 body=IfExp(563 test=Name(id='b', ctx=Load()),564 body=Name(id='a', ctx=Load()),565 orelse=Name(id='c', ctx=Load())))566```567568#### `class ast.Attribute(value, attr, ctx)`569570Доступ к атрибуту, например `d.keys`. `value` – это узел, обычно [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name). `attr` – это строка с именем атрибута, а `ctx` – [`Load`](https://python-all.ru/3.9/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.9/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.9/library/ast.html#ast.Del) в зависимости от того, как используется атрибут.571572```pycon573>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))574Expression(575 body=Attribute(576 value=Name(id='snake', ctx=Load()),577 attr='colour',578 ctx=Load()))579```580581#### `class ast.NamedExpr(target, value)`582583> Именованное выражение. Этот узел AST создаётся оператором присваивания (также известным как оператор «морж»). В отличие от узла [`Assign`](https://python-all.ru/3.9/library/ast.html#ast.Assign), где первый аргумент может быть несколькими узлами, в данном случае и `target`, и `value` должны быть одиночными узлами.584585```pycon586>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))587Expression(588 body=NamedExpr(589 target=Name(id='x', ctx=Store()),590 value=Constant(value=4)))591```592593#### Индексирование594595#### `class ast.Subscript(value, slice, ctx)`596597Индексация, такая как `l[1]`. `value` – индексируемый объект (обычно последовательность или отображение). `slice` – это индекс, срез или ключ. Оно может быть [`Tuple`](https://python-all.ru/3.9/library/ast.html#ast.Tuple) и содержать [`Slice`](https://python-all.ru/3.9/library/ast.html#ast.Slice). `ctx` является [`Load`](https://python-all.ru/3.9/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.9/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.9/library/ast.html#ast.Del) в зависимости от выполняемого действия при индексации.598599```pycon600>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))601Expression(602 body=Subscript(603 value=Name(id='l', ctx=Load()),604 slice=Tuple(605 elts=[606 Slice(607 lower=Constant(value=1),608 upper=Constant(value=2)),609 Constant(value=3)],610 ctx=Load()),611 ctx=Load()))612```613614#### `class ast.Slice(lower, upper, step)`615616Обычный срез (в виде `lower:upper` или `lower:upper:step`). Может встречаться только внутри поля *slice* узла [`Subscript`](https://python-all.ru/3.9/library/ast.html#ast.Subscript), либо напрямую, либо как элемент [`Tuple`](https://python-all.ru/3.9/library/ast.html#ast.Tuple).617618```pycon619>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))620Expression(621 body=Subscript(622 value=Name(id='l', ctx=Load()),623 slice=Slice(624 lower=Constant(value=1),625 upper=Constant(value=2)),626 ctx=Load()))627```628629#### Генераторы коллекций630631#### `class ast.ListComp(elt, generators)`632633#### `class ast.SetComp(elt, generators)`634635#### `class ast.GeneratorExp(elt, generators)`636637#### `class ast.DictComp(key, value, generators)`638639Генераторы списков и множеств, генераторные выражения и генераторы словарей. `elt` (или `key` и `value`) – это один узел, представляющий часть, которая будет вычисляться для каждого элемента.640641`generators` – это список узлов [`comprehension`](https://python-all.ru/3.9/library/ast.html#ast.comprehension).642643```pycon644>>> print(ast.dump(ast.parse('[x for x in numbers]', mode='eval'), indent=4))645Expression(646 body=ListComp(647 elt=Name(id='x', ctx=Load()),648 generators=[649 comprehension(650 target=Name(id='x', ctx=Store()),651 iter=Name(id='numbers', ctx=Load()),652 ifs=[],653 is_async=0)]))654>>> print(ast.dump(ast.parse('{x: x**2 for x in numbers}', mode='eval'), indent=4))655Expression(656 body=DictComp(657 key=Name(id='x', ctx=Load()),658 value=BinOp(659 left=Name(id='x', ctx=Load()),660 op=Pow(),661 right=Constant(value=2)),662 generators=[663 comprehension(664 target=Name(id='x', ctx=Store()),665 iter=Name(id='numbers', ctx=Load()),666 ifs=[],667 is_async=0)]))668>>> print(ast.dump(ast.parse('{x for x in numbers}', mode='eval'), indent=4))669Expression(670 body=SetComp(671 elt=Name(id='x', ctx=Load()),672 generators=[673 comprehension(674 target=Name(id='x', ctx=Store()),675 iter=Name(id='numbers', ctx=Load()),676 ifs=[],677 is_async=0)]))678```679680#### `class ast.comprehension(target, iter, ifs, is_async)`681682Одно предложение `for` в генераторе коллекции. `target` – это ссылка, используемая для каждого элемента (обычно узел [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name) или [`Tuple`](https://python-all.ru/3.9/library/ast.html#ast.Tuple)). `iter` – объект, по которому выполняется итерация. `ifs` – список проверочных выражений: каждое предложение `for` может содержать несколько `ifs`.683684`is_async` указывает, что генератор коллекции является асинхронным (использует `async for` вместо `for`). Значение – целое число (0 или 1).685686```pycon687>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),688... indent=4)) # несколько включений в одном689Expression(690 body=ListComp(691 elt=Call(692 func=Name(id='ord', ctx=Load()),693 args=[694 Name(id='c', ctx=Load())],695 keywords=[]),696 generators=[697 comprehension(698 target=Name(id='line', ctx=Store()),699 iter=Name(id='file', ctx=Load()),700 ifs=[],701 is_async=0),702 comprehension(703 target=Name(id='c', ctx=Store()),704 iter=Name(id='line', ctx=Load()),705 ifs=[],706 is_async=0)]))707708>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),709... indent=4)) # выражение-генератор710Expression(711 body=GeneratorExp(712 elt=BinOp(713 left=Name(id='n', ctx=Load()),714 op=Pow(),715 right=Constant(value=2)),716 generators=[717 comprehension(718 target=Name(id='n', ctx=Store()),719 iter=Name(id='it', ctx=Load()),720 ifs=[721 Compare(722 left=Name(id='n', ctx=Load()),723 ops=[724 Gt()],725 comparators=[726 Constant(value=5)]),727 Compare(728 left=Name(id='n', ctx=Load()),729 ops=[730 Lt()],731 comparators=[732 Constant(value=10)])],733 is_async=0)]))734735>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),736... indent=4)) # асинхронное включение737Expression(738 body=ListComp(739 elt=Name(id='i', ctx=Load()),740 generators=[741 comprehension(742 target=Name(id='i', ctx=Store()),743 iter=Name(id='soc', ctx=Load()),744 ifs=[],745 is_async=1)]))746```747748### Инструкции749750#### `class ast.Assign(targets, value, type_comment)`751752Присваивание. `targets` – список узлов, а `value` – один узел.753754Несколько узлов в `targets` обозначают присваивание одного и того же значения каждому. Распаковка представляется помещением узла [`Tuple`](https://python-all.ru/3.9/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.9/library/ast.html#ast.List) внутрь `targets`.755756#### `type_comment`757758`type_comment` – это необязательная строка с аннотацией типа в виде комментария.759760```pycon761>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # множественное присваивание762Module(763 body=[764 Assign(765 targets=[766 Name(id='a', ctx=Store()),767 Name(id='b', ctx=Store())],768 value=Constant(value=1))],769 type_ignores=[])770771>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # распаковка772Module(773 body=[774 Assign(775 targets=[776 Tuple(777 elts=[778 Name(id='a', ctx=Store()),779 Name(id='b', ctx=Store())],780 ctx=Store())],781 value=Name(id='c', ctx=Load()))],782 type_ignores=[])783```784785#### `class ast.AnnAssign(target, annotation, value, simple)`786787Присваивание с аннотацией типа. `target` – это один узел, которым может быть [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.9/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.9/library/ast.html#ast.Subscript). `annotation` – это аннотация, например узел [`Constant`](https://python-all.ru/3.9/library/ast.html#ast.Constant) или [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name). `value` – единственный необязательный узел. `simple` – целое число-флаг, равное True для узла [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name) в `target`, которые не появляются в круглых скобках и поэтому являются чистыми именами, а не выражениями.788789```pycon790>>> print(ast.dump(ast.parse('c: int'), indent=4))791Module(792 body=[793 AnnAssign(794 target=Name(id='c', ctx=Store()),795 annotation=Name(id='int', ctx=Load()),796 simple=1)],797 type_ignores=[])798799>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # аннотация со скобками800Module(801 body=[802 AnnAssign(803 target=Name(id='a', ctx=Store()),804 annotation=Name(id='int', ctx=Load()),805 value=Constant(value=1),806 simple=0)],807 type_ignores=[])808809>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # аннотация атрибута810Module(811 body=[812 AnnAssign(813 target=Attribute(814 value=Name(id='a', ctx=Load()),815 attr='b',816 ctx=Store()),817 annotation=Name(id='int', ctx=Load()),818 simple=0)],819 type_ignores=[])820821>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # аннотация подписки822Module(823 body=[824 AnnAssign(825 target=Subscript(826 value=Name(id='a', ctx=Load()),827 slice=Constant(value=1),828 ctx=Store()),829 annotation=Name(id='int', ctx=Load()),830 simple=0)],831 type_ignores=[])832```833834#### `class ast.AugAssign(target, op, value)`835836Расширенное присваивание, например `a += 1`. В следующем примере `target` – это узел [Имя](https://python-all.ru/3.9/library/ast.html#ast.Name) для `x` (с контекстом [`Store`](https://python-all.ru/3.9/library/ast.html#ast.Store)), `op` – это [Сложение](https://python-all.ru/3.9/library/ast.html#ast.Add), а `value` – это [Константа](https://python-all.ru/3.9/library/ast.html#ast.Constant) со значением 1.837838Атрибут `target` не может быть класса [`Tuple`](https://python-all.ru/3.9/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.9/library/ast.html#ast.List), в отличие от целей [`Assign`](https://python-all.ru/3.9/library/ast.html#ast.Assign).839840```pycon841>>> print(ast.dump(ast.parse('x += 2'), indent=4))842Module(843 body=[844 AugAssign(845 target=Name(id='x', ctx=Store()),846 op=Add(),847 value=Constant(value=2))],848 type_ignores=[])849```850851#### `class ast.Raise(exc, cause)`852853Инструкция `raise`. `exc` – объект исключения, который необходимо возбудить, обычно [Вызов](https://python-all.ru/3.9/library/ast.html#ast.Call) или [Имя](https://python-all.ru/3.9/library/ast.html#ast.Name), или `None` для отдельного `raise`. `cause` – необязательная часть для `y` в `Возбуждение`.854855```pycon856>>> print(ast.dump(ast.parse('raise x from y'), indent=4))857Module(858 body=[859 Raise(860 exc=Name(id='x', ctx=Load()),861 cause=Name(id='y', ctx=Load()))],862 type_ignores=[])863```864865#### `class ast.Assert(test, msg)`866867Утверждение. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.9/library/ast.html#ast.Compare). `msg` содержит сообщение об ошибке.868869```pycon870>>> print(ast.dump(ast.parse('assert x,y'), indent=4))871Module(872 body=[873 Assert(874 test=Name(id='x', ctx=Load()),875 msg=Name(id='y', ctx=Load()))],876 type_ignores=[])877```878879#### `class ast.Delete(targets)`880881Представляет инструкцию `del`. `targets` – список узлов, например узлов [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.9/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.9/library/ast.html#ast.Subscript).882883```pycon884>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))885Module(886 body=[887 Delete(888 targets=[889 Name(id='x', ctx=Del()),890 Name(id='y', ctx=Del()),891 Name(id='z', ctx=Del())])],892 type_ignores=[])893```894895#### `class ast.Pass`896897Инструкция `pass`.898899```pycon900>>> print(ast.dump(ast.parse('pass'), indent=4))901Module(902 body=[903 Pass()],904 type_ignores=[])905```906907Другие инструкции, которые применимы только внутри функций или циклов, описаны в других разделах.908909#### Импорты910911#### `class ast.Import(names)`912913Инструкция импорта. `names` – это список узлов [`alias`](https://python-all.ru/3.9/library/ast.html#ast.alias).914915```pycon916>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))917Module(918 body=[919 Import(920 names=[921 alias(name='x'),922 alias(name='y'),923 alias(name='z')])],924 type_ignores=[])925```926927#### `class ast.ImportFrom(module, names, level)`928929Представляет `from x import y`. `module` – это необработанная строка имени from, без начальных точек, или `None` для инструкций вроде `from . import foo`. `level` – целое число, указывающее уровень относительного импорта (0 означает абсолютный импорт).930931```pycon932>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))933Module(934 body=[935 ImportFrom(936 module='y',937 names=[938 alias(name='x'),939 alias(name='y'),940 alias(name='z')],941 level=0)],942 type_ignores=[])943```944945#### `class ast.alias(name, asname)`946947Оба параметра – необработанные строки имён. `asname` может быть `None`, если должно использоваться обычное имя.948949```pycon950>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))951Module(952 body=[953 ImportFrom(954 module='foo.bar',955 names=[956 alias(name='a', asname='b'),957 alias(name='c')],958 level=2)],959 type_ignores=[])960```961962### Управление потоком963964> **Примечание**965>966> Необязательные предложения, такие как `else`, сохраняются как пустой список, если они отсутствуют.967968#### `class ast.If(test, body, orelse)`969970Инструкция `if`. `test` содержит один узел, например узел [`Compare`](https://python-all.ru/3.9/library/ast.html#ast.Compare). `body` и `orelse` содержат по списку узлов.971972Предложения `elif` не имеют специального представления в AST, а появляются как дополнительные узлы [`If`](https://python-all.ru/3.9/library/ast.html#ast.If) в разделе `orelse` предыдущего.973974```pycon975>>> print(ast.dump(ast.parse("""976... if x:977... ...978... elif y:979... ...980... else:981... ...982... """), indent=4))983Module(984 body=[985 If(986 test=Name(id='x', ctx=Load()),987 body=[988 Expr(989 value=Constant(value=Ellipsis))],990 orelse=[991 If(992 test=Name(id='y', ctx=Load()),993 body=[994 Expr(995 value=Constant(value=Ellipsis))],996 orelse=[997 Expr(998 value=Constant(value=Ellipsis))])])],999 type_ignores=[])1000```10011002#### `class ast.For(target, iter, body, orelse, type_comment)`10031004Цикл `for`. `target` содержит переменную (или переменные), которой присваивает цикл, в виде одного узла [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.9/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.9/library/ast.html#ast.List). `iter` содержит элемент, по которому выполняется итерация, также в виде одного узла. `body` и `orelse` содержат списки узлов для выполнения. Узлы в `orelse` выполняются, если цикл завершается нормально, а не через оператор `break`.10051006#### `type_comment`10071008`type_comment` – это необязательная строка с аннотацией типа в виде комментария.10091010```pycon1011>>> print(ast.dump(ast.parse("""1012... for x in y:1013... ...1014... else:1015... ...1016... """), indent=4))1017Module(1018 body=[1019 For(1020 target=Name(id='x', ctx=Store()),1021 iter=Name(id='y', ctx=Load()),1022 body=[1023 Expr(1024 value=Constant(value=Ellipsis))],1025 orelse=[1026 Expr(1027 value=Constant(value=Ellipsis))])],1028 type_ignores=[])1029```10301031#### `class ast.While(test, body, orelse)`10321033Цикл `while`. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.9/library/ast.html#ast.Compare).10341035```pycon1036>> print(ast.dump(ast.parse("""1037... while x:1038... ...1039... else:1040... ...1041... """), indent=4))1042Module(1043 body=[1044 While(1045 test=Name(id='x', ctx=Load()),1046 body=[1047 Expr(1048 value=Constant(value=Ellipsis))],1049 orelse=[1050 Expr(1051 value=Constant(value=Ellipsis))])],1052 type_ignores=[])1053```10541055#### `class ast.Break`10561057#### `class ast.Continue`10581059Инструкции `break` и `continue`.10601061```pycon1062>>> print(ast.dump(ast.parse("""\1063... for a in b:1064... if a > 5:1065... break1066... else:1067... continue1068...1069... """), indent=4))1070Module(1071 body=[1072 For(1073 target=Name(id='a', ctx=Store()),1074 iter=Name(id='b', ctx=Load()),1075 body=[1076 If(1077 test=Compare(1078 left=Name(id='a', ctx=Load()),1079 ops=[1080 Gt()],1081 comparators=[1082 Constant(value=5)]),1083 body=[1084 Break()],1085 orelse=[1086 Continue()])],1087 orelse=[])],1088 type_ignores=[])1089```10901091#### `class ast.Try(body, handlers, orelse, finalbody)`10921093Блоки `try`. Все атрибуты – списки узлов для выполнения, за исключением `handlers`, который является списком узлов [`ExceptHandler`](https://python-all.ru/3.9/library/ast.html#ast.ExceptHandler).10941095```pycon1096>>> print(ast.dump(ast.parse("""1097... try:1098... ...1099... except Exception:1100... ...1101... except OtherException as e:1102... ...1103... else:1104... ...1105... finally:1106... ...1107... """), indent=4))1108Module(1109 body=[1110 Try(1111 body=[1112 Expr(1113 value=Constant(value=Ellipsis))],1114 handlers=[1115 ExceptHandler(1116 type=Name(id='Exception', ctx=Load()),1117 body=[1118 Expr(1119 value=Constant(value=Ellipsis))]),1120 ExceptHandler(1121 type=Name(id='OtherException', ctx=Load()),1122 name='e',1123 body=[1124 Expr(1125 value=Constant(value=Ellipsis))])],1126 orelse=[1127 Expr(1128 value=Constant(value=Ellipsis))],1129 finalbody=[1130 Expr(1131 value=Constant(value=Ellipsis))])],1132 type_ignores=[])1133```11341135#### `class ast.ExceptHandler(type, name, body)`11361137Одно предложение `except`. `type` – тип исключения, который оно перехватывает, обычно узел [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name) (или `None` для универсального предложения `except:`). `name` – необработанная строка для имени, в котором будет сохранено исключение, или `None`, если в предложении нет `as foo`. `body` – список узлов.11381139```pycon1140>>> print(ast.dump(ast.parse("""\1141... try:1142... a + 11143... except TypeError:1144... pass1145... """), indent=4))1146Module(1147 body=[1148 Try(1149 body=[1150 Expr(1151 value=BinOp(1152 left=Name(id='a', ctx=Load()),1153 op=Add(),1154 right=Constant(value=1)))],1155 handlers=[1156 ExceptHandler(1157 type=Name(id='TypeError', ctx=Load()),1158 body=[1159 Pass()])],1160 orelse=[],1161 finalbody=[])],1162 type_ignores=[])1163```11641165#### `class ast.With(items, body, type_comment)`11661167Блок `with`. `items` – это список узлов [`withitem`](https://python-all.ru/3.9/library/ast.html#ast.withitem), представляющих менеджеры контекста, а `body` – это блок с отступом внутри контекста.11681169#### `type_comment`11701171`type_comment` – это необязательная строка с аннотацией типа в виде комментария.11721173#### `class ast.withitem(context_expr, optional_vars)`11741175Один менеджер контекста в блоке `with`. `context_expr` – это менеджер контекста, часто узел [`Call`](https://python-all.ru/3.9/library/ast.html#ast.Call). `optional_vars` – это [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.9/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.9/library/ast.html#ast.List) для части `as foo`, или `None`, если она не используется.11761177```pycon1178>>> print(ast.dump(ast.parse("""\1179... with a as b, c as d:1180... something(b, d)1181... """), indent=4))1182Module(1183 body=[1184 With(1185 items=[1186 withitem(1187 context_expr=Name(id='a', ctx=Load()),1188 optional_vars=Name(id='b', ctx=Store())),1189 withitem(1190 context_expr=Name(id='c', ctx=Load()),1191 optional_vars=Name(id='d', ctx=Store()))],1192 body=[1193 Expr(1194 value=Call(1195 func=Name(id='something', ctx=Load()),1196 args=[1197 Name(id='b', ctx=Load()),1198 Name(id='d', ctx=Load())],1199 keywords=[]))])],1200 type_ignores=[])1201```12021203### Определения функций и классов12041205#### `class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment)`12061207Определение функции.12081209- `name` – это необработанная строка имени функции.1210- `args` – это узел [`arguments`](https://python-all.ru/3.9/library/ast.html#ast.arguments).1211- `body` – это список узлов внутри функции.1212- `decorator_list` – это список декораторов, которые будут применены; декораторы перечислены от самого внешнего к внутреннему (т.е. первый в списке применяется последним).1213- `returns` – это аннотация возвращаемого значения.12141215#### `type_comment`12161217`type_comment` – это необязательная строка с аннотацией типа в виде комментария.12181219#### `class ast.Lambda(args, body)`12201221`lambda` – это минимальное определение функции, которое можно использовать внутри выражения. В отличие от [`FunctionDef`](https://python-all.ru/3.9/library/ast.html#ast.FunctionDef), `body` содержит один узел.12221223```pycon1224>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))1225Module(1226 body=[1227 Expr(1228 value=Lambda(1229 args=arguments(1230 posonlyargs=[],1231 args=[1232 arg(arg='x'),1233 arg(arg='y')],1234 kwonlyargs=[],1235 kw_defaults=[],1236 defaults=[]),1237 body=Constant(value=Ellipsis)))],1238 type_ignores=[])1239```12401241#### `class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)`12421243Аргументы функции.12441245- `posonlyargs`, `args` и `kwonlyargs` – это списки узлов [`arg`](https://python-all.ru/3.9/library/ast.html#ast.arg).1246- `vararg` и `kwarg` – это одиночные узлы [`arg`](https://python-all.ru/3.9/library/ast.html#ast.arg), ссылающиеся на параметры `*args, **kwargs`.1247- `kw_defaults` – это список значений по умолчанию для keyword-only аргументов. Если один из них равен `None`, соответствующий аргумент обязателен.1248- `defaults` – это список значений по умолчанию для аргументов, которые можно передавать позиционно. Если значений по умолчанию меньше, они соответствуют последним n аргументам.12491250#### `class ast.arg(arg, annotation, type_comment)`12511252Один аргумент в списке. `arg` – это сырая строка с именем аргумента, `annotation` – это его аннотация, например, узел `Str` или [`Name`](https://python-all.ru/3.9/library/ast.html#ast.Name).12531254#### `type_comment`12551256`type_comment` – это необязательная строка с аннотацией типа в виде комментария12571258```pycon1259>>> print(ast.dump(ast.parse("""\1260... @decorator11261... @decorator21262... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':1263... pass1264... """), indent=4))1265Module(1266 body=[1267 FunctionDef(1268 name='f',1269 args=arguments(1270 posonlyargs=[],1271 args=[1272 arg(1273 arg='a',1274 annotation=Constant(value='annotation')),1275 arg(arg='b'),1276 arg(arg='c')],1277 vararg=arg(arg='d'),1278 kwonlyargs=[1279 arg(arg='e'),1280 arg(arg='f')],1281 kw_defaults=[1282 None,1283 Constant(value=3)],1284 kwarg=arg(arg='g'),1285 defaults=[1286 Constant(value=1),1287 Constant(value=2)]),1288 body=[1289 Pass()],1290 decorator_list=[1291 Name(id='decorator1', ctx=Load()),1292 Name(id='decorator2', ctx=Load())],1293 returns=Constant(value='return annotation'))],1294 type_ignores=[])1295```12961297#### `class ast.Return(value)`12981299Инструкция `return`.13001301```pycon1302>>> print(ast.dump(ast.parse('return 4'), indent=4))1303Module(1304 body=[1305 Return(1306 value=Constant(value=4))],1307 type_ignores=[])1308```13091310#### `class ast.Yield(value)`13111312#### `class ast.YieldFrom(value)`13131314Выражение `yield` или `yield from`. Поскольку это выражения, их необходимо обернуть в узел [`Expr`](https://python-all.ru/3.9/library/ast.html#ast.Expr), если возвращаемое значение не используется.13151316```pycon1317>>> print(ast.dump(ast.parse('yield x'), indent=4))1318Module(1319 body=[1320 Expr(1321 value=Yield(1322 value=Name(id='x', ctx=Load())))],1323 type_ignores=[])13241325>>> print(ast.dump(ast.parse('yield from x'), indent=4))1326Module(1327 body=[1328 Expr(1329 value=YieldFrom(1330 value=Name(id='x', ctx=Load())))],1331 type_ignores=[])1332```13331334#### `class ast.Global(names)`13351336#### `class ast.Nonlocal(names)`13371338Инструкции `global` и `nonlocal`. `names` – это список сырых строк.13391340```pycon1341>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))1342Module(1343 body=[1344 Global(1345 names=[1346 'x',1347 'y',1348 'z'])],1349 type_ignores=[])13501351>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))1352Module(1353 body=[1354 Nonlocal(1355 names=[1356 'x',1357 'y',1358 'z'])],1359 type_ignores=[])1360```13611362#### `class ast.ClassDef(name, bases, keywords, starargs, kwargs, body, decorator_list)`13631364Определение класса.13651366- `name` – это сырая строка с именем класса.1367- `bases` – это список узлов для явно указанных базовых классов.1368- `keywords` – это список узлов [`keyword`](https://python-all.ru/3.9/library/keyword.html#module-keyword), в основном для «metaclass». Остальные ключевые слова будут переданы метаклассу в соответствии с [PEP-3115](https://python-all.ru/3.9/library/ast.html).1369- `starargs` и `kwargs` – каждый является отдельным узлом, как при вызове функции. starargs будет развёрнут для присоединения к списку базовых классов, а kwargs будет передан метаклассу.1370- `body` – это список узлов, представляющих код внутри определения класса.1371- `decorator_list` – это список узлов, как и в [`FunctionDef`](https://python-all.ru/3.9/library/ast.html#ast.FunctionDef).13721373```pycon1374>>> print(ast.dump(ast.parse("""\1375... @decorator11376... @decorator21377... class Foo(base1, base2, metaclass=meta):1378... pass1379... """), indent=4))1380Module(1381 body=[1382 ClassDef(1383 name='Foo',1384 bases=[1385 Name(id='base1', ctx=Load()),1386 Name(id='base2', ctx=Load())],1387 keywords=[1388 keyword(1389 arg='metaclass',1390 value=Name(id='meta', ctx=Load()))],1391 body=[1392 Pass()],1393 decorator_list=[1394 Name(id='decorator1', ctx=Load()),1395 Name(id='decorator2', ctx=Load())])],1396 type_ignores=[])1397```13981399### async и await14001401#### `class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment)`14021403Определение функции `async def`. Имеет те же поля, что и [`FunctionDef`](https://python-all.ru/3.9/library/ast.html#ast.FunctionDef).14041405#### `class ast.Await(value)`14061407Выражение `await`. `value` – это то, чего оно ожидает. Допустимо только в теле [`AsyncFunctionDef`](https://python-all.ru/3.9/library/ast.html#ast.AsyncFunctionDef).14081409```pycon1410>>> print(ast.dump(ast.parse("""\1411... async def f():1412... await other_func()1413... """), indent=4))1414Module(1415 body=[1416 AsyncFunctionDef(1417 name='f',1418 args=arguments(1419 posonlyargs=[],1420 args=[],1421 kwonlyargs=[],1422 kw_defaults=[],1423 defaults=[]),1424 body=[1425 Expr(1426 value=Await(1427 value=Call(1428 func=Name(id='other_func', ctx=Load()),1429 args=[],1430 keywords=[])))],1431 decorator_list=[])],1432 type_ignores=[])1433```14341435#### `class ast.AsyncFor(target, iter, body, orelse, type_comment)`14361437#### `class ast.AsyncWith(items, body, type_comment)`14381439`async for` циклы и `async with` менеджеры контекста. Они имеют те же поля, что [`For`](https://python-all.ru/3.9/library/ast.html#ast.For) и [`With`](https://python-all.ru/3.9/library/ast.html#ast.With), соответственно. Допустимы только в теле [`AsyncFunctionDef`](https://python-all.ru/3.9/library/ast.html#ast.AsyncFunctionDef).14401441> **Примечание**1442>1443> Когда строка разбирается парсером [`ast.parse()`](https://python-all.ru/3.9/library/ast.html#ast.parse), узлы операторов (подклассы `ast.operator`, `ast.unaryop`, `ast.cmpop`, `ast.boolop` и `ast.expr_context`) на возвращаемом дереве являются синглтонами. Изменения в одном будут отражены во всех других вхождениях того же значения (например, [`ast.Add`](https://python-all.ru/3.9/library/ast.html#ast.Add)).14441445## [`ast`](https://python-all.ru/3.9/library/ast.html#module-ast) Вспомогательные функции14461447Помимо классов узлов, модуль [`ast`](https://python-all.ru/3.9/library/ast.html#module-ast) определяет следующие служебные функции и классы для обхода абстрактных синтаксических деревьев:14481449#### `ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None)`14501451Разбирает исходный код в узел AST. Эквивалентно `compile(source, filename, mode, ast.PyCF_ONLY_AST)`.14521453Если задан `type_comments=True`, парсер изменяется, чтобы проверять и возвращать комментарии типов, как указано в [**PEP 484**](https://python-all.ru/3.9/library/ast.html) и [**PEP 526**](https://python-all.ru/3.9/library/ast.html). Это эквивалентно добавлению [`ast.PyCF_TYPE_COMMENTS`](https://python-all.ru/3.9/library/ast.html#ast.PyCF_TYPE_COMMENTS) к флагам, передаваемым в [`compile()`](https://python-all.ru/3.9/library/functions.html#compile). Это приведёт к сообщению об ошибках синтаксиса для неправильно расположенных комментариев типов. Без этого флага комментарии типов будут игнорироваться, и поле `type_comment` в выбранных узлах AST всегда будет `None`. Кроме того, расположение комментариев `# type: ignore` будет возвращаться как атрибут `type_ignores` объекта `Module` (иначе это всегда пустой список).14541455Кроме того, если `mode` равно `'func_type'`, синтаксис входных данных изменяется в соответствии с [**PEP 484**](https://python-all.ru/3.9/library/ast.html) «сигнатурными комментариями типов», например `(str, int) -> List[str]`.14561457Также установка `feature_version` в кортеж `(major, minor)` попытается выполнить разбор с использованием грамматики этой версии Python. В настоящее время `major` должно быть равно `3`. Например, установка `feature_version=(3, 4)` разрешит использование `async` и `await` в качестве имён переменных. Минимальная поддерживаемая версия – `(3, 4)`; максимальная – `sys.version_info[0:2]`.14581459Если source содержит нулевой символ ('0'), возбуждается [`ValueError`](https://python-all.ru/3.9/library/exceptions.html#ValueError).14601461> > **Предупреждение**1462> >1463> > Обратите внимание, что успешный разбор исходного кода в объект AST не гарантирует, что предоставленный исходный код является корректным кодом Python, который можно выполнить, поскольку этап компиляции может вызывать дополнительные исключения [`SyntaxError`](https://python-all.ru/3.9/library/exceptions.html#SyntaxError). Например, исходный код `return 42` генерирует корректный узел AST для инструкции return, но его нельзя скомпилировать отдельно (он должен находиться внутри узла функции).1464> >1465> > В частности, [`ast.parse()`](https://python-all.ru/3.9/library/ast.html#ast.parse) не выполняет никаких проверок областей видимости, которые выполняет этап компиляции.14661467> **Предупреждение**1468>1469> Можно вызвать сбой интерпретатора Python с помощью достаточно большой/сложной строки из-за ограничений глубины стека в компиляторе AST Python.14701471Изменено в версии 3.8: Добавлены `type_comments`, `mode='func_type'` и `feature_version`.14721473#### `ast.unparse(ast_obj)`14741475Выполняет обратный разбор объекта [`ast.AST`](https://python-all.ru/3.9/library/ast.html#ast.AST) и генерирует строку с кодом, который при обратном разборе с помощью [`ast.parse()`](https://python-all.ru/3.9/library/ast.html#ast.parse) даст эквивалентный объект [`ast.AST`](https://python-all.ru/3.9/library/ast.html#ast.AST).14761477> **Предупреждение**1478>1479> Полученная строка кода не обязательно будет равна исходному коду, который породил объект [`ast.AST`](https://python-all.ru/3.9/library/ast.html#ast.AST) (без каких-либо оптимизаций компилятора, таких как константные кортежи/frozensets).14801481> **Предупреждение**1482>1483> Попытка выполнить обратный разбор очень сложного выражения приведёт к [`RecursionError`](https://python-all.ru/3.9/library/exceptions.html#RecursionError).14841485Новое в версии 3.9.14861487#### `ast.literal_eval(node_or_string)`14881489Вычисляет узел выражения или строку, содержащую только литерал Python или отображение контейнера. Предоставленная строка или узел могут состоять только из следующих структур литералов Python: строки, байты, числа, кортежи, списки, словари, множества, булевы значения и `None`.14901491Это можно использовать для вычисления строк, содержащих значения Python, без необходимости разбирать значения самостоятельно. Он не способен вычислять произвольно сложные выражения, например, с операторами или индексацией.14921493Раньше эта функция документировалась как «безопасная» без определения, что это значит. Это вводило в заблуждение. Она специально разработана так, чтобы не выполнять код Python, в отличие от более общей [`eval()`](https://python-all.ru/3.9/library/functions.html#eval). Нет пространства имён, поиска имён или возможности внешних вызовов. Но она не свободна от атак: относительно небольшой ввод может привести к истощению памяти или истощению стека C, что вызовет сбой процесса. Также существует возможность отказа в обслуживании из-за чрезмерного потребления ЦП на некоторых входных данных. Поэтому вызывать её на недоверенных данных не рекомендуется.14941495> **Предупреждение**1496>1497> Можно вызвать сбой интерпретатора Python из-за ограничений глубины стека в компиляторе AST Python.14981499Изменено в версии 3.2: Теперь допускает литералы байтов и множеств.15001501Изменено в версии 3.9: Теперь поддерживает создание пустых множеств с помощью `'set()'`.15021503#### `ast.get_docstring(node, clean=True)`15041505Возвращает строку документации для данного *узла* (который должен быть узлом [`FunctionDef`](https://python-all.ru/3.9/library/ast.html#ast.FunctionDef), [`AsyncFunctionDef`](https://python-all.ru/3.9/library/ast.html#ast.AsyncFunctionDef), [`ClassDef`](https://python-all.ru/3.9/library/ast.html#ast.ClassDef) или `Module`) или `None`, если у него нет строки документации. Если *clean* истинно, очищает отступы строки документации с помощью [`inspect.cleandoc()`](https://python-all.ru/3.9/library/inspect.html#inspect.cleandoc).15061507Изменено в версии 3.5: Теперь поддерживается [`AsyncFunctionDef`](https://python-all.ru/3.9/library/ast.html#ast.AsyncFunctionDef).15081509#### `ast.get_source_segment(source, node, *, padded=False)`15101511Возвращает фрагмент исходного кода из *source*, который породил узел *node*. Если не хватает информации о местоположении (`lineno`, `end_lineno`, `col_offset` или `end_col_offset`), возвращает `None`.15121513Если *padded* равно `True`, первая строка многострочного оператора будет дополнена пробелами, чтобы соответствовать исходной позиции.15141515Новое в версии 3.8.15161517#### `ast.fix_missing_locations(node)`15181519При компиляции дерева узлов с помощью [`compile()`](https://python-all.ru/3.9/library/functions.html#compile) компилятор ожидает атрибуты `lineno` и `col_offset` для каждого узла, который их поддерживает. Заполнять их вручную для сгенерированных узлов довольно утомительно, поэтому эта вспомогательная функция рекурсивно добавляет эти атрибуты, если их ещё нет, устанавливая их равными значениям родительского узла. Работает рекурсивно, начиная с *node*.15201521#### `ast.increment_lineno(node, n=1)`15221523Увеличивает номер строки и номер конечной строки каждого узла в дереве, начиная с *node*, на *n*. Это полезно для «перемещения кода» в другое место в файле.15241525#### `ast.copy_location(new_node, old_node)`15261527Копирует информацию о местоположении в исходном коде (`lineno`, `col_offset`, `end_lineno` и `end_col_offset`) из *old\_node* в *new\_node*, если это возможно, и возвращает *new\_node*.15281529#### `ast.iter_fields(node)`15301531Генерирует кортеж из `(fieldname, value)` для каждого поля в `node._fields`, которое присутствует в *node*.15321533#### `ast.iter_child_nodes(node)`15341535Генерирует все непосредственные дочерние узлы *node*, то есть все поля, являющиеся узлами, и все элементы полей, являющихся списками узлов.15361537#### `ast.walk(node)`15381539Рекурсивно генерирует все узлы-потомки в дереве, начиная с *node* (включая сам *node*), в произвольном порядке. Это полезно, если требуется только изменить узлы на месте, а контекст не важен.15401541#### `class ast.NodeVisitor`15421543Базовый класс для обхода узлов, который обходит абстрактное синтаксическое дерево и вызывает функцию-посетитель для каждого найденного узла. Эта функция может вернуть значение, которое передаётся методом [`visit()`](https://python-all.ru/3.9/library/ast.html#ast.NodeVisitor.visit).15441545Этот класс предназначен для наследования; в подклассе добавляются методы-посетители.15461547#### `visit(node)`15481549Посещает узел. Реализация по умолчанию вызывает метод `self.visit_classname`, где *classname* – имя класса узла, или [`generic_visit()`](https://python-all.ru/3.9/library/ast.html#ast.NodeVisitor.generic_visit), если такой метод отсутствует.15501551#### `generic_visit(node)`15521553Этот посетитель вызывает [`visit()`](https://python-all.ru/3.9/library/ast.html#ast.NodeVisitor.visit) для всех дочерних узлов.15541555Обратите внимание, что дочерние узлы тех узлов, для которых определён собственный метод-посетитель, не будут посещены, если посетитель сам не вызовет [`generic_visit()`](https://python-all.ru/3.9/library/ast.html#ast.NodeVisitor.generic_visit) или не обойдёт их самостоятельно.15561557Не используйте [`NodeVisitor`](https://python-all.ru/3.9/library/ast.html#ast.NodeVisitor), если требуется вносить изменения в узлы во время обхода. Для этого существует специальный посетитель ([`NodeTransformer`](https://python-all.ru/3.9/library/ast.html#ast.NodeTransformer)), который допускает модификации.15581559Устарело с версии 3.8: Методы `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` и `visit_Ellipsis()` теперь устарели и не будут вызываться в будущих версиях Python. Добавьте метод `visit_Constant()` для обработки всех узлов-констант.15601561#### `class ast.NodeTransformer`15621563Подкласс [`NodeVisitor`](https://python-all.ru/3.9/library/ast.html#ast.NodeVisitor), который обходит абстрактное синтаксическое дерево и позволяет изменять узлы.15641565Метод [`NodeTransformer`](https://python-all.ru/3.9/library/ast.html#ast.NodeTransformer) обходит AST и использует возвращаемое значение методов-посетителей для замены или удаления старого узла. Если возвращаемое значение метода-посетителя равно `None`, узел будет удалён из своего местоположения; в противном случае он заменяется возвращённым значением. Возвращённое значение может быть исходным узлом – в этом случае замена не происходит.15661567Вот пример преобразователя, который переписывает все обращения к именам (`foo`) в `data['foo']`:15681569```python1570class RewriteName(NodeTransformer):15711572 def visit_Name(self, node):1573 return Subscript(1574 value=Name(id='data', ctx=Load()),1575 slice=Constant(value=node.id),1576 ctx=node.ctx1577 )1578```15791580Имейте в виду: если у узла, с которым вы работаете, есть дочерние узлы, необходимо либо преобразовать дочерние узлы самостоятельно, либо сначала вызвать для узла метод `generic_visit()`.15811582Для узлов, входящих в состав набора инструкций (это относится ко всем узлам инструкций), посетитель может также возвращать список узлов, а не один узел.15831584Если [`NodeTransformer`](https://python-all.ru/3.9/library/ast.html#ast.NodeTransformer) вводит новые узлы (не входившие в исходное дерево) без указания информации о расположении (например, `lineno`), следует вызвать [`fix_missing_locations()`](https://python-all.ru/3.9/library/ast.html#ast.fix_missing_locations) для нового поддерева, чтобы пересчитать информацию о расположении:15851586```python1587tree = ast.parse('foo', mode='eval')1588new_tree = fix_missing_locations(RewriteName().visit(tree))1589```15901591Обычно преобразователь используется следующим образом:15921593```python1594node = YourTransformer().visit(node)1595```15961597#### `ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None)`15981599Возвращает форматированный дамп дерева из *node*. Это в основном полезно для отладки. Если *annotate\_fields* равно true (по умолчанию), возвращаемая строка будет показывать имена и значения полей. Если *annotate\_fields* равно false, результирующая строка будет более компактной за счёт опускания однозначных имён полей. Атрибуты, такие как номера строк и смещения столбцов, по умолчанию не выводятся. Если это нужно, *include\_attributes* можно установить в true.16001601Если *indent* – неотрицательное целое число или строка, дерево будет выведено с отступами указанного уровня. Уровень отступа 0, отрицательное значение или `""` вставляет только переводы строк. `None` (по умолчанию) выбирает однострочное представление. Положительный целочисленный отступ добавляет соответствующее количество пробелов на уровень. Если *indent* – строка (например, `"\t"`), эта строка используется для отступа каждого уровня.16021603Изменено в версии 3.9: Добавлена опция *indent*.16041605## Флаги компилятора16061607Следующие флаги могут быть переданы в [`compile()`](https://python-all.ru/3.9/library/functions.html#compile) для изменения эффектов компиляции программы:16081609#### `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`16101611Включает поддержку `await`, `async for`, `async with` и асинхронных включений верхнего уровня.16121613Новое в версии 3.8.16141615#### `ast.PyCF_ONLY_AST`16161617Генерирует и возвращает абстрактное синтаксическое дерево вместо скомпилированного объекта кода.16181619#### `ast.PyCF_TYPE_COMMENTS`16201621Включает поддержку комментариев типов в стиле [**PEP 484**](https://python-all.ru/3.9/library/ast.html) и [**PEP 526**](https://python-all.ru/3.9/library/ast.html) (`# type: <type>`, `# type: ignore <stuff>`).16221623Новое в версии 3.8.16241625## Использование командной строки16261627Новое в версии 3.9.16281629Модуль [`ast`](https://python-all.ru/3.9/library/ast.html#module-ast) может быть выполнен как скрипт из командной строки. Это просто:16301631```sh1632python -m ast [-m <mode>] [-a] [infile]1633```16341635Принимаются следующие опции:16361637#### `-h, --help`16381639Показать справку и выйти.16401641#### `-m <mode>`16421643#### `--mode <mode>`16441645Определяет, какой вид кода должен быть скомпилирован, как аргумент *mode* в [`parse()`](https://python-all.ru/3.9/library/ast.html#ast.parse).16461647#### `--no-type-comments`16481649Не обрабатывать комментарии типов.16501651#### `-a, --include-attributes`16521653Включать атрибуты, такие как номера строк и смещения столбцов.16541655#### `-i <indent>`16561657#### `--indent <indent>`16581659Отступ узлов в AST (количество пробелов).16601661Если указан `infile`, его содержимое разбирается в AST и выводится в stdout. В противном случае содержимое читается из stdin.16621663> **См. также**1664>1665> [Green Tree Snakes](https://python-all.ru/3.9/library/ast.html) – внешний документационный ресурс, содержащий подробности работы с AST Python.1666>1667> [ASTTokens](https://python-all.ru/3.9/library/ast.html) дополняет AST Python позициями токенов и текста в исходном коде, который их породил. Это полезно для инструментов, выполняющих преобразования исходного кода.1668>1669> [leoAst.py](https://python-all.ru/3.9/library/ast.html) объединяет представления программ на Python на основе токенов и синтаксических деревьев, вставляя двусторонние связи между токенами и узлами AST.1670>1671> [LibCST](https://python-all.ru/3.9/library/ast.html) разбирает код как конкретное синтаксическое дерево, похожее на AST, и сохраняет все детали форматирования. Это полезно для создания приложений автоматического рефакторинга (codemod) и линтеров.1672>1673> [Parso](https://python-all.ru/3.9/library/ast.html) – это синтаксический анализатор Python, поддерживающий восстановление после ошибок и сквозной разбор для разных версий Python (на нескольких версиях Python). Parso также может перечислять несколько синтаксических ошибок в файле Python.1674