ast.md
1> **Источник:** https://python-all.ru/3.10/library/ast.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# [`ast`](https://python-all.ru/3.10/library/ast.html#module-ast) – абстрактные синтаксические деревья89**Исходный код:** [Lib/ast.py](https://python-all.ru/src/3.10/Lib/ast.py)1011---1213Модуль [`ast`](https://python-all.ru/3.10/library/ast.html#module-ast) помогает приложениям Python обрабатывать деревья абстрактного синтаксиса языка Python. Абстрактный синтаксис может меняться от версии к версии; с помощью этого модуля можно программно узнать, как выглядит текущая грамматика.1415Абстрактное синтаксическое дерево можно создать, передав [`ast.PyCF_ONLY_AST`](https://python-all.ru/3.10/library/ast.html#ast.PyCF_ONLY_AST) в качестве флага встроенной функции [`compile()`](https://python-all.ru/3.10/library/functions.html#compile) или используя вспомогательную функцию [`parse()`](https://python-all.ru/3.10/library/ast.html#ast.parse) из этого модуля. Результатом будет дерево объектов, классы которых наследуют от [`ast.AST`](https://python-all.ru/3.10/library/ast.html#ast.AST). Абстрактное синтаксическое дерево можно скомпилировать в объект кода Python с помощью встроенной функции [`compile()`](https://python-all.ru/3.10/library/functions.html#compile).1617## Абстрактная грамматика1819Абстрактная грамматика в настоящее время определяется следующим образом:2021```asdl22-- Встроенные типы ASDL:23-- идентификатор, целое, строка, константа2425module Python26{27 mod = Module(stmt* body, type_ignore* type_ignores)28 | Interactive(stmt* body)29 | Expression(expr body)30 | FunctionType(expr* argtypes, expr returns)3132 stmt = FunctionDef(identifier name, arguments args,33 stmt* body, expr* decorator_list, expr? returns,34 string? type_comment)35 | AsyncFunctionDef(identifier name, arguments args,36 stmt* body, expr* decorator_list, expr? returns,37 string? type_comment)3839 | ClassDef(identifier name,40 expr* bases,41 keyword* keywords,42 stmt* body,43 expr* decorator_list)44 | Return(expr? value)4546 | Delete(expr* targets)47 | Assign(expr* targets, expr value, string? type_comment)48 | AugAssign(expr target, operator op, expr value)49 -- 'simple' указывает, что аннотируется простое имя без скобок50 | AnnAssign(expr target, expr annotation, expr? value, int simple)5152 -- используется 'orelse', так как else – ключевое слово в целевых языках53 | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)54 | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)55 | While(expr test, stmt* body, stmt* orelse)56 | If(expr test, stmt* body, stmt* orelse)57 | With(withitem* items, stmt* body, string? type_comment)58 | AsyncWith(withitem* items, stmt* body, string? type_comment)5960 | Match(expr subject, match_case* cases)6162 | Raise(expr? exc, expr? cause)63 | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)64 | Assert(expr test, expr? msg)6566 | Import(alias* names)67 | ImportFrom(identifier? module, alias* names, int? level)6869 | Global(identifier* names)70 | Nonlocal(identifier* names)71 | Expr(expr value)72 | Pass | Break | Continue7374 -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером75 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)7677 -- BoolOp() может использовать left и right?78 expr = BoolOp(boolop op, expr* values)79 | NamedExpr(expr target, expr value)80 | BinOp(expr left, operator op, expr right)81 | UnaryOp(unaryop op, expr operand)82 | Lambda(arguments args, expr body)83 | IfExp(expr test, expr body, expr orelse)84 | Dict(expr* keys, expr* values)85 | Set(expr* elts)86 | ListComp(expr elt, comprehension* generators)87 | SetComp(expr elt, comprehension* generators)88 | DictComp(expr key, expr value, comprehension* generators)89 | GeneratorExp(expr elt, comprehension* generators)90 -- грамматика ограничивает, где могут встречаться выражения yield91 | Await(expr value)92 | Yield(expr? value)93 | YieldFrom(expr value)94 -- нужны последовательности для сравнения, чтобы различать95 -- x < 4 < 3 and (x < 4) < 396 | Compare(expr left, cmpop* ops, expr* comparators)97 | Call(expr func, expr* args, keyword* keywords)98 | FormattedValue(expr value, int conversion, expr? format_spec)99 | JoinedStr(expr* values)100 | Constant(constant value, string? kind)101102 -- следующее выражение может появляться в контексте присваивания103 | Attribute(expr value, identifier attr, expr_context ctx)104 | Subscript(expr value, expr slice, expr_context ctx)105 | Starred(expr value, expr_context ctx)106 | Name(identifier id, expr_context ctx)107 | List(expr* elts, expr_context ctx)108 | Tuple(expr* elts, expr_context ctx)109110 -- может встречаться только в Subscript111 | Slice(expr? lower, expr? upper, expr? step)112113 -- col_offset – это смещение в байтах в строке UTF-8, используемой парсером114 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)115116 expr_context = Load | Store | Del117118 boolop = And | Or119120 operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift121 | RShift | BitOr | BitXor | BitAnd | FloorDiv122123 unaryop = Invert | Not | UAdd | USub124125 cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn126127 comprehension = (expr target, expr iter, expr* ifs, int is_async)128129 excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)130 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)131132 arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,133 expr* kw_defaults, arg? kwarg, expr* defaults)134135 arg = (identifier arg, expr? annotation, string? type_comment)136 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)137138 -- ключевые аргументы, переданные вызову (идентификатор NULL для **kwargs)139 keyword = (identifier? arg, expr value)140 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)141142 -- имя импорта с необязательным псевдонимом 'as'143 alias = (identifier name, identifier? asname)144 attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)145146 withitem = (expr context_expr, expr? optional_vars)147148 match_case = (pattern pattern, expr? guard, stmt* body)149150 pattern = MatchValue(expr value)151 | MatchSingleton(constant value)152 | MatchSequence(pattern* patterns)153 | MatchMapping(expr* keys, pattern* patterns, identifier? rest)154 | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)155156 | MatchStar(identifier? name)157 -- необязательный параметр "rest" MatchMapping обрабатывает захват дополнительных ключей отображения158159 | MatchAs(pattern? pattern, identifier? name)160 | MatchOr(pattern* patterns)161162 attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)163164 type_ignore = TypeIgnore(int lineno, string tag)165}166```167168## Классы узлов169170#### `class ast.AST`171172Это базовый класс для всех узлов AST. Реальные классы узлов унаследованы из файла `Parser/Python.asdl`, который воспроизведён [выше](https://python-all.ru/3.10/library/ast.html#abstract-grammar). Они определены в C-модуле `_ast` и повторно экспортируются в [`ast`](https://python-all.ru/3.10/library/ast.html#module-ast).173174Для каждого символа левой части абстрактной грамматики определён один класс (например, `ast.stmt` или `ast.expr`). Кроме того, для каждого конструктора правой части определён один класс; эти классы наследуют от классов для деревьев левой части. Например, [`ast.BinOp`](https://python-all.ru/3.10/library/ast.html#ast.BinOp) наследует от `ast.expr`. Для продукционных правил с альтернативами (так называемых «сумм») класс левой части является абстрактным: создаются только экземпляры конкретных узлов-конструкторов.175176#### `_fields`177178Каждый конкретный класс имеет атрибут [`_fields`](https://python-all.ru/3.10/library/ast.html#ast.AST._fields), который содержит имена всех дочерних узлов.179180Каждый экземпляр конкретного класса имеет по одному атрибуту для каждого дочернего узла, тип которого определён в грамматике. Например, экземпляры [`ast.BinOp`](https://python-all.ru/3.10/library/ast.html#ast.BinOp) имеют атрибут `left` типа `ast.expr`.181182Если эти атрибуты помечены как необязательные в грамматике (с помощью вопросительного знака), значением может быть `None`. Если атрибуты могут иметь ноль или более значений (помечены звёздочкой), значения представляются в виде списков Python. Все возможные атрибуты должны присутствовать и иметь корректные значения при компиляции AST с помощью [`compile()`](https://python-all.ru/3.10/library/functions.html#compile).183184#### `lineno`185186#### `col_offset`187188#### `end_lineno`189190#### `end_col_offset`191192Экземпляры подклассов `ast.expr` и `ast.stmt` имеют атрибуты [`lineno`](https://python-all.ru/3.10/library/ast.html#ast.AST.lineno), [`col_offset`](https://python-all.ru/3.10/library/ast.html#ast.AST.col_offset), [`end_lineno`](https://python-all.ru/3.10/library/ast.html#ast.AST.end_lineno) и [`end_col_offset`](https://python-all.ru/3.10/library/ast.html#ast.AST.end_col_offset). Атрибуты [`lineno`](https://python-all.ru/3.10/library/ast.html#ast.AST.lineno) и [`end_lineno`](https://python-all.ru/3.10/library/ast.html#ast.AST.end_lineno) – это номер первой и последней строки исходного текста (нумерация с 1, то есть первая строка – строка 1), а [`col_offset`](https://python-all.ru/3.10/library/ast.html#ast.AST.col_offset) и [`end_col_offset`](https://python-all.ru/3.10/library/ast.html#ast.AST.end_col_offset) – соответствующие смещения в байтах UTF-8 от первого и последнего токенов, породивших узел. Смещение UTF-8 записывается, потому что парсер использует UTF-8 внутри.193194Обратите внимание, что конечные позиции не требуются компилятором и поэтому являются необязательными. Смещение конца находится *после* последнего символа, например, можно получить фрагмент исходного кода узла выражения из одной строки с помощью `source_line[node.col_offset : node.end_col_offset]`.195196Конструктор класса `ast.T` разбирает свои аргументы следующим образом:197198- Если есть позиционные аргументы, их должно быть столько же, сколько элементов в `T._fields`; они будут присвоены как атрибуты с этими именами.199- Если есть ключевые аргументы, они установят атрибуты с теми же именами в указанные значения.200201Например, чтобы создать и заполнить узел [`ast.UnaryOp`](https://python-all.ru/3.10/library/ast.html#ast.UnaryOp), можно использовать202203```python204node = ast.UnaryOp()205node.op = ast.USub()206node.operand = ast.Constant()207node.operand.value = 5208node.operand.lineno = 0209node.operand.col_offset = 0210node.lineno = 0211node.col_offset = 0212```213214или более компактный215216```python217node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),218 lineno=0, col_offset=0)219```220221Изменено в версии 3.8: Класс [`ast.Constant`](https://python-all.ru/3.10/library/ast.html#ast.Constant) теперь используется для всех констант.222223Изменено в версии 3.9: Простые индексы представляются своим значением, расширенные срезы представляются кортежами.224225Устарело с версии 3.8: Старые классы `ast.Num`, `ast.Str`, `ast.Bytes`, `ast.NameConstant` и `ast.Ellipsis` всё ещё доступны, но будут удалены в будущих версиях Python. А пока их создание будет возвращать экземпляр другого класса.226227Устарело с версии 3.9: Старые классы `ast.Index` и `ast.ExtSlice` всё ещё доступны, но будут удалены в будущих выпусках Python. При этом при их создании будет возвращён экземпляр другого класса.228229> **Примечание**230>231> Описания конкретных классов узлов, приведённые здесь, изначально были адаптированы из замечательного проекта [Green Tree Snakes](https://python-all.ru/3.10/library/ast.html) и всех его участников.232233### Литералы234235#### `class ast.Constant(value)`236237Постоянное значение. Атрибут `value` литерала `Constant` содержит объект Python, который он представляет. Представленные значения могут быть простыми типами, такими как число, строка или `None`, а также неизменяемыми контейнерными типами (кортежами и замороженными множествами), если все их элементы постоянны.238239```pycon240>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))241Expression(242 body=Constant(value=123))243```244245#### `class ast.FormattedValue(value, conversion, format_spec)`246247Узел, представляющий одно поле форматирования в f-строке. Если строка содержит только одно поле форматирования и больше ничего, узел может быть изолированным; в противном случае он встречается внутри [`JoinedStr`](https://python-all.ru/3.10/library/ast.html#ast.JoinedStr).248249- `value` – это любой узел выражения (например, литерал, переменная или вызов функции).250- `conversion` – целое число:251252 - -1: без форматирования253 - 115: `!s` форматирование строк254 - 114: `!r` форматирование repr255 - 97: `!a` форматирование ascii256- `format_spec` – узел [`JoinedStr`](https://python-all.ru/3.10/library/ast.html#ast.JoinedStr), представляющий форматирование значения, или `None`, если формат не указан. `conversion` и `format_spec` могут быть установлены одновременно.257258#### `class ast.JoinedStr(values)`259260F-строка, содержащая последовательность [`FormattedValue`](https://python-all.ru/3.10/library/ast.html#ast.FormattedValue) и [`Constant`](https://python-all.ru/3.10/library/ast.html#ast.Constant) узлов.261262```pycon263>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))264Expression(265 body=JoinedStr(266 values=[267 Constant(value='sin('),268 FormattedValue(269 value=Name(id='a', ctx=Load()),270 conversion=-1),271 Constant(value=') is '),272 FormattedValue(273 value=Call(274 func=Name(id='sin', ctx=Load()),275 args=[276 Name(id='a', ctx=Load())],277 keywords=[]),278 conversion=-1,279 format_spec=JoinedStr(280 values=[281 Constant(value='.3')]))]))282```283284#### `class ast.List(elts, ctx)`285286#### `class ast.Tuple(elts, ctx)`287288Список или кортеж. `elts` содержит список узлов, представляющих элементы. `ctx` равен [`Store`](https://python-all.ru/3.10/library/ast.html#ast.Store), если контейнер является целью присваивания (т.е. `(x,y)=something`), и [`Load`](https://python-all.ru/3.10/library/ast.html#ast.Load) в противном случае.289290```pycon291>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))292Expression(293 body=List(294 elts=[295 Constant(value=1),296 Constant(value=2),297 Constant(value=3)],298 ctx=Load()))299>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))300Expression(301 body=Tuple(302 elts=[303 Constant(value=1),304 Constant(value=2),305 Constant(value=3)],306 ctx=Load()))307```308309#### `class ast.Set(elts)`310311Множество. `elts` содержит список узлов, представляющих элементы множества.312313```pycon314>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))315Expression(316 body=Set(317 elts=[318 Constant(value=1),319 Constant(value=2),320 Constant(value=3)]))321```322323#### `class ast.Dict(keys, values)`324325Словарь. `keys` и `values` содержат списки узлов, представляющих ключи и значения соответственно, в соответствующем порядке (то, что было бы возвращено при вызове `dictionary.keys()` и `dictionary.values()`).326327При распаковке словаря с помощью литералов словаря выражение, которое нужно раскрыть, помещается в список `values`, а `None` – на соответствующую позицию в `keys`.328329```pycon330>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))331Expression(332 body=Dict(333 keys=[334 Constant(value='a'),335 None],336 values=[337 Constant(value=1),338 Name(id='d', ctx=Load())]))339```340341### Переменные342343#### `class ast.Name(id, ctx)`344345Имя переменной. `id` содержит имя в виде строки, а `ctx` – один из следующих типов.346347#### `class ast.Load`348349#### `class ast.Store`350351#### `class ast.Del`352353Ссылки на переменные можно использовать для загрузки значения переменной, для присваивания ей нового значения или для её удаления. Ссылки на переменные получают контекст, чтобы различать эти случаи.354355```pycon356>>> print(ast.dump(ast.parse('a'), indent=4))357Module(358 body=[359 Expr(360 value=Name(id='a', ctx=Load()))],361 type_ignores=[])362363>>> print(ast.dump(ast.parse('a = 1'), indent=4))364Module(365 body=[366 Assign(367 targets=[368 Name(id='a', ctx=Store())],369 value=Constant(value=1))],370 type_ignores=[])371372>>> print(ast.dump(ast.parse('del a'), indent=4))373Module(374 body=[375 Delete(376 targets=[377 Name(id='a', ctx=Del())])],378 type_ignores=[])379```380381#### `class ast.Starred(value, ctx)`382383Ссылка на переменную `*var`. В `value` хранится переменная, обычно узел [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name). Этот тип необходимо использовать при построении узла [`Call`](https://python-all.ru/3.10/library/ast.html#ast.Call) с помощью `*args`.384385```pycon386>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))387Module(388 body=[389 Assign(390 targets=[391 Tuple(392 elts=[393 Name(id='a', ctx=Store()),394 Starred(395 value=Name(id='b', ctx=Store()),396 ctx=Store())],397 ctx=Store())],398 value=Name(id='it', ctx=Load()))],399 type_ignores=[])400```401402### Выражения403404#### `class ast.Expr(value)`405406Когда выражение, например вызов функции, выступает в роли самостоятельного оператора и его возвращаемое значение не используется и не сохраняется, оно помещается в этот контейнер. `value` содержит один из остальных узлов этого раздела: узел [`Constant`](https://python-all.ru/3.10/library/ast.html#ast.Constant), узел [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name), [`Lambda`](https://python-all.ru/3.10/library/ast.html#ast.Lambda), [`Yield`](https://python-all.ru/3.10/library/ast.html#ast.Yield) или [`YieldFrom`](https://python-all.ru/3.10/library/ast.html#ast.YieldFrom).407408```pycon409>>> print(ast.dump(ast.parse('-a'), indent=4))410Module(411 body=[412 Expr(413 value=UnaryOp(414 op=USub(),415 operand=Name(id='a', ctx=Load())))],416 type_ignores=[])417```418419#### `class ast.UnaryOp(op, operand)`420421Унарная операция. `op` – оператор, а `operand` – любой узел выражения.422423#### `class ast.UAdd`424425#### `class ast.USub`426427#### `class ast.Not`428429#### `class ast.Invert`430431Токены унарных операторов. [`Not`](https://python-all.ru/3.10/library/ast.html#ast.Not) – ключевое слово `not`, [`Invert`](https://python-all.ru/3.10/library/ast.html#ast.Invert) – оператор `~`.432433```pycon434>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))435Expression(436 body=UnaryOp(437 op=Not(),438 operand=Name(id='x', ctx=Load())))439```440441#### `class ast.BinOp(left, op, right)`442443Бинарная операция (например, сложение или деление). `op` – оператор, а `left` и `right` – любые узлы выражений.444445```pycon446>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))447Expression(448 body=BinOp(449 left=Name(id='x', ctx=Load()),450 op=Add(),451 right=Name(id='y', ctx=Load())))452```453454#### `class ast.Add`455456#### `class ast.Sub`457458#### `class ast.Mult`459460#### `class ast.Div`461462#### `class ast.FloorDiv`463464#### `class ast.Mod`465466#### `class ast.Pow`467468#### `class ast.LShift`469470#### `class ast.RShift`471472#### `class ast.BitOr`473474#### `class ast.BitXor`475476#### `class ast.BitAnd`477478#### `class ast.MatMult`479480Токены бинарных операторов.481482#### `class ast.BoolOp(op, values)`483484Логическая операция – 'or' или 'and'. `op` – это [`Or`](https://python-all.ru/3.10/library/ast.html#ast.Or) или [`And`](https://python-all.ru/3.10/library/ast.html#ast.And). `values` – участвующие значения. Последовательные операции с одним и тем же оператором, например `a or b or c`, сводятся в один узел с несколькими значениями.485486Это не включает `not`, который является [`UnaryOp`](https://python-all.ru/3.10/library/ast.html#ast.UnaryOp).487488```pycon489>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))490Expression(491 body=BoolOp(492 op=Or(),493 values=[494 Name(id='x', ctx=Load()),495 Name(id='y', ctx=Load())]))496```497498#### `class ast.And`499500#### `class ast.Or`501502Токены логических операторов.503504#### `class ast.Compare(left, ops, comparators)`505506Сравнение двух или более значений. `left` – первое значение в сравнении, `ops` – список операторов, а `comparators` – список значений после первого элемента сравнения.507508```pycon509>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))510Expression(511 body=Compare(512 left=Constant(value=1),513 ops=[514 LtE(),515 Lt()],516 comparators=[517 Name(id='a', ctx=Load()),518 Constant(value=10)]))519```520521#### `class ast.Eq`522523#### `class ast.NotEq`524525#### `class ast.Lt`526527#### `class ast.LtE`528529#### `class ast.Gt`530531#### `class ast.GtE`532533#### `class ast.Is`534535#### `class ast.IsNot`536537#### `class ast.In`538539#### `class ast.NotIn`540541Токены операторов сравнения.542543#### `class ast.Call(func, args, keywords, starargs, kwargs)`544545Вызов функции. `func` – это функция; обычно это объект [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name) или [`Attribute`](https://python-all.ru/3.10/library/ast.html#ast.Attribute). Об аргументах:546547- `args` содержит список аргументов, переданных по позиции.548- `keywords` содержит список объектов [`keyword`](https://python-all.ru/3.10/library/keyword.html#module-keyword), представляющих аргументы, переданные по ключевому слову.549550При создании узла `Call`, `args` и `keywords` обязательны, но они могут быть пустыми списками. `starargs` и `kwargs` необязательны.551552```pycon553>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))554Expression(555 body=Call(556 func=Name(id='func', ctx=Load()),557 args=[558 Name(id='a', ctx=Load()),559 Starred(560 value=Name(id='d', ctx=Load()),561 ctx=Load())],562 keywords=[563 keyword(564 arg='b',565 value=Name(id='c', ctx=Load())),566 keyword(567 value=Name(id='e', ctx=Load()))]))568```569570#### `class ast.keyword(arg, value)`571572Именованный аргумент вызова функции или определения класса. `arg` – это необработанная строка с именем параметра, `value` – узел, который нужно передать.573574#### `class ast.IfExp(test, body, orelse)`575576Выражение, например `a if b else c`. Каждое поле содержит один узел, поэтому в следующем примере все три являются узлами [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name).577578```pycon579>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))580Expression(581 body=IfExp(582 test=Name(id='b', ctx=Load()),583 body=Name(id='a', ctx=Load()),584 orelse=Name(id='c', ctx=Load())))585```586587#### `class ast.Attribute(value, attr, ctx)`588589Доступ к атрибуту, например `d.keys`. `value` – это узел, обычно [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name). `attr` – это строка с именем атрибута, а `ctx` – [`Load`](https://python-all.ru/3.10/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.10/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.10/library/ast.html#ast.Del) в зависимости от того, как используется атрибут.590591```pycon592>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))593Expression(594 body=Attribute(595 value=Name(id='snake', ctx=Load()),596 attr='colour',597 ctx=Load()))598```599600#### `class ast.NamedExpr(target, value)`601602> Именованное выражение. Этот узел AST создаётся оператором присваивания (также известным как оператор «морж»). В отличие от узла [`Assign`](https://python-all.ru/3.10/library/ast.html#ast.Assign), где первый аргумент может быть несколькими узлами, в данном случае и `target`, и `value` должны быть одиночными узлами.603604```pycon605>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))606Expression(607 body=NamedExpr(608 target=Name(id='x', ctx=Store()),609 value=Constant(value=4)))610```611612#### Индексирование613614#### `class ast.Subscript(value, slice, ctx)`615616Индексация, такая как `l[1]`. `value` – индексируемый объект (обычно последовательность или отображение). `slice` – это индекс, срез или ключ. Оно может быть [`Tuple`](https://python-all.ru/3.10/library/ast.html#ast.Tuple) и содержать [`Slice`](https://python-all.ru/3.10/library/ast.html#ast.Slice). `ctx` является [`Load`](https://python-all.ru/3.10/library/ast.html#ast.Load), [`Store`](https://python-all.ru/3.10/library/ast.html#ast.Store) или [`Del`](https://python-all.ru/3.10/library/ast.html#ast.Del) в зависимости от выполняемого действия при индексации.617618```pycon619>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))620Expression(621 body=Subscript(622 value=Name(id='l', ctx=Load()),623 slice=Tuple(624 elts=[625 Slice(626 lower=Constant(value=1),627 upper=Constant(value=2)),628 Constant(value=3)],629 ctx=Load()),630 ctx=Load()))631```632633#### `class ast.Slice(lower, upper, step)`634635Обычный срез (в виде `lower:upper` или `lower:upper:step`). Может встречаться только внутри поля *slice* узла [`Subscript`](https://python-all.ru/3.10/library/ast.html#ast.Subscript), либо напрямую, либо как элемент [`Tuple`](https://python-all.ru/3.10/library/ast.html#ast.Tuple).636637```pycon638>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))639Expression(640 body=Subscript(641 value=Name(id='l', ctx=Load()),642 slice=Slice(643 lower=Constant(value=1),644 upper=Constant(value=2)),645 ctx=Load()))646```647648#### Генераторы коллекций649650#### `class ast.ListComp(elt, generators)`651652#### `class ast.SetComp(elt, generators)`653654#### `class ast.GeneratorExp(elt, generators)`655656#### `class ast.DictComp(key, value, generators)`657658Генераторы списков и множеств, генераторные выражения и генераторы словарей. `elt` (или `key` и `value`) – это один узел, представляющий часть, которая будет вычисляться для каждого элемента.659660`generators` – это список узлов [`comprehension`](https://python-all.ru/3.10/library/ast.html#ast.comprehension).661662```pycon663>>> print(ast.dump(ast.parse('[x for x in numbers]', mode='eval'), indent=4))664Expression(665 body=ListComp(666 elt=Name(id='x', ctx=Load()),667 generators=[668 comprehension(669 target=Name(id='x', ctx=Store()),670 iter=Name(id='numbers', ctx=Load()),671 ifs=[],672 is_async=0)]))673>>> print(ast.dump(ast.parse('{x: x**2 for x in numbers}', mode='eval'), indent=4))674Expression(675 body=DictComp(676 key=Name(id='x', ctx=Load()),677 value=BinOp(678 left=Name(id='x', ctx=Load()),679 op=Pow(),680 right=Constant(value=2)),681 generators=[682 comprehension(683 target=Name(id='x', ctx=Store()),684 iter=Name(id='numbers', ctx=Load()),685 ifs=[],686 is_async=0)]))687>>> print(ast.dump(ast.parse('{x for x in numbers}', mode='eval'), indent=4))688Expression(689 body=SetComp(690 elt=Name(id='x', ctx=Load()),691 generators=[692 comprehension(693 target=Name(id='x', ctx=Store()),694 iter=Name(id='numbers', ctx=Load()),695 ifs=[],696 is_async=0)]))697```698699#### `class ast.comprehension(target, iter, ifs, is_async)`700701Одно предложение `for` в генераторе коллекции. `target` – это ссылка, используемая для каждого элемента (обычно узел [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name) или [`Tuple`](https://python-all.ru/3.10/library/ast.html#ast.Tuple)). `iter` – объект, по которому выполняется итерация. `ifs` – список проверочных выражений: каждое предложение `for` может содержать несколько `ifs`.702703`is_async` указывает, что генератор коллекции является асинхронным (использует `async for` вместо `for`). Значение – целое число (0 или 1).704705```pycon706>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),707... indent=4)) # несколько включений в одном708Expression(709 body=ListComp(710 elt=Call(711 func=Name(id='ord', ctx=Load()),712 args=[713 Name(id='c', ctx=Load())],714 keywords=[]),715 generators=[716 comprehension(717 target=Name(id='line', ctx=Store()),718 iter=Name(id='file', ctx=Load()),719 ifs=[],720 is_async=0),721 comprehension(722 target=Name(id='c', ctx=Store()),723 iter=Name(id='line', ctx=Load()),724 ifs=[],725 is_async=0)]))726727>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),728... indent=4)) # выражение-генератор729Expression(730 body=GeneratorExp(731 elt=BinOp(732 left=Name(id='n', ctx=Load()),733 op=Pow(),734 right=Constant(value=2)),735 generators=[736 comprehension(737 target=Name(id='n', ctx=Store()),738 iter=Name(id='it', ctx=Load()),739 ifs=[740 Compare(741 left=Name(id='n', ctx=Load()),742 ops=[743 Gt()],744 comparators=[745 Constant(value=5)]),746 Compare(747 left=Name(id='n', ctx=Load()),748 ops=[749 Lt()],750 comparators=[751 Constant(value=10)])],752 is_async=0)]))753754>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),755... indent=4)) # асинхронное включение756Expression(757 body=ListComp(758 elt=Name(id='i', ctx=Load()),759 generators=[760 comprehension(761 target=Name(id='i', ctx=Store()),762 iter=Name(id='soc', ctx=Load()),763 ifs=[],764 is_async=1)]))765```766767### Инструкции768769#### `class ast.Assign(targets, value, type_comment)`770771Присваивание. `targets` – список узлов, а `value` – один узел.772773Несколько узлов в `targets` обозначают присваивание одного и того же значения каждому. Распаковка представляется помещением узла [`Tuple`](https://python-all.ru/3.10/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.10/library/ast.html#ast.List) внутрь `targets`.774775#### `type_comment`776777`type_comment` – это необязательная строка с аннотацией типа в виде комментария.778779```pycon780>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # множественное присваивание781Module(782 body=[783 Assign(784 targets=[785 Name(id='a', ctx=Store()),786 Name(id='b', ctx=Store())],787 value=Constant(value=1))],788 type_ignores=[])789790>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # распаковка791Module(792 body=[793 Assign(794 targets=[795 Tuple(796 elts=[797 Name(id='a', ctx=Store()),798 Name(id='b', ctx=Store())],799 ctx=Store())],800 value=Name(id='c', ctx=Load()))],801 type_ignores=[])802```803804#### `class ast.AnnAssign(target, annotation, value, simple)`805806Присваивание с аннотацией типа. `target` – это один узел, которым может быть [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.10/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.10/library/ast.html#ast.Subscript). `annotation` – это аннотация, например узел [`Constant`](https://python-all.ru/3.10/library/ast.html#ast.Constant) или [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name). `value` – единственный необязательный узел. `simple` – целое число-флаг, равное True для узла [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name) в `target`, которые не появляются в круглых скобках и поэтому являются чистыми именами, а не выражениями.807808```pycon809>>> print(ast.dump(ast.parse('c: int'), indent=4))810Module(811 body=[812 AnnAssign(813 target=Name(id='c', ctx=Store()),814 annotation=Name(id='int', ctx=Load()),815 simple=1)],816 type_ignores=[])817818>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # аннотация со скобками819Module(820 body=[821 AnnAssign(822 target=Name(id='a', ctx=Store()),823 annotation=Name(id='int', ctx=Load()),824 value=Constant(value=1),825 simple=0)],826 type_ignores=[])827828>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # аннотация атрибута829Module(830 body=[831 AnnAssign(832 target=Attribute(833 value=Name(id='a', ctx=Load()),834 attr='b',835 ctx=Store()),836 annotation=Name(id='int', ctx=Load()),837 simple=0)],838 type_ignores=[])839840>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # аннотация подписки841Module(842 body=[843 AnnAssign(844 target=Subscript(845 value=Name(id='a', ctx=Load()),846 slice=Constant(value=1),847 ctx=Store()),848 annotation=Name(id='int', ctx=Load()),849 simple=0)],850 type_ignores=[])851```852853#### `class ast.AugAssign(target, op, value)`854855Расширенное присваивание, например `a += 1`. В следующем примере `target` – это узел [Имя](https://python-all.ru/3.10/library/ast.html#ast.Name) для `x` (с контекстом [`Store`](https://python-all.ru/3.10/library/ast.html#ast.Store)), `op` – это [Сложение](https://python-all.ru/3.10/library/ast.html#ast.Add), а `value` – это [Константа](https://python-all.ru/3.10/library/ast.html#ast.Constant) со значением 1.856857Атрибут `target` не может быть класса [`Tuple`](https://python-all.ru/3.10/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.10/library/ast.html#ast.List), в отличие от целей [`Assign`](https://python-all.ru/3.10/library/ast.html#ast.Assign).858859```pycon860>>> print(ast.dump(ast.parse('x += 2'), indent=4))861Module(862 body=[863 AugAssign(864 target=Name(id='x', ctx=Store()),865 op=Add(),866 value=Constant(value=2))],867 type_ignores=[])868```869870#### `class ast.Raise(exc, cause)`871872Инструкция `raise`. `exc` – объект исключения, который необходимо возбудить, обычно [Вызов](https://python-all.ru/3.10/library/ast.html#ast.Call) или [Имя](https://python-all.ru/3.10/library/ast.html#ast.Name), или `None` для отдельного `raise`. `cause` – необязательная часть для `y` в `Возбуждение`.873874```pycon875>>> print(ast.dump(ast.parse('raise x from y'), indent=4))876Module(877 body=[878 Raise(879 exc=Name(id='x', ctx=Load()),880 cause=Name(id='y', ctx=Load()))],881 type_ignores=[])882```883884#### `class ast.Assert(test, msg)`885886Утверждение. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.10/library/ast.html#ast.Compare). `msg` содержит сообщение об ошибке.887888```pycon889>>> print(ast.dump(ast.parse('assert x,y'), indent=4))890Module(891 body=[892 Assert(893 test=Name(id='x', ctx=Load()),894 msg=Name(id='y', ctx=Load()))],895 type_ignores=[])896```897898#### `class ast.Delete(targets)`899900Представляет инструкцию `del`. `targets` – список узлов, например узлов [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name), [`Attribute`](https://python-all.ru/3.10/library/ast.html#ast.Attribute) или [`Subscript`](https://python-all.ru/3.10/library/ast.html#ast.Subscript).901902```pycon903>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))904Module(905 body=[906 Delete(907 targets=[908 Name(id='x', ctx=Del()),909 Name(id='y', ctx=Del()),910 Name(id='z', ctx=Del())])],911 type_ignores=[])912```913914#### `class ast.Pass`915916Инструкция `pass`.917918```pycon919>>> print(ast.dump(ast.parse('pass'), indent=4))920Module(921 body=[922 Pass()],923 type_ignores=[])924```925926Другие инструкции, которые применимы только внутри функций или циклов, описаны в других разделах.927928#### Импорты929930#### `class ast.Import(names)`931932Инструкция импорта. `names` – это список узлов [`alias`](https://python-all.ru/3.10/library/ast.html#ast.alias).933934```pycon935>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))936Module(937 body=[938 Import(939 names=[940 alias(name='x'),941 alias(name='y'),942 alias(name='z')])],943 type_ignores=[])944```945946#### `class ast.ImportFrom(module, names, level)`947948Представляет `from x import y`. `module` – это необработанная строка имени from, без начальных точек, или `None` для инструкций вроде `from . import foo`. `level` – целое число, указывающее уровень относительного импорта (0 означает абсолютный импорт).949950```pycon951>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))952Module(953 body=[954 ImportFrom(955 module='y',956 names=[957 alias(name='x'),958 alias(name='y'),959 alias(name='z')],960 level=0)],961 type_ignores=[])962```963964#### `class ast.alias(name, asname)`965966Оба параметра – необработанные строки имён. `asname` может быть `None`, если должно использоваться обычное имя.967968```pycon969>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))970Module(971 body=[972 ImportFrom(973 module='foo.bar',974 names=[975 alias(name='a', asname='b'),976 alias(name='c')],977 level=2)],978 type_ignores=[])979```980981### Управление потоком982983> **Примечание**984>985> Необязательные предложения, такие как `else`, сохраняются как пустой список, если они отсутствуют.986987#### `class ast.If(test, body, orelse)`988989Инструкция `if`. `test` содержит один узел, например узел [`Compare`](https://python-all.ru/3.10/library/ast.html#ast.Compare). `body` и `orelse` содержат по списку узлов.990991Предложения `elif` не имеют специального представления в AST, а появляются как дополнительные узлы [`If`](https://python-all.ru/3.10/library/ast.html#ast.If) в разделе `orelse` предыдущего.992993```pycon994>>> print(ast.dump(ast.parse("""995... if x:996... ...997... elif y:998... ...999... else:1000... ...1001... """), indent=4))1002Module(1003 body=[1004 If(1005 test=Name(id='x', ctx=Load()),1006 body=[1007 Expr(1008 value=Constant(value=Ellipsis))],1009 orelse=[1010 If(1011 test=Name(id='y', ctx=Load()),1012 body=[1013 Expr(1014 value=Constant(value=Ellipsis))],1015 orelse=[1016 Expr(1017 value=Constant(value=Ellipsis))])])],1018 type_ignores=[])1019```10201021#### `class ast.For(target, iter, body, orelse, type_comment)`10221023Цикл `for`. `target` содержит переменную (или переменные), которой присваивает цикл, в виде одного узла [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.10/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.10/library/ast.html#ast.List). `iter` содержит элемент, по которому выполняется итерация, также в виде одного узла. `body` и `orelse` содержат списки узлов для выполнения. Узлы в `orelse` выполняются, если цикл завершается нормально, а не через оператор `break`.10241025#### `type_comment`10261027`type_comment` – это необязательная строка с аннотацией типа в виде комментария.10281029```pycon1030>>> print(ast.dump(ast.parse("""1031... for x in y:1032... ...1033... else:1034... ...1035... """), indent=4))1036Module(1037 body=[1038 For(1039 target=Name(id='x', ctx=Store()),1040 iter=Name(id='y', ctx=Load()),1041 body=[1042 Expr(1043 value=Constant(value=Ellipsis))],1044 orelse=[1045 Expr(1046 value=Constant(value=Ellipsis))])],1047 type_ignores=[])1048```10491050#### `class ast.While(test, body, orelse)`10511052Цикл `while`. `test` содержит условие, например узел [`Compare`](https://python-all.ru/3.10/library/ast.html#ast.Compare).10531054```pycon1055>> print(ast.dump(ast.parse("""1056... while x:1057... ...1058... else:1059... ...1060... """), indent=4))1061Module(1062 body=[1063 While(1064 test=Name(id='x', ctx=Load()),1065 body=[1066 Expr(1067 value=Constant(value=Ellipsis))],1068 orelse=[1069 Expr(1070 value=Constant(value=Ellipsis))])],1071 type_ignores=[])1072```10731074#### `class ast.Break`10751076#### `class ast.Continue`10771078Инструкции `break` и `continue`.10791080```pycon1081>>> print(ast.dump(ast.parse("""\1082... for a in b:1083... if a > 5:1084... break1085... else:1086... continue1087...1088... """), indent=4))1089Module(1090 body=[1091 For(1092 target=Name(id='a', ctx=Store()),1093 iter=Name(id='b', ctx=Load()),1094 body=[1095 If(1096 test=Compare(1097 left=Name(id='a', ctx=Load()),1098 ops=[1099 Gt()],1100 comparators=[1101 Constant(value=5)]),1102 body=[1103 Break()],1104 orelse=[1105 Continue()])],1106 orelse=[])],1107 type_ignores=[])1108```11091110#### `class ast.Try(body, handlers, orelse, finalbody)`11111112Блоки `try`. Все атрибуты – списки узлов для выполнения, за исключением `handlers`, который является списком узлов [`ExceptHandler`](https://python-all.ru/3.10/library/ast.html#ast.ExceptHandler).11131114```pycon1115>>> print(ast.dump(ast.parse("""1116... try:1117... ...1118... except Exception:1119... ...1120... except OtherException as e:1121... ...1122... else:1123... ...1124... finally:1125... ...1126... """), indent=4))1127Module(1128 body=[1129 Try(1130 body=[1131 Expr(1132 value=Constant(value=Ellipsis))],1133 handlers=[1134 ExceptHandler(1135 type=Name(id='Exception', ctx=Load()),1136 body=[1137 Expr(1138 value=Constant(value=Ellipsis))]),1139 ExceptHandler(1140 type=Name(id='OtherException', ctx=Load()),1141 name='e',1142 body=[1143 Expr(1144 value=Constant(value=Ellipsis))])],1145 orelse=[1146 Expr(1147 value=Constant(value=Ellipsis))],1148 finalbody=[1149 Expr(1150 value=Constant(value=Ellipsis))])],1151 type_ignores=[])1152```11531154#### `class ast.ExceptHandler(type, name, body)`11551156Одно предложение `except`. `type` – тип исключения, который оно перехватывает, обычно узел [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name) (или `None` для универсального предложения `except:`). `name` – необработанная строка для имени, в котором будет сохранено исключение, или `None`, если в предложении нет `as foo`. `body` – список узлов.11571158```pycon1159>>> print(ast.dump(ast.parse("""\1160... try:1161... a + 11162... except TypeError:1163... pass1164... """), indent=4))1165Module(1166 body=[1167 Try(1168 body=[1169 Expr(1170 value=BinOp(1171 left=Name(id='a', ctx=Load()),1172 op=Add(),1173 right=Constant(value=1)))],1174 handlers=[1175 ExceptHandler(1176 type=Name(id='TypeError', ctx=Load()),1177 body=[1178 Pass()])],1179 orelse=[],1180 finalbody=[])],1181 type_ignores=[])1182```11831184#### `class ast.With(items, body, type_comment)`11851186Блок `with`. `items` – это список узлов [`withitem`](https://python-all.ru/3.10/library/ast.html#ast.withitem), представляющих менеджеры контекста, а `body` – это блок с отступом внутри контекста.11871188#### `type_comment`11891190`type_comment` – это необязательная строка с аннотацией типа в виде комментария.11911192#### `class ast.withitem(context_expr, optional_vars)`11931194Один менеджер контекста в блоке `with`. `context_expr` – это менеджер контекста, часто узел [`Call`](https://python-all.ru/3.10/library/ast.html#ast.Call). `optional_vars` – это [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name), [`Tuple`](https://python-all.ru/3.10/library/ast.html#ast.Tuple) или [`List`](https://python-all.ru/3.10/library/ast.html#ast.List) для части `as foo`, или `None`, если она не используется.11951196```pycon1197>>> print(ast.dump(ast.parse("""\1198... with a as b, c as d:1199... something(b, d)1200... """), indent=4))1201Module(1202 body=[1203 With(1204 items=[1205 withitem(1206 context_expr=Name(id='a', ctx=Load()),1207 optional_vars=Name(id='b', ctx=Store())),1208 withitem(1209 context_expr=Name(id='c', ctx=Load()),1210 optional_vars=Name(id='d', ctx=Store()))],1211 body=[1212 Expr(1213 value=Call(1214 func=Name(id='something', ctx=Load()),1215 args=[1216 Name(id='b', ctx=Load()),1217 Name(id='d', ctx=Load())],1218 keywords=[]))])],1219 type_ignores=[])1220```12211222### Сопоставление с образцом12231224#### `class ast.Match(subject, cases)`12251226Оператор `match`. В `subject` хранится subject сопоставления (объект, который сравнивается с вариантами), а `cases` содержит итерируемый набор узлов [`match_case`](https://python-all.ru/3.10/library/ast.html#ast.match_case) с различными вариантами.12271228#### `class ast.match_case(pattern, guard, body)`12291230Один вариант (case) в операторе `match`. `pattern` содержит шаблон сопоставления, с которым будет сравниваться subject. Обратите внимание, что узлы [`AST`](https://python-all.ru/3.10/library/ast.html#ast.AST), создаваемые для шаблонов, отличаются от узлов, создаваемых для выражений, даже при одинаковом синтаксисе.12311232Атрибут `guard` содержит выражение, которое будет вычислено, если шаблон совпадает с subject.12331234`body` содержит список узлов, которые выполняются, если шаблон совпадает и результат вычисления guard-выражения истинен.12351236```pycon1237>>> print(ast.dump(ast.parse("""1238... match x:1239... case [x] if x>0:1240... ...1241... case tuple():1242... ...1243... """), indent=4))1244Module(1245 body=[1246 Match(1247 subject=Name(id='x', ctx=Load()),1248 cases=[1249 match_case(1250 pattern=MatchSequence(1251 patterns=[1252 MatchAs(name='x')]),1253 guard=Compare(1254 left=Name(id='x', ctx=Load()),1255 ops=[1256 Gt()],1257 comparators=[1258 Constant(value=0)]),1259 body=[1260 Expr(1261 value=Constant(value=Ellipsis))]),1262 match_case(1263 pattern=MatchClass(1264 cls=Name(id='tuple', ctx=Load()),1265 patterns=[],1266 kwd_attrs=[],1267 kwd_patterns=[]),1268 body=[1269 Expr(1270 value=Constant(value=Ellipsis))])])],1271 type_ignores=[])1272```12731274#### `class ast.MatchValue(value)`12751276Сопоставление с литералом или шаблоном значения, сравниваемым по равенству. `value` – это узел выражения. Допустимые узлы значений ограничены, как описано в документации оператора match. Этот шаблон успешно срабатывает, если subject сопоставления равен вычисленному значению.12771278```pycon1279>>> print(ast.dump(ast.parse("""1280... match x:1281... case "Relevant":1282... ...1283... """), indent=4))1284Module(1285 body=[1286 Match(1287 subject=Name(id='x', ctx=Load()),1288 cases=[1289 match_case(1290 pattern=MatchValue(1291 value=Constant(value='Relevant')),1292 body=[1293 Expr(1294 value=Constant(value=Ellipsis))])])],1295 type_ignores=[])1296```12971298#### `class ast.MatchSingleton(value)`12991300Сопоставление с литералом, сравниваемым по идентичности. `value` – это синглтон, с которым производится сравнение: `None`, `True` или `False`. Этот шаблон успешно срабатывает, если subject сопоставления является заданной константой.13011302```pycon1303>>> print(ast.dump(ast.parse("""1304... match x:1305... case None:1306... ...1307... """), indent=4))1308Module(1309 body=[1310 Match(1311 subject=Name(id='x', ctx=Load()),1312 cases=[1313 match_case(1314 pattern=MatchSingleton(value=None),1315 body=[1316 Expr(1317 value=Constant(value=Ellipsis))])])],1318 type_ignores=[])1319```13201321#### `class ast.MatchSequence(patterns)`13221323Шаблон последовательности (sequence pattern) в match. `patterns` содержит шаблоны, которые будут сопоставляться с элементами subject, если subject является последовательностью. Сопоставляется с последовательностью переменной длины, если один из подшаблонов является узлом `MatchStar`, в противном случае сопоставляется с последовательностью фиксированной длины.13241325```pycon1326>>> print(ast.dump(ast.parse("""1327... match x:1328... case [1, 2]:1329... ...1330... """), indent=4))1331Module(1332 body=[1333 Match(1334 subject=Name(id='x', ctx=Load()),1335 cases=[1336 match_case(1337 pattern=MatchSequence(1338 patterns=[1339 MatchValue(1340 value=Constant(value=1)),1341 MatchValue(1342 value=Constant(value=2))]),1343 body=[1344 Expr(1345 value=Constant(value=Ellipsis))])])],1346 type_ignores=[])1347```13481349#### `class ast.MatchStar(name)`13501351Сопоставляется с остатком последовательности в шаблоне последовательности переменной длины. Если `name` не равно `None`, то при успешном сопоставлении всего шаблона последовательности этому имени привязывается список, содержащий оставшиеся элементы последовательности.13521353```pycon1354>>> print(ast.dump(ast.parse("""1355... match x:1356... case [1, 2, *rest]:1357... ...1358... case [*_]:1359... ...1360... """), indent=4))1361Module(1362 body=[1363 Match(1364 subject=Name(id='x', ctx=Load()),1365 cases=[1366 match_case(1367 pattern=MatchSequence(1368 patterns=[1369 MatchValue(1370 value=Constant(value=1)),1371 MatchValue(1372 value=Constant(value=2)),1373 MatchStar(name='rest')]),1374 body=[1375 Expr(1376 value=Constant(value=Ellipsis))]),1377 match_case(1378 pattern=MatchSequence(1379 patterns=[1380 MatchStar()]),1381 body=[1382 Expr(1383 value=Constant(value=Ellipsis))])])],1384 type_ignores=[])1385```13861387#### `class ast.MatchMapping(keys, patterns, rest)`13881389Шаблон отображения (mapping pattern) в match. `keys` – последовательность узлов выражений. `patterns` – соответствующая последовательность узлов шаблонов. `rest` – необязательное имя, которое можно указать для захвата оставшихся элементов отображения. Допустимые ключевые выражения ограничены, как описано в документации оператора match.13901391Этот шаблон успешно срабатывает, если subject является отображением, все вычисленные ключевые выражения присутствуют в отображении, а значение, соответствующее каждому ключу, совпадает с соответствующим подшаблоном. Если `rest` не равно `None`, то при успешном сопоставлении всего шаблона отображения этому имени привязывается словарь, содержащий оставшиеся элементы отображения.13921393```pycon1394>>> print(ast.dump(ast.parse("""1395... match x:1396... case {1: _, 2: _}:1397... ...1398... case {**rest}:1399... ...1400... """), indent=4))1401Module(1402 body=[1403 Match(1404 subject=Name(id='x', ctx=Load()),1405 cases=[1406 match_case(1407 pattern=MatchMapping(1408 keys=[1409 Constant(value=1),1410 Constant(value=2)],1411 patterns=[1412 MatchAs(),1413 MatchAs()]),1414 body=[1415 Expr(1416 value=Constant(value=Ellipsis))]),1417 match_case(1418 pattern=MatchMapping(keys=[], patterns=[], rest='rest'),1419 body=[1420 Expr(1421 value=Constant(value=Ellipsis))])])],1422 type_ignores=[])1423```14241425#### `class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)`14261427Шаблон класса (class pattern) в match. `cls` – выражение, задающее номинальный класс для сопоставления. `patterns` – последовательность узлов шаблонов, которые будут сопоставляться с определённой классом последовательностью атрибутов для сопоставления с образцом. `kwd_attrs` – последовательность дополнительных атрибутов для сопоставления (указанных как ключевые аргументы в шаблоне класса), `kwd_patterns` – соответствующие шаблоны (указанные как значения ключевых слов в шаблоне класса).14281429Этот шаблон успешно срабатывает, если subject является экземпляром указанного класса, все позиционные шаблоны совпадают с соответствующими атрибутами, определёнными классом, и все указанные ключевые атрибуты совпадают со своими шаблонами.14301431Примечание: классы могут определять свойство, возвращающее self, чтобы сопоставлять узел шаблона с сопоставляемым экземпляром. Некоторые встроенные типы также сопоставляются таким образом, как описано в документации оператора match.14321433```pycon1434>>> print(ast.dump(ast.parse("""1435... match x:1436... case Point2D(0, 0):1437... ...1438... case Point3D(x=0, y=0, z=0):1439... ...1440... """), indent=4))1441Module(1442 body=[1443 Match(1444 subject=Name(id='x', ctx=Load()),1445 cases=[1446 match_case(1447 pattern=MatchClass(1448 cls=Name(id='Point2D', ctx=Load()),1449 patterns=[1450 MatchValue(1451 value=Constant(value=0)),1452 MatchValue(1453 value=Constant(value=0))],1454 kwd_attrs=[],1455 kwd_patterns=[]),1456 body=[1457 Expr(1458 value=Constant(value=Ellipsis))]),1459 match_case(1460 pattern=MatchClass(1461 cls=Name(id='Point3D', ctx=Load()),1462 patterns=[],1463 kwd_attrs=[1464 'x',1465 'y',1466 'z'],1467 kwd_patterns=[1468 MatchValue(1469 value=Constant(value=0)),1470 MatchValue(1471 value=Constant(value=0)),1472 MatchValue(1473 value=Constant(value=0))]),1474 body=[1475 Expr(1476 value=Constant(value=Ellipsis))])])],1477 type_ignores=[])1478```14791480#### `class ast.MatchAs(pattern, name)`14811482Сопоставление «as-pattern», шаблон захвата (capture pattern) или шаблон-заменитель (wildcard pattern). `pattern` содержит шаблон match, с которым будет сопоставлен subject. Если шаблон равен `None`, узел представляет собой шаблон захвата (т.е. просто имя) и всегда успешно срабатывает.14831484Атрибут `name` содержит имя, которое будет привязано при успешном сопоставлении шаблона. Если `name` равно `None`, то `pattern` также должно быть `None`, и узел представляет собой шаблон-заменитель (wildcard).14851486```pycon1487>>> print(ast.dump(ast.parse("""1488... match x:1489... case [x] as y:1490... ...1491... case _:1492... ...1493... """), indent=4))1494Module(1495 body=[1496 Match(1497 subject=Name(id='x', ctx=Load()),1498 cases=[1499 match_case(1500 pattern=MatchAs(1501 pattern=MatchSequence(1502 patterns=[1503 MatchAs(name='x')]),1504 name='y'),1505 body=[1506 Expr(1507 value=Constant(value=Ellipsis))]),1508 match_case(1509 pattern=MatchAs(),1510 body=[1511 Expr(1512 value=Constant(value=Ellipsis))])])],1513 type_ignores=[])1514```15151516#### `class ast.MatchOr(patterns)`15171518Сопоставление «or-pattern» (шаблон ИЛИ). Or-pattern последовательно сопоставляет каждый из своих подшаблонов с subject, пока один из них не сработает. Тогда считается, что or-pattern сработал. Если ни один из подшаблонов не сработал, or-pattern не срабатывает. Атрибут `patterns` содержит список узлов шаблонов match, которые будут сопоставляться с subject.15191520```pycon1521>>> print(ast.dump(ast.parse("""1522... match x:1523... case [x] | (y):1524... ...1525... """), indent=4))1526Module(1527 body=[1528 Match(1529 subject=Name(id='x', ctx=Load()),1530 cases=[1531 match_case(1532 pattern=MatchOr(1533 patterns=[1534 MatchSequence(1535 patterns=[1536 MatchAs(name='x')]),1537 MatchAs(name='y')]),1538 body=[1539 Expr(1540 value=Constant(value=Ellipsis))])])],1541 type_ignores=[])1542```15431544### Определения функций и классов15451546#### `class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment)`15471548Определение функции.15491550- `name` – это необработанная строка имени функции.1551- `args` – это узел [`arguments`](https://python-all.ru/3.10/library/ast.html#ast.arguments).1552- `body` – это список узлов внутри функции.1553- `decorator_list` – это список декораторов, которые будут применены; декораторы перечислены от самого внешнего к внутреннему (т.е. первый в списке применяется последним).1554- `returns` – это аннотация возвращаемого значения.15551556#### `type_comment`15571558`type_comment` – это необязательная строка с аннотацией типа в виде комментария.15591560#### `class ast.Lambda(args, body)`15611562`lambda` – это минимальное определение функции, которое можно использовать внутри выражения. В отличие от [`FunctionDef`](https://python-all.ru/3.10/library/ast.html#ast.FunctionDef), `body` содержит один узел.15631564```pycon1565>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))1566Module(1567 body=[1568 Expr(1569 value=Lambda(1570 args=arguments(1571 posonlyargs=[],1572 args=[1573 arg(arg='x'),1574 arg(arg='y')],1575 kwonlyargs=[],1576 kw_defaults=[],1577 defaults=[]),1578 body=Constant(value=Ellipsis)))],1579 type_ignores=[])1580```15811582#### `class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)`15831584Аргументы функции.15851586- `posonlyargs`, `args` и `kwonlyargs` – это списки узлов [`arg`](https://python-all.ru/3.10/library/ast.html#ast.arg).1587- `vararg` и `kwarg` – это одиночные узлы [`arg`](https://python-all.ru/3.10/library/ast.html#ast.arg), ссылающиеся на параметры `*args, **kwargs`.1588- `kw_defaults` – это список значений по умолчанию для keyword-only аргументов. Если один из них равен `None`, соответствующий аргумент обязателен.1589- `defaults` – это список значений по умолчанию для аргументов, которые можно передавать позиционно. Если значений по умолчанию меньше, они соответствуют последним n аргументам.15901591#### `class ast.arg(arg, annotation, type_comment)`15921593Один аргумент в списке. `arg` – это сырая строка с именем аргумента, `annotation` – это его аннотация, например, узел `Str` или [`Name`](https://python-all.ru/3.10/library/ast.html#ast.Name).15941595#### `type_comment`15961597`type_comment` – это необязательная строка с аннотацией типа в виде комментария15981599```pycon1600>>> print(ast.dump(ast.parse("""\1601... @decorator11602... @decorator21603... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':1604... pass1605... """), indent=4))1606Module(1607 body=[1608 FunctionDef(1609 name='f',1610 args=arguments(1611 posonlyargs=[],1612 args=[1613 arg(1614 arg='a',1615 annotation=Constant(value='annotation')),1616 arg(arg='b'),1617 arg(arg='c')],1618 vararg=arg(arg='d'),1619 kwonlyargs=[1620 arg(arg='e'),1621 arg(arg='f')],1622 kw_defaults=[1623 None,1624 Constant(value=3)],1625 kwarg=arg(arg='g'),1626 defaults=[1627 Constant(value=1),1628 Constant(value=2)]),1629 body=[1630 Pass()],1631 decorator_list=[1632 Name(id='decorator1', ctx=Load()),1633 Name(id='decorator2', ctx=Load())],1634 returns=Constant(value='return annotation'))],1635 type_ignores=[])1636```16371638#### `class ast.Return(value)`16391640Инструкция `return`.16411642```pycon1643>>> print(ast.dump(ast.parse('return 4'), indent=4))1644Module(1645 body=[1646 Return(1647 value=Constant(value=4))],1648 type_ignores=[])1649```16501651#### `class ast.Yield(value)`16521653#### `class ast.YieldFrom(value)`16541655Выражение `yield` или `yield from`. Поскольку это выражения, их необходимо обернуть в узел [`Expr`](https://python-all.ru/3.10/library/ast.html#ast.Expr), если возвращаемое значение не используется.16561657```pycon1658>>> print(ast.dump(ast.parse('yield x'), indent=4))1659Module(1660 body=[1661 Expr(1662 value=Yield(1663 value=Name(id='x', ctx=Load())))],1664 type_ignores=[])16651666>>> print(ast.dump(ast.parse('yield from x'), indent=4))1667Module(1668 body=[1669 Expr(1670 value=YieldFrom(1671 value=Name(id='x', ctx=Load())))],1672 type_ignores=[])1673```16741675#### `class ast.Global(names)`16761677#### `class ast.Nonlocal(names)`16781679Инструкции `global` и `nonlocal`. `names` – это список сырых строк.16801681```pycon1682>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))1683Module(1684 body=[1685 Global(1686 names=[1687 'x',1688 'y',1689 'z'])],1690 type_ignores=[])16911692>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))1693Module(1694 body=[1695 Nonlocal(1696 names=[1697 'x',1698 'y',1699 'z'])],1700 type_ignores=[])1701```17021703#### `class ast.ClassDef(name, bases, keywords, starargs, kwargs, body, decorator_list)`17041705Определение класса.17061707- `name` – это сырая строка с именем класса.1708- `bases` – это список узлов для явно указанных базовых классов.1709- `keywords` – это список узлов [`keyword`](https://python-all.ru/3.10/library/keyword.html#module-keyword), в основном для «metaclass». Остальные ключевые слова будут переданы метаклассу в соответствии с [PEP-3115](https://python-all.ru/3.10/library/ast.html).1710- `starargs` и `kwargs` – каждый является отдельным узлом, как при вызове функции. starargs будет развёрнут для присоединения к списку базовых классов, а kwargs будет передан метаклассу.1711- `body` – это список узлов, представляющих код внутри определения класса.1712- `decorator_list` – это список узлов, как и в [`FunctionDef`](https://python-all.ru/3.10/library/ast.html#ast.FunctionDef).17131714```pycon1715>>> print(ast.dump(ast.parse("""\1716... @decorator11717... @decorator21718... class Foo(base1, base2, metaclass=meta):1719... pass1720... """), indent=4))1721Module(1722 body=[1723 ClassDef(1724 name='Foo',1725 bases=[1726 Name(id='base1', ctx=Load()),1727 Name(id='base2', ctx=Load())],1728 keywords=[1729 keyword(1730 arg='metaclass',1731 value=Name(id='meta', ctx=Load()))],1732 body=[1733 Pass()],1734 decorator_list=[1735 Name(id='decorator1', ctx=Load()),1736 Name(id='decorator2', ctx=Load())])],1737 type_ignores=[])1738```17391740### async и await17411742#### `class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment)`17431744Определение функции `async def`. Имеет те же поля, что и [`FunctionDef`](https://python-all.ru/3.10/library/ast.html#ast.FunctionDef).17451746#### `class ast.Await(value)`17471748Выражение `await`. `value` – это то, чего оно ожидает. Допустимо только в теле [`AsyncFunctionDef`](https://python-all.ru/3.10/library/ast.html#ast.AsyncFunctionDef).17491750```pycon1751>>> print(ast.dump(ast.parse("""\1752... async def f():1753... await other_func()1754... """), indent=4))1755Module(1756 body=[1757 AsyncFunctionDef(1758 name='f',1759 args=arguments(1760 posonlyargs=[],1761 args=[],1762 kwonlyargs=[],1763 kw_defaults=[],1764 defaults=[]),1765 body=[1766 Expr(1767 value=Await(1768 value=Call(1769 func=Name(id='other_func', ctx=Load()),1770 args=[],1771 keywords=[])))],1772 decorator_list=[])],1773 type_ignores=[])1774```17751776#### `class ast.AsyncFor(target, iter, body, orelse, type_comment)`17771778#### `class ast.AsyncWith(items, body, type_comment)`17791780`async for` циклы и `async with` менеджеры контекста. Они имеют те же поля, что [`For`](https://python-all.ru/3.10/library/ast.html#ast.For) и [`With`](https://python-all.ru/3.10/library/ast.html#ast.With), соответственно. Допустимы только в теле [`AsyncFunctionDef`](https://python-all.ru/3.10/library/ast.html#ast.AsyncFunctionDef).17811782> **Примечание**1783>1784> Когда строка разбирается парсером [`ast.parse()`](https://python-all.ru/3.10/library/ast.html#ast.parse), узлы операторов (подклассы `ast.operator`, `ast.unaryop`, `ast.cmpop`, `ast.boolop` и `ast.expr_context`) на возвращаемом дереве являются синглтонами. Изменения в одном будут отражены во всех других вхождениях того же значения (например, [`ast.Add`](https://python-all.ru/3.10/library/ast.html#ast.Add)).17851786## [`ast`](https://python-all.ru/3.10/library/ast.html#module-ast) Вспомогательные функции17871788Помимо классов узлов, модуль [`ast`](https://python-all.ru/3.10/library/ast.html#module-ast) определяет следующие служебные функции и классы для обхода абстрактных синтаксических деревьев:17891790#### `ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None)`17911792Разбирает исходный код в узел AST. Эквивалентно `compile(source, filename, mode, ast.PyCF_ONLY_AST)`.17931794Если задан `type_comments=True`, парсер изменяется, чтобы проверять и возвращать комментарии типов, как указано в [**PEP 484**](https://python-all.ru/3.10/library/ast.html) и [**PEP 526**](https://python-all.ru/3.10/library/ast.html). Это эквивалентно добавлению [`ast.PyCF_TYPE_COMMENTS`](https://python-all.ru/3.10/library/ast.html#ast.PyCF_TYPE_COMMENTS) к флагам, передаваемым в [`compile()`](https://python-all.ru/3.10/library/functions.html#compile). Это приведёт к сообщению об ошибках синтаксиса для неправильно расположенных комментариев типов. Без этого флага комментарии типов будут игнорироваться, и поле `type_comment` в выбранных узлах AST всегда будет `None`. Кроме того, расположение комментариев `# type: ignore` будет возвращаться как атрибут `type_ignores` объекта `Module` (иначе это всегда пустой список).17951796Кроме того, если `mode` равно `'func_type'`, синтаксис входных данных изменяется в соответствии с [**PEP 484**](https://python-all.ru/3.10/library/ast.html) «сигнатурными комментариями типов», например `(str, int) -> List[str]`.17971798Также установка `feature_version` в кортеж `(major, minor)` попытается выполнить разбор с использованием грамматики этой версии Python. В настоящее время `major` должно быть равно `3`. Например, установка `feature_version=(3, 4)` разрешит использование `async` и `await` в качестве имён переменных. Минимальная поддерживаемая версия – `(3, 4)`; максимальная – `sys.version_info[0:2]`.17991800Если source содержит нулевой символ (’0’), возбуждается [`ValueError`](https://python-all.ru/3.10/library/exceptions.html#ValueError).18011802> **Предупреждение**1803>1804> Обратите внимание, что успешный разбор исходного кода в объект AST не гарантирует, что предоставленный исходный код является корректным кодом Python, который можно выполнить, поскольку этап компиляции может вызывать дополнительные исключения [`SyntaxError`](https://python-all.ru/3.10/library/exceptions.html#SyntaxError). Например, исходный код `return 42` генерирует корректный узел AST для инструкции return, но его нельзя скомпилировать отдельно (он должен находиться внутри узла функции).1805>1806> В частности, [`ast.parse()`](https://python-all.ru/3.10/library/ast.html#ast.parse) не выполняет никаких проверок областей видимости, которые выполняет этап компиляции.18071808> **Предупреждение**1809>1810> Можно вызвать сбой интерпретатора Python с помощью достаточно большой/сложной строки из-за ограничений глубины стека в компиляторе AST Python.18111812Изменено в версии 3.8: Добавлены `type_comments`, `mode='func_type'` и `feature_version`.18131814#### `ast.unparse(ast_obj)`18151816Выполняет обратный разбор объекта [`ast.AST`](https://python-all.ru/3.10/library/ast.html#ast.AST) и генерирует строку с кодом, который при обратном разборе с помощью [`ast.parse()`](https://python-all.ru/3.10/library/ast.html#ast.parse) даст эквивалентный объект [`ast.AST`](https://python-all.ru/3.10/library/ast.html#ast.AST).18171818> **Предупреждение**1819>1820> Полученная строка кода не обязательно будет равна исходному коду, который породил объект [`ast.AST`](https://python-all.ru/3.10/library/ast.html#ast.AST) (без каких-либо оптимизаций компилятора, таких как константные кортежи/frozensets).18211822> **Предупреждение**1823>1824> Попытка выполнить обратный разбор очень сложного выражения приведёт к [`RecursionError`](https://python-all.ru/3.10/library/exceptions.html#RecursionError).18251826Новое в версии 3.9.18271828#### `ast.literal_eval(node_or_string)`18291830Вычисляет узел выражения или строку, содержащую только литерал Python или отображение контейнера. Предоставленная строка или узел могут состоять только из следующих структур литералов Python: строки, байты, числа, кортежи, списки, словари, множества, булевы значения, `None` и `Ellipsis`.18311832Это можно использовать для вычисления строк, содержащих значения Python, без необходимости разбирать значения самостоятельно. Он не способен вычислять произвольно сложные выражения, например, с операторами или индексацией.18331834Раньше эта функция документировалась как «безопасная» без определения, что это значит. Это вводило в заблуждение. Она специально разработана так, чтобы не выполнять код Python, в отличие от более общей [`eval()`](https://python-all.ru/3.10/library/functions.html#eval). Нет пространства имён, поиска имён или возможности внешних вызовов. Но она не свободна от атак: относительно небольшой ввод может привести к истощению памяти или истощению стека C, что вызовет сбой процесса. Также существует возможность отказа в обслуживании из-за чрезмерного потребления ЦП на некоторых входных данных. Поэтому вызывать её на недоверенных данных не рекомендуется.18351836> **Предупреждение**1837>1838> Можно вызвать сбой интерпретатора Python из-за ограничений глубины стека в компиляторе AST Python.1839>1840> Она может возбуждать [`ValueError`](https://python-all.ru/3.10/library/exceptions.html#ValueError), [`TypeError`](https://python-all.ru/3.10/library/exceptions.html#TypeError), [`SyntaxError`](https://python-all.ru/3.10/library/exceptions.html#SyntaxError), [`MemoryError`](https://python-all.ru/3.10/library/exceptions.html#MemoryError) и [`RecursionError`](https://python-all.ru/3.10/library/exceptions.html#RecursionError) в зависимости от некорректного ввода.18411842Изменено в версии 3.2: Теперь допускает литералы байтов и множеств.18431844Изменено в версии 3.9: Теперь поддерживает создание пустых множеств с помощью `'set()'`.18451846Изменено в версии 3.10: Для строковых входных данных начальные пробелы и табуляции теперь удаляются.18471848#### `ast.get_docstring(node, clean=True)`18491850Возвращает строку документации для данного *узла* (который должен быть узлом [`FunctionDef`](https://python-all.ru/3.10/library/ast.html#ast.FunctionDef), [`AsyncFunctionDef`](https://python-all.ru/3.10/library/ast.html#ast.AsyncFunctionDef), [`ClassDef`](https://python-all.ru/3.10/library/ast.html#ast.ClassDef) или `Module`) или `None`, если у него нет строки документации. Если *clean* истинно, очищает отступы строки документации с помощью [`inspect.cleandoc()`](https://python-all.ru/3.10/library/inspect.html#inspect.cleandoc).18511852Изменено в версии 3.5: Теперь поддерживается [`AsyncFunctionDef`](https://python-all.ru/3.10/library/ast.html#ast.AsyncFunctionDef).18531854#### `ast.get_source_segment(source, node, *, padded=False)`18551856Возвращает фрагмент исходного кода из *source*, который породил узел *node*. Если не хватает информации о местоположении (`lineno`, `end_lineno`, `col_offset` или `end_col_offset`), возвращает `None`.18571858Если *padded* равно `True`, первая строка многострочного оператора будет дополнена пробелами, чтобы соответствовать исходной позиции.18591860Новое в версии 3.8.18611862#### `ast.fix_missing_locations(node)`18631864При компиляции дерева узлов с помощью [`compile()`](https://python-all.ru/3.10/library/functions.html#compile) компилятор ожидает атрибуты `lineno` и `col_offset` для каждого узла, который их поддерживает. Заполнять их вручную для сгенерированных узлов довольно утомительно, поэтому эта вспомогательная функция рекурсивно добавляет эти атрибуты, если их ещё нет, устанавливая их равными значениям родительского узла. Работает рекурсивно, начиная с *node*.18651866#### `ast.increment_lineno(node, n=1)`18671868Увеличивает номер строки и номер конечной строки каждого узла в дереве, начиная с *node*, на *n*. Это полезно для «перемещения кода» в другое место в файле.18691870#### `ast.copy_location(new_node, old_node)`18711872Копирует информацию о местоположении в исходном коде (`lineno`, `col_offset`, `end_lineno` и `end_col_offset`) из *old\_node* в *new\_node*, если это возможно, и возвращает *new\_node*.18731874#### `ast.iter_fields(node)`18751876Генерирует кортеж из `(fieldname, value)` для каждого поля в `node._fields`, которое присутствует в *node*.18771878#### `ast.iter_child_nodes(node)`18791880Генерирует все непосредственные дочерние узлы *node*, то есть все поля, являющиеся узлами, и все элементы полей, являющихся списками узлов.18811882#### `ast.walk(node)`18831884Рекурсивно генерирует все узлы-потомки в дереве, начиная с *node* (включая сам *node*), в произвольном порядке. Это полезно, если требуется только изменить узлы на месте, а контекст не важен.18851886#### `class ast.NodeVisitor`18871888Базовый класс для обхода узлов, который обходит абстрактное синтаксическое дерево и вызывает функцию-посетитель для каждого найденного узла. Эта функция может вернуть значение, которое передаётся методом [`visit()`](https://python-all.ru/3.10/library/ast.html#ast.NodeVisitor.visit).18891890Этот класс предназначен для наследования; в подклассе добавляются методы-посетители.18911892#### `visit(node)`18931894Посещает узел. Реализация по умолчанию вызывает метод `self.visit_classname`, где *classname* – имя класса узла, или [`generic_visit()`](https://python-all.ru/3.10/library/ast.html#ast.NodeVisitor.generic_visit), если такой метод отсутствует.18951896#### `generic_visit(node)`18971898Этот посетитель вызывает [`visit()`](https://python-all.ru/3.10/library/ast.html#ast.NodeVisitor.visit) для всех дочерних узлов.18991900Обратите внимание, что дочерние узлы тех узлов, для которых определён собственный метод-посетитель, не будут посещены, если посетитель сам не вызовет [`generic_visit()`](https://python-all.ru/3.10/library/ast.html#ast.NodeVisitor.generic_visit) или не обойдёт их самостоятельно.19011902Не используйте [`NodeVisitor`](https://python-all.ru/3.10/library/ast.html#ast.NodeVisitor), если требуется вносить изменения в узлы во время обхода. Для этого существует специальный посетитель ([`NodeTransformer`](https://python-all.ru/3.10/library/ast.html#ast.NodeTransformer)), который допускает модификации.19031904Устарело с версии 3.8: Методы `visit_Num()`, `visit_Str()`, `visit_Bytes()`, `visit_NameConstant()` и `visit_Ellipsis()` теперь устарели и не будут вызываться в будущих версиях Python. Добавьте метод `visit_Constant()` для обработки всех узлов-констант.19051906#### `class ast.NodeTransformer`19071908Подкласс [`NodeVisitor`](https://python-all.ru/3.10/library/ast.html#ast.NodeVisitor), который обходит абстрактное синтаксическое дерево и позволяет изменять узлы.19091910Метод [`NodeTransformer`](https://python-all.ru/3.10/library/ast.html#ast.NodeTransformer) обходит AST и использует возвращаемое значение методов-посетителей для замены или удаления старого узла. Если возвращаемое значение метода-посетителя равно `None`, узел будет удалён из своего местоположения; в противном случае он заменяется возвращённым значением. Возвращённое значение может быть исходным узлом – в этом случае замена не происходит.19111912Вот пример преобразователя, который переписывает все обращения к именам (`foo`) в `data['foo']`:19131914```python1915class RewriteName(NodeTransformer):19161917 def visit_Name(self, node):1918 return Subscript(1919 value=Name(id='data', ctx=Load()),1920 slice=Constant(value=node.id),1921 ctx=node.ctx1922 )1923```19241925Имейте в виду: если у узла, с которым вы работаете, есть дочерние узлы, необходимо либо преобразовать дочерние узлы самостоятельно, либо сначала вызвать для узла метод `generic_visit()`.19261927Для узлов, входящих в состав набора инструкций (это относится ко всем узлам инструкций), посетитель может также возвращать список узлов, а не один узел.19281929Если [`NodeTransformer`](https://python-all.ru/3.10/library/ast.html#ast.NodeTransformer) вводит новые узлы (не входившие в исходное дерево) без указания информации о расположении (например, `lineno`), следует вызвать [`fix_missing_locations()`](https://python-all.ru/3.10/library/ast.html#ast.fix_missing_locations) для нового поддерева, чтобы пересчитать информацию о расположении:19301931```python1932tree = ast.parse('foo', mode='eval')1933new_tree = fix_missing_locations(RewriteName().visit(tree))1934```19351936Обычно преобразователь используется следующим образом:19371938```python1939node = YourTransformer().visit(node)1940```19411942#### `ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None)`19431944Возвращает форматированный дамп дерева из *node*. Это в основном полезно для отладки. Если *annotate\_fields* равно true (по умолчанию), возвращаемая строка будет показывать имена и значения полей. Если *annotate\_fields* равно false, результирующая строка будет более компактной за счёт опускания однозначных имён полей. Атрибуты, такие как номера строк и смещения столбцов, по умолчанию не выводятся. Если это нужно, *include\_attributes* можно установить в true.19451946Если *indent* – неотрицательное целое число или строка, дерево будет выведено с отступами указанного уровня. Уровень отступа 0, отрицательное значение или `""` вставляет только переводы строк. `None` (по умолчанию) выбирает однострочное представление. Положительный целочисленный отступ добавляет соответствующее количество пробелов на уровень. Если *indent* – строка (например, `"\t"`), эта строка используется для отступа каждого уровня.19471948Изменено в версии 3.9: Добавлена опция *indent*.19491950## Флаги компилятора19511952Следующие флаги могут быть переданы в [`compile()`](https://python-all.ru/3.10/library/functions.html#compile) для изменения эффектов компиляции программы:19531954#### `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT`19551956Включает поддержку `await`, `async for`, `async with` и асинхронных включений верхнего уровня.19571958Новое в версии 3.8.19591960#### `ast.PyCF_ONLY_AST`19611962Генерирует и возвращает абстрактное синтаксическое дерево вместо скомпилированного объекта кода.19631964#### `ast.PyCF_TYPE_COMMENTS`19651966Включает поддержку комментариев типов в стиле [**PEP 484**](https://python-all.ru/3.10/library/ast.html) и [**PEP 526**](https://python-all.ru/3.10/library/ast.html) (`# type: <type>`, `# type: ignore <stuff>`).19671968Новое в версии 3.8.19691970## Использование командной строки19711972Новое в версии 3.9.19731974Модуль [`ast`](https://python-all.ru/3.10/library/ast.html#module-ast) может быть выполнен как скрипт из командной строки. Это просто:19751976```sh1977python -m ast [-m <mode>] [-a] [infile]1978```19791980Принимаются следующие опции:19811982#### `-h, --help`19831984Показать справку и выйти.19851986#### `-m <mode>`19871988#### `--mode <mode>`19891990Определяет, какой вид кода должен быть скомпилирован, как аргумент *mode* в [`parse()`](https://python-all.ru/3.10/library/ast.html#ast.parse).19911992#### `--no-type-comments`19931994Не обрабатывать комментарии типов.19951996#### `-a, --include-attributes`19971998Включать атрибуты, такие как номера строк и смещения столбцов.19992000#### `-i <indent>`20012002#### `--indent <indent>`20032004Отступ узлов в AST (количество пробелов).20052006Если указан `infile`, его содержимое разбирается в AST и выводится в stdout. В противном случае содержимое читается из stdin.20072008> **См. также**2009>2010> [Green Tree Snakes](https://python-all.ru/3.10/library/ast.html) – внешний документационный ресурс, содержащий подробности работы с AST Python.2011>2012> [ASTTokens](https://python-all.ru/3.10/library/ast.html) дополняет AST Python позициями токенов и текста в исходном коде, который их породил. Это полезно для инструментов, выполняющих преобразования исходного кода.2013>2014> [leoAst.py](https://python-all.ru/3.10/library/ast.html) объединяет представления программ на Python на основе токенов и синтаксических деревьев, вставляя двусторонние связи между токенами и узлами AST.2015>2016> [LibCST](https://python-all.ru/3.10/library/ast.html) разбирает код как конкретное синтаксическое дерево, похожее на AST, и сохраняет все детали форматирования. Это полезно для создания приложений автоматического рефакторинга (codemod) и линтеров.2017>2018> [Parso](https://python-all.ru/3.10/library/ast.html) – это синтаксический анализатор Python, поддерживающий восстановление после ошибок и сквозной разбор для разных версий Python (на нескольких версиях Python). Parso также может перечислять несколько синтаксических ошибок в файле Python.2019