ast
— Árvores de Sintaxe Abstrata¶
Código-fonte: Lib/ast.py
O módulo ast
ajuda as aplicações Python a processar árvores da gramática de sintaxe abstrata do Python. A sintaxe abstrata em si pode mudar em cada lançamento do Python; este módulo ajuda a descobrir programaticamente como é a gramática atual.
Uma árvore de sintaxe abstrata pode ser gerada passando ast.PyCF_ONLY_AST
como um sinalizador para a função embutida compile()
, ou usando o auxiliar parse()
fornecido neste módulo. O resultado será uma árvore de objetos cujas classes herdam de ast.AST
. Uma árvore de sintaxe abstrata pode ser compilada em um objeto código Python usando a função embutida compile()
.
Gramática Abstrata¶
A gramática abstrata está atualmente definida da seguinte forma:
-- ASDL's 4 builtin types are:
-- identifier, int, string, constant
module Python
{
mod = Module(stmt* body, type_ignore* type_ignores)
| Interactive(stmt* body)
| Expression(expr body)
| FunctionType(expr* argtypes, expr returns)
stmt = FunctionDef(identifier name, arguments args,
stmt* body, expr* decorator_list, expr? returns,
string? type_comment, type_param* type_params)
| AsyncFunctionDef(identifier name, arguments args,
stmt* body, expr* decorator_list, expr? returns,
string? type_comment, type_param* type_params)
| ClassDef(identifier name,
expr* bases,
keyword* keywords,
stmt* body,
expr* decorator_list,
type_param* type_params)
| Return(expr? value)
| Delete(expr* targets)
| Assign(expr* targets, expr value, string? type_comment)
| TypeAlias(expr name, type_param* type_params, expr value)
| AugAssign(expr target, operator op, expr value)
-- 'simple' indicates that we annotate simple name without parens
| AnnAssign(expr target, expr annotation, expr? value, int simple)
-- use 'orelse' because else is a keyword in target languages
| For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
| AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
| While(expr test, stmt* body, stmt* orelse)
| If(expr test, stmt* body, stmt* orelse)
| With(withitem* items, stmt* body, string? type_comment)
| AsyncWith(withitem* items, stmt* body, string? type_comment)
| Match(expr subject, match_case* cases)
| Raise(expr? exc, expr? cause)
| Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
| TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
| Assert(expr test, expr? msg)
| Import(alias* names)
| ImportFrom(identifier? module, alias* names, int? level)
| Global(identifier* names)
| Nonlocal(identifier* names)
| Expr(expr value)
| Pass | Break | Continue
-- col_offset is the byte offset in the utf8 string the parser uses
attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
-- BoolOp() can use left & right?
expr = BoolOp(boolop op, expr* values)
| NamedExpr(expr target, expr value)
| BinOp(expr left, operator op, expr right)
| UnaryOp(unaryop op, expr operand)
| Lambda(arguments args, expr body)
| IfExp(expr test, expr body, expr orelse)
| Dict(expr* keys, expr* values)
| Set(expr* elts)
| ListComp(expr elt, comprehension* generators)
| SetComp(expr elt, comprehension* generators)
| DictComp(expr key, expr value, comprehension* generators)
| GeneratorExp(expr elt, comprehension* generators)
-- the grammar constrains where yield expressions can occur
| Await(expr value)
| Yield(expr? value)
| YieldFrom(expr value)
-- need sequences for compare to distinguish between
-- x < 4 < 3 and (x < 4) < 3
| Compare(expr left, cmpop* ops, expr* comparators)
| Call(expr func, expr* args, keyword* keywords)
| FormattedValue(expr value, int conversion, expr? format_spec)
| JoinedStr(expr* values)
| Constant(constant value, string? kind)
-- the following expression can appear in assignment context
| Attribute(expr value, identifier attr, expr_context ctx)
| Subscript(expr value, expr slice, expr_context ctx)
| Starred(expr value, expr_context ctx)
| Name(identifier id, expr_context ctx)
| List(expr* elts, expr_context ctx)
| Tuple(expr* elts, expr_context ctx)
-- can appear only in Subscript
| Slice(expr? lower, expr? upper, expr? step)
-- col_offset is the byte offset in the utf8 string the parser uses
attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
expr_context = Load | Store | Del
boolop = And | Or
operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift
| RShift | BitOr | BitXor | BitAnd | FloorDiv
unaryop = Invert | Not | UAdd | USub
cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn
comprehension = (expr target, expr iter, expr* ifs, int is_async)
excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)
attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,
expr* kw_defaults, arg? kwarg, expr* defaults)
arg = (identifier arg, expr? annotation, string? type_comment)
attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
-- keyword arguments supplied to call (NULL identifier for **kwargs)
keyword = (identifier? arg, expr value)
attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
-- import name with optional 'as' alias.
alias = (identifier name, identifier? asname)
attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
withitem = (expr context_expr, expr? optional_vars)
match_case = (pattern pattern, expr? guard, stmt* body)
pattern = MatchValue(expr value)
| MatchSingleton(constant value)
| MatchSequence(pattern* patterns)
| MatchMapping(expr* keys, pattern* patterns, identifier? rest)
| MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)
| MatchStar(identifier? name)
-- The optional "rest" MatchMapping parameter handles capturing extra mapping keys
| MatchAs(pattern? pattern, identifier? name)
| MatchOr(pattern* patterns)
attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)
type_ignore = TypeIgnore(int lineno, string tag)
type_param = TypeVar(identifier name, expr? bound)
| ParamSpec(identifier name)
| TypeVarTuple(identifier name)
attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)
}
Classes de nós¶
- class ast.AST¶
Esta é a base de todas as classes de nós de AST. As classes de nós reais são derivadas do arquivo
Parser/Python.asdl
, que é reproduzido acima. Elas são definidas no módulo C_ast
e reexportadas noast
.Há uma classe definida para cada símbolo do lado esquerdo na gramática abstrata (por exemplo,
ast.stmt
ouast.expr
). Além disso, existe uma classe definida para cada construtor no lado direito; essas classes herdam das classes para as árvores do lado esquerdo. Por exemplo,ast.BinOp
herda deast.expr
. Para regras de produção com alternativas (“somas”), a classe do lado esquerdo é abstrata: apenas instâncias de nós construtores específicos são criadas.- _fields¶
Cada classe concreta possui um atributo
_fields
que fornece os nomes de todos os nós filhos.Cada instância de uma classe concreta tem um atributo para cada nó filho, do tipo definido na gramática. Por exemplo, as instâncias
ast.BinOp
possuem um atributoleft
do tipoast.expr
.Se estes atributos estiverem marcados como opcionais na gramática (usando um ponto de interrogação), o valor pode ser
None
. Se os atributos puderem ter valor zero ou mais (marcados com um asterisco), os valores serão representados como listas do Python. Todos os atributos possíveis devem estar presentes e ter valores válidos ao compilar uma AST comcompile()
.
- lineno¶
- col_offset¶
- end_lineno¶
- end_col_offset¶
As instâncias das subclasses
ast.expr
east.stmt
possuem os atributoslineno
,col_offset
,end_lineno
eend_col_offset
. Olineno
eend_lineno
são o primeiro e o último número de linha do intervalo do texto de origem (indexado em 1, para que a primeira linha seja a linha 1) e ocol_offset
eend_col_offset
são os deslocamentos de byte UTF-8 correspondentes do primeiro e do último tokens que geraram o nó. O deslocamento UTF-8 é registrado porque o analisador sintático usa UTF-8 internamente.Observe que as posições finais não são exigidas pelo compilador e, portanto, são opcionais. O deslocamento final está após o último símbolo, por exemplo, é possível obter o segmento de origem de um nó de expressão de uma linha usando
source_line[node.col_offset : node.end_col_offset]
.
O construtor de uma classe
ast.T
analisa seus argumentos da seguinte forma:Se houver argumentos posicionais, deve haver tantos quanto houver itens em
T._fields
; eles serão atribuídos como atributos desses nomes.Se houver argumentos nomeados, eles definirão os atributos dos mesmos nomes para os valores fornecidos.
Por exemplo, para criar e popular um nó
ast.UnaryOp
, você poderia usarnode = ast.UnaryOp() node.op = ast.USub() node.operand = ast.Constant() node.operand.value = 5 node.operand.lineno = 0 node.operand.col_offset = 0 node.lineno = 0 node.col_offset = 0
ou a forma mais compacta
node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0), lineno=0, col_offset=0)
Alterado na versão 3.8: A classe ast.Constant
é agora usada para todas as constantes.
Alterado na versão 3.9: Os índices simples são representados por seus valores, as fatias estendidas são representadas como tuplas.
Obsoleto desde a versão 3.8: Classes antigas ast.Num
, ast.Str
, ast.Bytes
, ast.NameConstant
e ast.Ellipsis
ainda estão disponíveis, mas serão removidos em versões futuras do Python. Enquanto isso, instanciá-las retornará uma instância de uma classe diferente.
Obsoleto desde a versão 3.9: Classes antigas ast.Index
e ast.ExtSlice
ainda estão disponíveis, mas serão removidos em versões futuras do Python. Enquanto isso, instanciá-las retornará uma instância de uma classe diferente.
Nota
As descrições das classes de nós específicas exibidas aqui foram inicialmente adaptadas do fantástico projeto Green Tree Snakes e de todos os seus contribuidores.
Nós raízes¶
- class ast.Module(body, type_ignores)¶
Um módulo Python, como entrada de arquivo. Tipo de nó gerado por
ast.parse()
com mode no padrão"exec"
.body
é umalist
das Instruções do módulo.type_ignores
é umalist
dos comentários de ignorar tipo do módulo; vejaast.parse()
para mais detalhes.>>> print(ast.dump(ast.parse('x = 1'), indent=4)) Module( body=[ Assign( targets=[ Name(id='x', ctx=Store())], value=Constant(value=1))], type_ignores=[])
- class ast.Expression(body)¶
Uma única entrada de expressão Python. Tipo de nó gerado por
ast.parse()
quando mode é"eval"
.body
é um nó único, um dos tipos de expressão.>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4)) Expression( body=Constant(value=123))
- class ast.Interactive(body)¶
Uma única entrada interativa, como em Modo interativo. Tipo de nó gerado por
ast.parse()
quando mode é"single"
.body
é umalist
de nós de instrução.>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4)) Interactive( body=[ Assign( targets=[ Name(id='x', ctx=Store())], value=Constant(value=1)), Assign( targets=[ Name(id='y', ctx=Store())], value=Constant(value=2))])
- class ast.FunctionType(argtypes, returns)¶
Uma representação de comentários de tipo antigo para funções, já que as versões do Python anteriores a 3.5 não davam suporte às anotações da PEP 484. Tipo de nó gerado por
ast.parse()
quando mode é"func_type"
.Esses comentários de tipo ficariam assim:
def sum_two_number(a, b): # tipo: (int, int) -> int return a + b
argtypes
é umalist
de nós de expressão.returns
é um único nó de expressão.>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4)) FunctionType( argtypes=[ Name(id='int', ctx=Load()), Name(id='str', ctx=Load())], returns=Subscript( value=Name(id='List', ctx=Load()), slice=Name(id='int', ctx=Load()), ctx=Load()))
Adicionado na versão 3.8.
Literais¶
- class ast.Constant(value)¶
Um valor constante. O atributo
value
do literalConstant
contém o objeto Python que ele representa. Os valores representados podem ser tipos simples como um número, string ouNone
, mas também tipos de contêineres imutáveis (tuplas e frozensets) se todos os seus elementos forem constantes.>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4)) Expression( body=Constant(value=123))
- class ast.FormattedValue(value, conversion, format_spec)¶
Nó que representa um único campo de formatação em uma f-string. Se a string contiver um único campo de formatação e nada mais, o nó poderá ser isolado, caso contrário ele aparecerá em
JoinedStr
.value
é qualquer nó de expressão (como um literal, uma variável ou uma chamada de função).conversion
é um inteiro:-1: sem formatação
115:
!s
formatação de string114:
!r
formatação de repr97:
!a
formatação ascii
format_spec
é um nóJoinedStr
que representa a formatação do valor, ouNone
se nenhum formato foi especificado. Tantoconversion
quantoformat_spec
podem ser configurados ao mesmo tempo.
- class ast.JoinedStr(values)¶
Uma f-string, compreendendo uma série de nós
FormattedValue
eConstant
.>>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4)) Expression( body=JoinedStr( values=[ Constant(value='sin('), FormattedValue( value=Name(id='a', ctx=Load()), conversion=-1), Constant(value=') is '), FormattedValue( value=Call( func=Name(id='sin', ctx=Load()), args=[ Name(id='a', ctx=Load())], keywords=[]), conversion=-1, format_spec=JoinedStr( values=[ Constant(value='.3')]))]))
- class ast.List(elts, ctx)¶
- class ast.Tuple(elts, ctx)¶
Uma lista ou tupla.
elts
contém uma lista de nós que representam os elementos.ctx
éStore
se o contêiner for um alvo de atribuição (ou seja,(x,y)=algumacoisa
), eLoad
caso contrário.>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4)) Expression( body=List( elts=[ Constant(value=1), Constant(value=2), Constant(value=3)], ctx=Load())) >>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4)) Expression( body=Tuple( elts=[ Constant(value=1), Constant(value=2), Constant(value=3)], ctx=Load()))
- class ast.Set(elts)¶
Um conjunto.
elts
contém uma lista de nós que representam os elementos do conjunto.>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4)) Expression( body=Set( elts=[ Constant(value=1), Constant(value=2), Constant(value=3)]))
- class ast.Dict(keys, values)¶
Um dicionário.
keys
evalues
contêm listas de nós que representam as chaves e os valores respectivamente, em ordem correspondente (o que seria retornado ao chamardictionary.keys()
edictionary.values()
).Ao desempacotar o dicionário usando literais de dicionário, a expressão a ser expandida vai para a lista
values
, com umNone
na posição correspondente emkeys
.>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4)) Expression( body=Dict( keys=[ Constant(value='a'), None], values=[ Constant(value=1), Name(id='d', ctx=Load())]))
Variáveis¶
- class ast.Name(id, ctx)¶
Um nome de variável.
id
contém o nome como uma string ectx
é um dos seguintes tipos.
- class ast.Load¶
- class ast.Store¶
- class ast.Del¶
As referências de variáveis podem ser usadas para carregar o valor de uma variável, para atribuir um novo valor a ela ou para excluí-la. As referências de variáveis recebem um contexto para distinguir esses casos.
>>> print(ast.dump(ast.parse('a'), indent=4)) Module( body=[ Expr( value=Name(id='a', ctx=Load()))], type_ignores=[]) >>> print(ast.dump(ast.parse('a = 1'), indent=4)) Module( body=[ Assign( targets=[ Name(id='a', ctx=Store())], value=Constant(value=1))], type_ignores=[]) >>> print(ast.dump(ast.parse('del a'), indent=4)) Module( body=[ Delete( targets=[ Name(id='a', ctx=Del())])], type_ignores=[])
- class ast.Starred(value, ctx)¶
Uma referência de variável
*var
.value
contém a variável, normalmente um nóName
. Este tipo deve ser usado ao construir um nóCall
com*args
.>>> print(ast.dump(ast.parse('a, *b = it'), indent=4)) Module( body=[ Assign( targets=[ Tuple( elts=[ Name(id='a', ctx=Store()), Starred( value=Name(id='b', ctx=Store()), ctx=Store())], ctx=Store())], value=Name(id='it', ctx=Load()))], type_ignores=[])
Expressões¶
- class ast.Expr(value)¶
Quando uma expressão, como uma chamada de função, aparece como uma instrução por si só com seu valor de retorno não usado ou armazenado, ela é encapsulada neste contêiner.
value
contém um dos outros nós nesta seção, um nóConstant
, umName
, umLambda
, umYield
ouYieldFrom
.>>> print(ast.dump(ast.parse('-a'), indent=4)) Module( body=[ Expr( value=UnaryOp( op=USub(), operand=Name(id='a', ctx=Load())))], type_ignores=[])
- class ast.UnaryOp(op, operand)¶
Uma operação unária.
op
é o operador eoperand
qualquer nó de expressão.
- class ast.UAdd¶
- class ast.USub¶
- class ast.Not¶
- class ast.Invert¶
Tokens de operador unário.
Not
é a palavra reservadanot
,Invert
é o operador~
.>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4)) Expression( body=UnaryOp( op=Not(), operand=Name(id='x', ctx=Load())))
- class ast.BinOp(left, op, right)¶
Uma operação binária (como adição ou divisão).
op
é o operador, eleft
eright
são quaisquer nós de expressão.>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4)) Expression( body=BinOp( left=Name(id='x', ctx=Load()), op=Add(), right=Name(id='y', ctx=Load())))
- class ast.Add¶
- class ast.Sub¶
- class ast.Mult¶
- class ast.Div¶
- class ast.FloorDiv¶
- class ast.Mod¶
- class ast.Pow¶
- class ast.LShift¶
- class ast.RShift¶
- class ast.BitOr¶
- class ast.BitXor¶
- class ast.BitAnd¶
- class ast.MatMult¶
Tokens de operador binário.
- class ast.BoolOp(op, values)¶
Uma operação booleana, ‘or’ ou ‘and’.
op
éOr
ouAnd
.values
são os valores envolvidos. Operações consecutivas com o mesmo operador, comoa or b or c
, são recolhidas em um nó com vários valores.Isso não inclui
not
, que é umUnaryOp
.>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4)) Expression( body=BoolOp( op=Or(), values=[ Name(id='x', ctx=Load()), Name(id='y', ctx=Load())]))
- class ast.Compare(left, ops, comparators)¶
Uma comparação de dois ou mais valores.
left
é o primeiro valor na comparação,ops
a lista de operadores ecomparators
a lista de valores após o primeiro elemento na comparação.>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4)) Expression( body=Compare( left=Constant(value=1), ops=[ LtE(), Lt()], comparators=[ Name(id='a', ctx=Load()), Constant(value=10)]))
- class ast.Eq¶
- class ast.NotEq¶
- class ast.Lt¶
- class ast.LtE¶
- class ast.Gt¶
- class ast.GtE¶
- class ast.Is¶
- class ast.IsNot¶
- class ast.In¶
- class ast.NotIn¶
Tokens de operador de comparação.
- class ast.Call(func, args, keywords)¶
Uma chamada de função.
func
é a função, que geralmente será um objetoName
ouAttribute
. Dos argumentos:args
contém uma lista dos argumentos passados por posição.keywords
contém uma lista de objetoskeyword
representando argumentos passados como nomeados.
Ao criar um nó
Call
,args
ekeywords
são necessários, mas podem ser listas vazias.>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4)) Expression( body=Call( func=Name(id='func', ctx=Load()), args=[ Name(id='a', ctx=Load()), Starred( value=Name(id='d', ctx=Load()), ctx=Load())], keywords=[ keyword( arg='b', value=Name(id='c', ctx=Load())), keyword( value=Name(id='e', ctx=Load()))]))
- class ast.keyword(arg, value)¶
Um argumento nomeado para uma chamada de função ou definição de classe.
arg
é uma string bruta do nome do parâmetro,value
é um nó para passar.
- class ast.IfExp(test, body, orelse)¶
Uma expressão como
a if b else c
. Cada campo contém um único nó, portanto, no exemplo a seguir, todos os três são nósName
.>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4)) Expression( body=IfExp( test=Name(id='b', ctx=Load()), body=Name(id='a', ctx=Load()), orelse=Name(id='c', ctx=Load())))
- class ast.Attribute(value, attr, ctx)¶
Acesso a atributo como, por exemplo,
d.keys
.value
é um nó, normalmente umName
.attr
é uma string simples fornecendo o nome do atributo, ectx
éLoad
,Store
ouDel
de acordo com como o atributo é acionado sobre.>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4)) Expression( body=Attribute( value=Name(id='snake', ctx=Load()), attr='colour', ctx=Load()))
- class ast.NamedExpr(target, value)¶
Uma expressão nomeada. Este nó de AST é produzido pelo operador de expressões de atribuição (também conhecido como operador morsa). Ao contrário do nó
Assign
no qual o primeiro argumento pode ser múltiplos nós, neste caso ambostarget
evalue
devem ser nós únicos.>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4)) Expression( body=NamedExpr( target=Name(id='x', ctx=Store()), value=Constant(value=4)))
Adicionado na versão 3.8.
Subscrição¶
- class ast.Subscript(value, slice, ctx)¶
Um subscrito, como
l[1]
.value
é o objeto subscrito (geralmente sequência ou mapeamento).slice
é um índice, fatia ou chave. Pode ser umaTuple
e conter umaSlice
.ctx
éLoad
,Store
ouDel
de acordo com a ação realizada com o subscrito.>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4)) Expression( body=Subscript( value=Name(id='l', ctx=Load()), slice=Tuple( elts=[ Slice( lower=Constant(value=1), upper=Constant(value=2)), Constant(value=3)], ctx=Load()), ctx=Load()))
- class ast.Slice(lower, upper, step)¶
Fatiamento regular (no formato
lower:upper
oulower:upper:step
). Pode ocorrer apenas dentro do campo slice deSubscript
, diretamente ou como um elemento deTuple
.>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4)) Expression( body=Subscript( value=Name(id='l', ctx=Load()), slice=Slice( lower=Constant(value=1), upper=Constant(value=2)), ctx=Load()))
Compreensões¶
- class ast.ListComp(elt, generators)¶
- class ast.SetComp(elt, generators)¶
- class ast.GeneratorExp(elt, generators)¶
- class ast.DictComp(key, value, generators)¶
Lista e define compreensões, expressões geradoras e compreensões de dicionário.
elt
(oukey
evalue
) é um único nó que representa a parte que será avaliada para cada item.generators
é uma lista de nós decomprehension
.>>> print(ast.dump(ast.parse('[x for x in numbers]', mode='eval'), indent=4)) Expression( body=ListComp( elt=Name(id='x', ctx=Load()), generators=[ comprehension( target=Name(id='x', ctx=Store()), iter=Name(id='numbers', ctx=Load()), ifs=[], is_async=0)])) >>> print(ast.dump(ast.parse('{x: x**2 for x in numbers}', mode='eval'), indent=4)) Expression( body=DictComp( key=Name(id='x', ctx=Load()), value=BinOp( left=Name(id='x', ctx=Load()), op=Pow(), right=Constant(value=2)), generators=[ comprehension( target=Name(id='x', ctx=Store()), iter=Name(id='numbers', ctx=Load()), ifs=[], is_async=0)])) >>> print(ast.dump(ast.parse('{x for x in numbers}', mode='eval'), indent=4)) Expression( body=SetComp( elt=Name(id='x', ctx=Load()), generators=[ comprehension( target=Name(id='x', ctx=Store()), iter=Name(id='numbers', ctx=Load()), ifs=[], is_async=0)]))
- class ast.comprehension(target, iter, ifs, is_async)¶
Uma cláusula
for
em uma compreensão.target
é a referência a ser usada para cada elemento - normalmente um nóName
ouTuple
.iter
é o objeto sobre o qual iterar.ifs
é uma lista de expressões de teste: cada cláusulafor
pode ter múltiplosifs
.is_async
indica que uma compreensão é assíncrona (usando umasync for
em vez defor
). O valor é um número inteiro (0 ou 1).>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'), ... indent=4)) # Multiple comprehensions in one. Expression( body=ListComp( elt=Call( func=Name(id='ord', ctx=Load()), args=[ Name(id='c', ctx=Load())], keywords=[]), generators=[ comprehension( target=Name(id='line', ctx=Store()), iter=Name(id='file', ctx=Load()), ifs=[], is_async=0), comprehension( target=Name(id='c', ctx=Store()), iter=Name(id='line', ctx=Load()), ifs=[], is_async=0)])) >>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'), ... indent=4)) # generator comprehension Expression( body=GeneratorExp( elt=BinOp( left=Name(id='n', ctx=Load()), op=Pow(), right=Constant(value=2)), generators=[ comprehension( target=Name(id='n', ctx=Store()), iter=Name(id='it', ctx=Load()), ifs=[ Compare( left=Name(id='n', ctx=Load()), ops=[ Gt()], comparators=[ Constant(value=5)]), Compare( left=Name(id='n', ctx=Load()), ops=[ Lt()], comparators=[ Constant(value=10)])], is_async=0)])) >>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'), ... indent=4)) # Async comprehension Expression( body=ListComp( elt=Name(id='i', ctx=Load()), generators=[ comprehension( target=Name(id='i', ctx=Store()), iter=Name(id='soc', ctx=Load()), ifs=[], is_async=1)]))
Instruções¶
- class ast.Assign(targets, value, type_comment)¶
Uma atribuição.
targets
é uma lista de nós evalue
é um único nó.Vários nós em
targets
representam a atribuição do mesmo valor a cada um. O desempacotamento é representada colocando umaTuple
ouList
dentro detargets
.- type_comment¶
type_comment
é uma string opcional com a anotação de tipo como comentário.
>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # Multiple assignment Module( body=[ Assign( targets=[ Name(id='a', ctx=Store()), Name(id='b', ctx=Store())], value=Constant(value=1))], type_ignores=[]) >>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # Unpacking Module( body=[ Assign( targets=[ Tuple( elts=[ Name(id='a', ctx=Store()), Name(id='b', ctx=Store())], ctx=Store())], value=Name(id='c', ctx=Load()))], type_ignores=[])
- class ast.AnnAssign(target, annotation, value, simple)¶
Uma atribuição com uma anotação de tipo.
target
é um nó único e pode ser uma classeName
,Attribute
ouSubscript
.annotation
é a anotação, como um nóConstant
ouName
.value
é um único nó opcional.simple
é sempre 0 (indicando um alvo “complexo”) ou 1 (indicando um alvo “simples”). Um alvo “simples” consiste apenas em um nóName
que não aparece entre parênteses; todos os outros alvos são considerados complexos. Apenas alvos simples aparecem no dicionário__annotations__
de módulos e classes.>>> print(ast.dump(ast.parse('c: int'), indent=4)) Module( body=[ AnnAssign( target=Name(id='c', ctx=Store()), annotation=Name(id='int', ctx=Load()), simple=1)], type_ignores=[]) >>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # Annotation with parenthesis Module( body=[ AnnAssign( target=Name(id='a', ctx=Store()), annotation=Name(id='int', ctx=Load()), value=Constant(value=1), simple=0)], type_ignores=[]) >>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # Attribute annotation Module( body=[ AnnAssign( target=Attribute( value=Name(id='a', ctx=Load()), attr='b', ctx=Store()), annotation=Name(id='int', ctx=Load()), simple=0)], type_ignores=[]) >>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # Subscript annotation Module( body=[ AnnAssign( target=Subscript( value=Name(id='a', ctx=Load()), slice=Constant(value=1), ctx=Store()), annotation=Name(id='int', ctx=Load()), simple=0)], type_ignores=[])
- class ast.AugAssign(target, op, value)¶
Atribuição aumentada, como
a += 1
. No exemplo a seguir,target
é um nóName
parax
(com o contextoStore
),op
éAdd
, evalue
é umaConstant
com valor para 1.O atributo
target
não pode ser da classeTuple
ouList
, diferentemente dos alvos deAssign
.>>> print(ast.dump(ast.parse('x += 2'), indent=4)) Module( body=[ AugAssign( target=Name(id='x', ctx=Store()), op=Add(), value=Constant(value=2))], type_ignores=[])
- class ast.Raise(exc, cause)¶
Uma instrução
raise
.exc
é o objeto de exceção a ser levantado, normalmente umaCall
ouName
, ouNone
para umraise
independente.cause
é a parte opcional paray
emraise x from y
.>>> print(ast.dump(ast.parse('raise x from y'), indent=4)) Module( body=[ Raise( exc=Name(id='x', ctx=Load()), cause=Name(id='y', ctx=Load()))], type_ignores=[])
- class ast.Assert(test, msg)¶
Uma asserção.
test
contém a condição, como um nóCompare
.msg
contém a mensagem de falha.>>> print(ast.dump(ast.parse('assert x,y'), indent=4)) Module( body=[ Assert( test=Name(id='x', ctx=Load()), msg=Name(id='y', ctx=Load()))], type_ignores=[])
- class ast.Delete(targets)¶
Representa uma instrução
del
.targets
é uma lista de nós, como nósName
,Attribute
ouSubscript
.>>> print(ast.dump(ast.parse('del x,y,z'), indent=4)) Module( body=[ Delete( targets=[ Name(id='x', ctx=Del()), Name(id='y', ctx=Del()), Name(id='z', ctx=Del())])], type_ignores=[])
- class ast.Pass¶
Uma instrução
pass
.>>> print(ast.dump(ast.parse('pass'), indent=4)) Module( body=[ Pass()], type_ignores=[])
- class ast.TypeAlias(name, type_params, value)¶
Um apelido de tipo criado através da instrução
type
.name
é o nome do apelido,type_params
é uma lista de parâmetros de tipo, evalue
é o valor do apelido do tipo.>>> print(ast.dump(ast.parse('type Alias = int'), indent=4)) Module( body=[ TypeAlias( name=Name(id='Alias', ctx=Store()), type_params=[], value=Name(id='int', ctx=Load()))], type_ignores=[])
Adicionado na versão 3.12.
Outras instruções que são aplicáveis apenas dentro de funções ou laços são descritas em outras seções.
Importações¶
- class ast.Import(names)¶
Uma instrução de importação.
names
é uma lista de nós dealias
.>>> print(ast.dump(ast.parse('import x,y,z'), indent=4)) Module( body=[ Import( names=[ alias(name='x'), alias(name='y'), alias(name='z')])], type_ignores=[])
- class ast.ImportFrom(module, names, level)¶
Representa
from x import y
.module
é uma string bruta do nome ‘from’, sem quaisquer pontos iniciais, ouNone
para instruções comofrom . import foo
.level
é um número inteiro que contém o nível da importação relativa (0 significa importação absoluta).>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4)) Module( body=[ ImportFrom( module='y', names=[ alias(name='x'), alias(name='y'), alias(name='z')], level=0)], type_ignores=[])
- class ast.alias(name, asname)¶
Ambos os parâmetros são strings brutas dos nomes.
asname
pode serNone
se o nome normal for usado.>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4)) Module( body=[ ImportFrom( module='foo.bar', names=[ alias(name='a', asname='b'), alias(name='c')], level=2)], type_ignores=[])
Fluxo de controle¶
Nota
Cláusulas opcionais como else
são armazenadas como uma lista vazia se não estiverem presentes.
- class ast.If(test, body, orelse)¶
Uma instrução
if
.test
contém um único nó, como um nóCompare
.body
eorelse
contêm, cada um, uma lista de nós.As cláusulas
elif
não têm uma representação especial no AST, mas aparecem como nós extras deIf
dentro da seçãoorelse
da cláusula anterior.>>> print(ast.dump(ast.parse(""" ... if x: ... ... ... elif y: ... ... ... else: ... ... ... """), indent=4)) Module( body=[ If( test=Name(id='x', ctx=Load()), body=[ Expr( value=Constant(value=Ellipsis))], orelse=[ If( test=Name(id='y', ctx=Load()), body=[ Expr( value=Constant(value=Ellipsis))], orelse=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
- class ast.For(target, iter, body, orelse, type_comment)¶
Um laço
for
.target
contém as variáveis às quais o laço atribui, como um único nó deName
,Tuple
,List
,Attribute
ouSubscript
.iter
contém o item a ser repetido, novamente como um único nó.body
eorelse
contêm listas de nós para executar. Aqueles emorelse
são executados se o laço terminar normalmente, ao invés de através de uma instruçãobreak
.- type_comment¶
type_comment
é uma string opcional com a anotação de tipo como comentário.
>>> print(ast.dump(ast.parse(""" ... for x in y: ... ... ... else: ... ... ... """), indent=4)) Module( body=[ For( target=Name(id='x', ctx=Store()), iter=Name(id='y', ctx=Load()), body=[ Expr( value=Constant(value=Ellipsis))], orelse=[ Expr( value=Constant(value=Ellipsis))])], type_ignores=[])
- class ast.While(test, body, orelse)¶
Um laço
while
.test
contém a condição, como um nó deCompare
.>> print(ast.dump(ast.parse(""" ... while x: ... ... ... else: ... ... ... """), indent=4)) Module( body=[ While( test=Name(id='x', ctx=Load()), body=[ Expr( value=Constant(value=Ellipsis))], orelse=[ Expr( value=Constant(value=Ellipsis))])], type_ignores=[])
- class ast.Break¶
- class ast.Continue¶
As instruções
break
econtinue
.>>> print(ast.dump(ast.parse("""\ ... for a in b: ... if a > 5: ... break ... else: ... continue ... ... """), indent=4)) Module( body=[ For( target=Name(id='a', ctx=Store()), iter=Name(id='b', ctx=Load()), body=[ If( test=Compare( left=Name(id='a', ctx=Load()), ops=[ Gt()], comparators=[ Constant(value=5)]), body=[ Break()], orelse=[ Continue()])], orelse=[])], type_ignores=[])
- class ast.Try(body, handlers, orelse, finalbody)¶
Blocos
try
. Todos os atributos são uma lista de nós a serem executados, excetohandlers
, que é uma lista de nós deExceptHandler
.>>> print(ast.dump(ast.parse(""" ... try: ... ... ... except Exception: ... ... ... except OtherException as e: ... ... ... else: ... ... ... finally: ... ... ... """), indent=4)) Module( body=[ Try( body=[ Expr( value=Constant(value=Ellipsis))], handlers=[ ExceptHandler( type=Name(id='Exception', ctx=Load()), body=[ Expr( value=Constant(value=Ellipsis))]), ExceptHandler( type=Name(id='OtherException', ctx=Load()), name='e', body=[ Expr( value=Constant(value=Ellipsis))])], orelse=[ Expr( value=Constant(value=Ellipsis))], finalbody=[ Expr( value=Constant(value=Ellipsis))])], type_ignores=[])
- class ast.TryStar(body, handlers, orelse, finalbody)¶
Blocos
try
que são seguidos por cláusulasexcept*
. Os atributos são os mesmos deTry
, mas os nósExceptHandler
emhandlers
são interpretados como blocosexcept*
em vez deexcept
.>>> print(ast.dump(ast.parse(""" ... try: ... ... ... except* Exception: ... ... ... """), indent=4)) Module( body=[ TryStar( body=[ Expr( value=Constant(value=Ellipsis))], handlers=[ ExceptHandler( type=Name(id='Exception', ctx=Load()), body=[ Expr( value=Constant(value=Ellipsis))])], orelse=[], finalbody=[])], type_ignores=[])
Adicionado na versão 3.11.
- class ast.ExceptHandler(type, name, body)¶
Uma única cláusula
except
.type
é o tipo de exceção que irá corresponder, normalmente um nó deName
(ouNone
para uma cláusula abrangenteexcept:
).name
é uma string bruta para o nome conter a exceção, ouNone
se a cláusula não tiveras foo
.body
é uma lista de nós.>>> print(ast.dump(ast.parse("""\ ... try: ... a + 1 ... except TypeError: ... pass ... """), indent=4)) Module( body=[ Try( body=[ Expr( value=BinOp( left=Name(id='a', ctx=Load()), op=Add(), right=Constant(value=1)))], handlers=[ ExceptHandler( type=Name(id='TypeError', ctx=Load()), body=[ Pass()])], orelse=[], finalbody=[])], type_ignores=[])
- class ast.With(items, body, type_comment)¶
Um bloco
with
.items
é uma lista de nóswithitem
representando os gerenciadores de contexto, ebody
é o bloco indentado dentro do contexto.- type_comment¶
type_comment
é uma string opcional com a anotação de tipo como comentário.
- class ast.withitem(context_expr, optional_vars)¶
Um único gerenciador de contexto em um bloco
with
.context_expr
é o gerenciador de contexto, geralmente um nó deCall
.optional_vars
é umName
,Tuple
ouList
para a parteas foo
, ouNone
se não for usado.>>> print(ast.dump(ast.parse("""\ ... with a as b, c as d: ... something(b, d) ... """), indent=4)) Module( body=[ With( items=[ withitem( context_expr=Name(id='a', ctx=Load()), optional_vars=Name(id='b', ctx=Store())), withitem( context_expr=Name(id='c', ctx=Load()), optional_vars=Name(id='d', ctx=Store()))], body=[ Expr( value=Call( func=Name(id='something', ctx=Load()), args=[ Name(id='b', ctx=Load()), Name(id='d', ctx=Load())], keywords=[]))])], type_ignores=[])
Correspondência de padrões¶
- class ast.Match(subject, cases)¶
Uma instrução
match
.subject
contém o assunto da correspondência (o objeto que está sendo comparado com os casos) ecases
contém um iterável de nós dematch_case
com os diferentes casos.Adicionado na versão 3.10.
- class ast.match_case(pattern, guard, body)¶
Um padrão de caso único em uma instrução
match
.pattern
contém o padrão de correspondência com o qual o assunto será comparado. Observe que os nósAST
produzidos para padrões diferem daqueles produzidos para expressões, mesmo quando compartilham a mesma sintaxe.O atributo
guard
contém uma expressão que será avaliada se o padrão corresponder ao assunto.body
contém uma lista de nós a serem executados se o padrão corresponder e o resultado da avaliação da expressão de guarda for verdadeiro.>>> print(ast.dump(ast.parse(""" ... match x: ... case [x] if x>0: ... ... ... case tuple(): ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchSequence( patterns=[ MatchAs(name='x')]), guard=Compare( left=Name(id='x', ctx=Load()), ops=[ Gt()], comparators=[ Constant(value=0)]), body=[ Expr( value=Constant(value=Ellipsis))]), match_case( pattern=MatchClass( cls=Name(id='tuple', ctx=Load()), patterns=[], kwd_attrs=[], kwd_patterns=[]), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
- class ast.MatchValue(value)¶
Um literal de correspondência ou padrão de valor que é comparado por igualdade.
value
é um nó de expressão. Os nós de valor permitido são restritos conforme descrito na documentação da instrução de correspondência. Este padrão será bem-sucedido se o assunto da correspondência for igual ao valor avaliado.>>> print(ast.dump(ast.parse(""" ... match x: ... case "Relevant": ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchValue( value=Constant(value='Relevant')), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
- class ast.MatchSingleton(value)¶
Um padrão literal de correspondência que compara por identidade.
value
é o singleton a ser comparado com:None
,True
ouFalse
. Este padrão será bem-sucedido se o assunto da correspondência for a constante fornecida.>>> print(ast.dump(ast.parse(""" ... match x: ... case None: ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchSingleton(value=None), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
- class ast.MatchSequence(patterns)¶
Um padrão de sequência de correspondência.
patterns
contém os padrões a serem comparados aos elementos do assunto se o assunto for uma sequência. Corresponde a uma sequência de comprimento variável se um dos subpadrões for um nóMatchStar
, caso contrário corresponde a uma sequência de comprimento fixo.>>> print(ast.dump(ast.parse(""" ... match x: ... case [1, 2]: ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchSequence( patterns=[ MatchValue( value=Constant(value=1)), MatchValue( value=Constant(value=2))]), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
- class ast.MatchStar(name)¶
Corresponde ao restante da sequência em um padrão de sequência de correspondência de comprimento variável. Se
name
não forNone
, uma lista contendo os elementos restantes da sequência será vinculada a esse nome se o padrão de sequência geral for bem-sucedido.>>> print(ast.dump(ast.parse(""" ... match x: ... case [1, 2, *rest]: ... ... ... case [*_]: ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchSequence( patterns=[ MatchValue( value=Constant(value=1)), MatchValue( value=Constant(value=2)), MatchStar(name='rest')]), body=[ Expr( value=Constant(value=Ellipsis))]), match_case( pattern=MatchSequence( patterns=[ MatchStar()]), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
- class ast.MatchMapping(keys, patterns, rest)¶
Um padrão de mapeamento de correspondência.
keys
é uma sequência de nós de expressão.patterns
é uma sequência correspondente de nós padrão.rest
é um nome opcional que pode ser especificado para capturar os elementos restantes do mapeamento. As expressões-chave permitidas são restritas conforme descrito na documentação da instrução match.Este padrão será bem-sucedido se o assunto for um mapeamento, todas as expressões-chave avaliadas estiverem presentes no mapeamento e o valor correspondente a cada chave corresponder ao subpadrão correspondente. Se
rest
não forNone
, um dict contendo os elementos de mapeamento restantes será vinculado a esse nome se o padrão de mapeamento geral for bem-sucedido.>>> print(ast.dump(ast.parse(""" ... match x: ... case {1: _, 2: _}: ... ... ... case {**rest}: ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchMapping( keys=[ Constant(value=1), Constant(value=2)], patterns=[ MatchAs(), MatchAs()]), body=[ Expr( value=Constant(value=Ellipsis))]), match_case( pattern=MatchMapping(keys=[], patterns=[], rest='rest'), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
- class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)¶
Um padrão de classe de correspondência.
cls
é uma expressão que fornece a classe nominal a ser correspondida.patterns
é uma sequência de nós padrão a serem comparados com a sequência definida pela classe de atributos de correspondência de padrões.kwd_attrs
é uma sequência de atributos adicionais a serem correspondidos (especificados como argumentos nomeados no padrão de classe),kwd_patterns
são os padrões correspondentes (especificados como valores de argumentos nomeados no padrão de classe).Esse padrão será bem-sucedido se o assunto for uma instância da classe indicada, todos os padrões posicionais corresponderem aos atributos correspondentes definidos pela classe e quaisquer atributos, passados como argumentos nomeados, especificados corresponderem ao seu padrão correspondente.
Nota: as classes podem definir uma propriedade que retorna self para corresponder um nó padrão à instância que está sendo correspondida. Vários tipos internos também são combinados dessa forma, conforme descrito na documentação da instrução match.
>>> print(ast.dump(ast.parse(""" ... match x: ... case Point2D(0, 0): ... ... ... case Point3D(x=0, y=0, z=0): ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchClass( cls=Name(id='Point2D', ctx=Load()), patterns=[ MatchValue( value=Constant(value=0)), MatchValue( value=Constant(value=0))], kwd_attrs=[], kwd_patterns=[]), body=[ Expr( value=Constant(value=Ellipsis))]), match_case( pattern=MatchClass( cls=Name(id='Point3D', ctx=Load()), patterns=[], kwd_attrs=[ 'x', 'y', 'z'], kwd_patterns=[ MatchValue( value=Constant(value=0)), MatchValue( value=Constant(value=0)), MatchValue( value=Constant(value=0))]), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
- class ast.MatchAs(pattern, name)¶
Uma correspondência “como padrão”, padrão de captura ou padrão curinga.
pattern
contém o padrão de correspondência com o qual o assunto será comparado. Se o padrão forNone
, o nó representa um padrão de captura (ou seja, um nome simples) e sempre terá sucesso.O atributo
name
contém o nome que será vinculado se o padrão for bem-sucedido. Sename
forNone
,pattern
também deverá serNone
e o nó representa o padrão curinga.>>> print(ast.dump(ast.parse(""" ... match x: ... case [x] as y: ... ... ... case _: ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchAs( pattern=MatchSequence( patterns=[ MatchAs(name='x')]), name='y'), body=[ Expr( value=Constant(value=Ellipsis))]), match_case( pattern=MatchAs(), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
- class ast.MatchOr(patterns)¶
Uma correspondência de “padrão ou”. Um “padrão ou” corresponde cada um de seus subpadrões com o assunto, até que um seja bem-sucedido. O “padrão ou” é então considerado bem-sucedido. Se nenhum dos subpadrões for bem-sucedido, o padrão or falhará. O atributo
patterns
contém uma lista de nós de padrões de correspondência que serão comparados com o assunto.>>> print(ast.dump(ast.parse(""" ... match x: ... case [x] | (y): ... ... ... """), indent=4)) Module( body=[ Match( subject=Name(id='x', ctx=Load()), cases=[ match_case( pattern=MatchOr( patterns=[ MatchSequence( patterns=[ MatchAs(name='x')]), MatchAs(name='y')]), body=[ Expr( value=Constant(value=Ellipsis))])])], type_ignores=[])
Adicionado na versão 3.10.
Parâmetros de tipo¶
Parâmetros de tipo podem existir em classes, funções e apelidos de tipo.
- class ast.TypeVar(name, bound)¶
A
typing.TypeVar
.name
is the name of the type variable.bound
is the bound or constraints, if any. Ifbound
is aTuple
, it represents constraints; otherwise it represents the bound.>>> print(ast.dump(ast.parse("type Alias[T: int] = list[T]"), indent=4)) Module( body=[ TypeAlias( name=Name(id='Alias', ctx=Store()), type_params=[ TypeVar( name='T', bound=Name(id='int', ctx=Load()))], value=Subscript( value=Name(id='list', ctx=Load()), slice=Name(id='T', ctx=Load()), ctx=Load()))], type_ignores=[])
Adicionado na versão 3.12.
- class ast.ParamSpec(name)¶
A
typing.ParamSpec
.name
is the name of the parameter specification.>>> print(ast.dump(ast.parse("type Alias[**P] = Callable[P, int]"), indent=4)) Module( body=[ TypeAlias( name=Name(id='Alias', ctx=Store()), type_params=[ ParamSpec(name='P')], value=Subscript( value=Name(id='Callable', ctx=Load()), slice=Tuple( elts=[ Name(id='P', ctx=Load()), Name(id='int', ctx=Load())], ctx=Load()), ctx=Load()))], type_ignores=[])
Adicionado na versão 3.12.
- class ast.TypeVarTuple(name)¶
A
typing.TypeVarTuple
.name
is the name of the type variable tuple.>>> print(ast.dump(ast.parse("type Alias[*Ts] = tuple[*Ts]"), indent=4)) Module( body=[ TypeAlias( name=Name(id='Alias', ctx=Store()), type_params=[ TypeVarTuple(name='Ts')], value=Subscript( value=Name(id='tuple', ctx=Load()), slice=Tuple( elts=[ Starred( value=Name(id='Ts', ctx=Load()), ctx=Load())], ctx=Load()), ctx=Load()))], type_ignores=[])
Adicionado na versão 3.12.
Definições de função e classe¶
- class ast.FunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)¶
Uma definição de função
name
é uma string bruta do nome da função.args
é um nóarguments
.body
é a lista de nós dentro da função.decorator_list
é a lista de decoradores a serem aplicados, armazenados primeiro na parte externa (ou seja, o primeiro da lista será aplicado por último).returns
é a anotação de retorno.type_params
é uma lista de parâmetros de tipo.
- type_comment¶
type_comment
é uma string opcional com a anotação de tipo como comentário.
Alterado na versão 3.12: Adicionado
type_params
.
- class ast.Lambda(args, body)¶
lambda
é uma definição mínima de função que pode ser usada dentro de uma expressão. Ao contrário deFunctionDef
,body
contém um único nó.>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4)) Module( body=[ Expr( value=Lambda( args=arguments( posonlyargs=[], args=[ arg(arg='x'), arg(arg='y')], kwonlyargs=[], kw_defaults=[], defaults=[]), body=Constant(value=Ellipsis)))], type_ignores=[])
- class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)¶
Os argumentos para uma função.
posonlyargs
,args
ekwonlyargs
são listas de nósarg
.vararg
ekwarg
são nósarg
únicos, referindo-se aos parâmetros*args, **kwargs
.kw_defaults
é uma lista de valores padrão para argumentos somente-nomeados. Se um forNone
, o argumento correspondente é necessário.defaults
é uma lista de valores padrão para argumentos que podem ser passados posicionalmente. Se houver menos padrões, eles corresponderão aos últimos n argumentos.
- class ast.arg(arg, annotation, type_comment)¶
Um único argumento em uma lista.
arg
é uma string bruta do nome do argumento;annotation
é sua anotação, como um nóName
.- type_comment¶
type_comment
é uma string opcional com a anotação de tipo como comentário
>>> print(ast.dump(ast.parse("""\ ... @decorator1 ... @decorator2 ... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation': ... pass ... """), indent=4)) Module( body=[ FunctionDef( name='f', args=arguments( posonlyargs=[], args=[ arg( arg='a', annotation=Constant(value='annotation')), arg(arg='b'), arg(arg='c')], vararg=arg(arg='d'), kwonlyargs=[ arg(arg='e'), arg(arg='f')], kw_defaults=[ None, Constant(value=3)], kwarg=arg(arg='g'), defaults=[ Constant(value=1), Constant(value=2)]), body=[ Pass()], decorator_list=[ Name(id='decorator1', ctx=Load()), Name(id='decorator2', ctx=Load())], returns=Constant(value='return annotation'), type_params=[])], type_ignores=[])
- class ast.Return(value)¶
Uma instrução
return
.>>> print(ast.dump(ast.parse('return 4'), indent=4)) Module( body=[ Return( value=Constant(value=4))], type_ignores=[])
- class ast.Yield(value)¶
- class ast.YieldFrom(value)¶
Uma expressão
yield
ouyield from
. Por serem expressões, elas devem ser agrupadas em um nóExpr
se o valor enviado de volta não for usado.>>> print(ast.dump(ast.parse('yield x'), indent=4)) Module( body=[ Expr( value=Yield( value=Name(id='x', ctx=Load())))], type_ignores=[]) >>> print(ast.dump(ast.parse('yield from x'), indent=4)) Module( body=[ Expr( value=YieldFrom( value=Name(id='x', ctx=Load())))], type_ignores=[])
- class ast.Global(names)¶
- class ast.Nonlocal(names)¶
Instruções
global
enonlocal
.names
é uma lista de strings brutas.>>> print(ast.dump(ast.parse('global x,y,z'), indent=4)) Module( body=[ Global( names=[ 'x', 'y', 'z'])], type_ignores=[]) >>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4)) Module( body=[ Nonlocal( names=[ 'x', 'y', 'z'])], type_ignores=[])
- class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)¶
Uma definição de classe
name
é uma string bruta para o nome da classebases
é uma lista de nós para classes base especificadas explicitamente.keywords
é uma lista de nóskeyword
, principalmente para ‘metaclass’. Outras argumentos nomeados serão passadas para a metaclasse, conforme a PEP 3115.body
é uma lista de nós que representam o código dentro da definição de classe.decorator_list
é uma lista de nós, como emFunctionDef
.type_params
é uma lista de parâmetros de tipo.
>>> print(ast.dump(ast.parse("""\ ... @decorator1 ... @decorator2 ... class Foo(base1, base2, metaclass=meta): ... pass ... """), indent=4)) Module( body=[ ClassDef( name='Foo', bases=[ Name(id='base1', ctx=Load()), Name(id='base2', ctx=Load())], keywords=[ keyword( arg='metaclass', value=Name(id='meta', ctx=Load()))], body=[ Pass()], decorator_list=[ Name(id='decorator1', ctx=Load()), Name(id='decorator2', ctx=Load())], type_params=[])], type_ignores=[])
Alterado na versão 3.12: Adicionado
type_params
.
Async e await¶
- class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)¶
Uma definição de função
async def
. Possui os mesmos campos queFunctionDef
.Alterado na versão 3.12: Adicionado
type_params
.
- class ast.Await(value)¶
Uma expressão
await
.value
é o que ela espera. Válido apenas no corpo de umAsyncFunctionDef
.
>>> print(ast.dump(ast.parse("""\
... async def f():
... await other_func()
... """), indent=4))
Module(
body=[
AsyncFunctionDef(
name='f',
args=arguments(
posonlyargs=[],
args=[],
kwonlyargs=[],
kw_defaults=[],
defaults=[]),
body=[
Expr(
value=Await(
value=Call(
func=Name(id='other_func', ctx=Load()),
args=[],
keywords=[])))],
decorator_list=[],
type_params=[])],
type_ignores=[])
- class ast.AsyncFor(target, iter, body, orelse, type_comment)¶
- class ast.AsyncWith(items, body, type_comment)¶
Laços
async for
e gerenciadores de contextoasync with
. Eles têm os mesmos campos queFor
eWith
, respectivamente. Válido apenas no corpo deAsyncFunctionDef
.
Nota
Quando uma string é analisada por ast.parse()
, os nós operadores (subclasses de ast.operator
, ast.unaryop
, ast.cmpop
, ast.boolop
e ast.expr_context
) na árvore retornada serão singletons. As alterações em um serão refletidas em todas as outras ocorrências do mesmo valor (por exemplo, ast.Add
).
Auxiliares de ast
¶
Além das classes de nós, o módulo ast
define essas funções e classes utilitárias para percorrer árvores de sintaxe abstrata:
- ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None)¶
Analisa a fonte em um nó AST. Equivalente a
compile(source, filename, mode, ast.PyCF_ONLY_AST)
.Se
type_comments=True
é fornecido, o analisador é modificado para verificar e retornar comentários do tipo, conforme especificado por PEP 484 e PEP 526. Isso é equivalente a adicionarast.PyCF_TYPE_COMMENTS
aos sinalizadores passados paracompile()
. Isso relatará erros de sintaxe para comentários do tipo extraviado. Sem esse sinalizador, os comentários do tipo serão ignorados e o campotype_comment
nos nós AST selecionados sempre seráNone
. Além disso, os locais dos comentários# type: ignore
serão retornados como o atributotype_ignores
deModule
(caso contrário, é sempre uma lista vazia).Além disso, se
mode
for'func_type'
, a sintaxe de entrada é modificada para corresponder a “comentários de tipo de assinatura” de PEP 484, por exemplo,(str, int) -> List[str]
.Setting
feature_version
to a tuple(major, minor)
will result in a “best-effort” attempt to parse using that Python version’s grammar. For example, settingfeature_version=(3, 9)
will attempt to disallow parsing ofmatch
statements. Currentlymajor
must equal to3
. The lowest supported version is(3, 4)
(and this may increase in future Python versions); the highest issys.version_info[0:2]
. “Best-effort” attempt means there is no guarantee that the parse (or success of the parse) is the same as when run on the Python version corresponding tofeature_version
.Se a fonte contém um caractere nulo (
\0
),ValueError
é levantada.Aviso
Observe que a análise bem-sucedida do código-fonte em um objeto AST não garante que o código-fonte fornecido seja um código Python válido que pode ser executado, pois a etapa de compilação pode levantar mais exceções
SyntaxError
. Por exemplo, a fontereturn 42
gera um nó AST válido para uma instrução return, mas não pode ser compilado sozinho (precisa estar dentro de um nó de função).Em particular,
ast.parse()
não fará nenhuma verificação de escopo, o que a etapa de compilação faz.Aviso
É possível travar o interpretador Python com uma string suficientemente grande/complexa devido às limitações de profundidade da pilha no compilador de AST do Python.
Alterado na versão 3.8: Adicionado
type_comments
,mode='func_type'
efeature_version
.
- ast.unparse(ast_obj)¶
Desfaz análise de um objeto
ast.AST
e gera uma string com código que produziria um objetoast.AST
equivalente se analisado novamente comast.parse()
.Aviso
A string de código produzida não será necessariamente igual ao código original que gerou o objeto
ast.AST
(sem quaisquer otimizações do compilador, como tuplas/frozensets constantes).Aviso
Tentar desfazer análise de uma expressão altamente complexa resultaria em
RecursionError
.Adicionado na versão 3.9.
- ast.literal_eval(node_or_string)¶
Avalia um nó de expressão ou uma string contendo apenas um literal Python ou uma exibição de contêiner. A string ou nó fornecido pode consistir apenas nas seguintes estruturas literais Python: strings, bytes, números, tuplas, listas, dicionários, conjuntos, booleanos,
None
eEllipsis
.Isso pode ser usado para avaliar strings contendo valores Python sem a necessidade de analisar os valores por conta própria. Não é capaz de avaliar expressões arbitrariamente complexas, por exemplo, envolvendo operadores ou indexação.
Esta função foi documentada como “segura” no passado sem definir o que isso significava. Isso foi enganoso. Isso foi projetado especificamente para não executar código Python, ao contrário do
eval()
mais geral. Não há espaço de nomes, pesquisas de nome ou capacidade de chamada. Mas não está livre de ataques: uma entrada relativamente pequena pode levar ao esgotamento da memória ou ao esgotamento da pilha C, travando o processo. Também existe a possibilidade de negação de serviço por consumo excessivo de CPU em algumas entradas. Portanto, não é recomendado chamá-la em dados não confiáveis.Aviso
É possível travar o interpretador Python devido às limitações de profundidade da pilha no compilador AST do Python.
Pode levantar
ValueError
,TypeError
,SyntaxError
,MemoryError
eRecursionError
dependendo da entrada malformada.Alterado na versão 3.2: Agora permite bytes e literais de conjuntos.
Alterado na versão 3.9: Agora oferece suporte à criação de conjuntos vazios com
'set()'
.Alterado na versão 3.10: Para entradas de string, os espaços iniciais e tabulações agora são removidos.
- ast.get_docstring(node, clean=True)¶
Retorna a docstring do node dado (que deve ser um nó
FunctionDef
,AsyncFunctionDef
,ClassDef
ouModule
) ouNone
se não tiver uma docstring. Se clean for verdadeiro, limpa o recuo da docstring cominspect.cleandoc()
.Alterado na versão 3.5: Não há suporte a
AsyncFunctionDef
.
- ast.get_source_segment(source, node, *, padded=False)¶
Obtém o segmento de código-fonte do source que gerou o node. Se alguma informação de localização (
lineno
,end_lineno
,col_offset
ouend_col_offset
) está faltando, retornaNone
.Se padded for
True
, a primeira linha de uma instrução multilinha será preenchida com espaços para corresponder à sua posição original.Adicionado na versão 3.8.
- ast.fix_missing_locations(node)¶
Quando você compila uma árvore de nós com
compile()
, o compilador espera atributoslineno
ecol_offset
para cada nó que os suporta. Isso é tedioso para preencher nós gerados, portanto, esse auxiliar adiciona esses atributos recursivamente, onde ainda não estão definidos, definindo-os para os valores do nó pai. Ele funciona recursivamente a partir do node.
- ast.increment_lineno(node, n=1)¶
Incrementa o número da linhas e o número da linha final de cada nó na árvore começando em node em n. Isso é útil para “mover código” para um local diferente em um arquivo.
- ast.copy_location(new_node, old_node)¶
Copia o local de origem (
lineno
,col_offset
,end_lineno
eend_col_offset
) de old_node para new_node se possível e, então, retorna new_node.
- ast.iter_fields(node)¶
Produz uma tupla de
(fieldname, value)
para cada campo emnode._fields
que esteja presente em node.
- ast.iter_child_nodes(node)¶
Produz todos os nós filhos diretos de node, ou seja, todos os campos que são nós e todos os itens de campos que são listas de nós.
- ast.walk(node)¶
Produz recursivamente todos os nós descendentes na árvore começando em node (incluindo o próprio node), em nenhuma ordem especificada. Isso é útil se você quiser apenas modificar nós no lugar e não se importar com o contexto.
- class ast.NodeVisitor¶
Uma classe base de visitante de nó que percorre a árvore de sintaxe abstrata e chama uma função de visitante para cada nó encontrado. Esta função pode retornar um valor que é encaminhado pelo método
visit()
.Esta classe deve ser uma subclasse, com a subclasse adicionando métodos visitantes.
- visit(node)¶
Visita um nó. A implementação padrão chama o método chamado
self.visit_nomedaclasse
sendo nomedaclasse o nome da classe do nó, ougeneric_visit()
se aquele método não existir.
- generic_visit(node)¶
Este visitante chama
visit()
em todos os filhos do nó.Observe que nós filhos de nós que possuem um método de visitante personalizado não serão visitados, a menos que o visitante chame
generic_visit()
ou os visite por conta própria.
- visit_Constant(node)¶
Manipula todos os nós constantes.
Não use o
NodeVisitor
se você quiser aplicar mudanças nos nós durante a travessia. Para isso existe um visitante especial (NodeTransformer
) que permite modificações.Obsoleto desde a versão 3.8: Os métodos
visit_Num()
,visit_Str()
,visit_Bytes()
,visit_NameConstant()
evisit_Ellipsis()
estão agora descontinuados e não serão chamados em futuras versões do Python. Adicione um métodovisit_Constant()
para lidar com nós de constantes.
- class ast.NodeTransformer¶
A subclasse
NodeVisitor
que percorre a árvore de sintaxe abstrata e permite a modificação de nós.O
NodeTransformer
percorrerá a AST e usará o valor de retorno dos métodos do visitante para substituir ou remover o nó antigo. Se o valor de retorno do método visitante forNone
, o nó será removido de seu local, caso contrário, ele será substituído pelo valor de retorno. O valor de retorno pode ser o nó original, caso em que não há substituição.Aqui está um exemplo de transformador que rescreve todas as ocorrências de procuras por nome (
foo
) paradata['foo']
:class RewriteName(NodeTransformer): def visit_Name(self, node): return Subscript( value=Name(id='data', ctx=Load()), slice=Constant(value=node.id), ctx=node.ctx )
Tenha em mente que, se o nó em que você está operando tiver nós filhos, você deve transformar os nós filhos por conta própria ou chamar o método
generic_visit()
para o nó primeiro.Para nós que faziam parte de uma coleção de instruções (que se aplica a todos os nós de instrução), o visitante também pode retornar uma lista de nós em vez de apenas um único nó.
Se
NodeTransformer
introduz novos nós (que não faziam parte da árvore original) sem fornecer informações de localização (comolineno
),fix_missing_locations()
deve ser chamado com o novo subárvore para recalcular as informações de localização:tree = ast.parse('foo', mode='eval') new_tree = fix_missing_locations(RewriteName().visit(tree))
Normalmente você usa o transformador assim:
node = YourTransformer().visit(node)
- ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None)¶
Retorne um despejo formatado da árvore em node. Isso é útil principalmente para fins de depuração. Se annotate_fields for verdadeiro (por padrão), a sequência retornada mostrará os nomes e os valores para os campos. Se annotate_fields for falso, a sequência de resultados será mais compacta ao omitir nomes de campos não ambíguos. Atributos como números de linha e deslocamentos de coluna não são despejados por padrão. Se isso for desejado, include_attributes pode ser definido como verdadeiro.
Se indent for um inteiro não negativo ou uma string, então a árvore terá uma saída formatada com este nível de indentação. Um nível de indentação 0, negativo ou
""
apenas colocará novas linhas.None
(o padrão) seleciona a representação de uma única linha. Usando um inteiro positivo a indentação terá alguns espaços por nível. Se indent for uma string (como"\t"
), essa string será usada para indentar cada nível.Alterado na versão 3.9: Adicionada a opção indent.
Sinalizadores do compilador¶
Os seguintes sinalizadores podem ser passados para compile()
para alterar os efeitos na compilação de um programa:
- ast.PyCF_ALLOW_TOP_LEVEL_AWAIT¶
Habilita suporte para
await
,async for
,async with
e compreensões assíncronas de nível superior.Adicionado na versão 3.8.
- ast.PyCF_ONLY_AST¶
Gera e retorna uma árvore de sintaxe abstrata em vez de retornar um objeto de código compilado.
Uso na linha de comando¶
Adicionado na versão 3.9.
O módulo ast
pode ser executado como um script na linha de comando. É tão simples quanto:
python -m ast [-m <mode>] [-a] [infile]
As seguintes opções são aceitas:
- -h, --help¶
Mostra a mensagem de ajuda e sai.
- -m <mode>¶
- --mode <mode>¶
Especifica que tipo de código deve ser compilado, como o argumento mode em
parse()
.
- --no-type-comments¶
Não analisa comentários de tipo.
- -a, --include-attributes¶
Inclui atributos como números de linha e deslocamentos de colunas.
Se infile
for especificado, seu conteúdo será analisado no AST e despejado no stdout. Caso contrário, o conteúdo será lido em stdin.
Ver também
Green Tree Snakes, um recurso de documentação externo, possui bons detalhes sobre trabalhar com ASTs do Python.
ASTTokens anota ASTs do Python com as posições de tokens e texto no código-fonte que as gerou. Isso é útil para ferramentas que fazem transformações de código-fonte.
leoAst.py unifica as visualizações baseadas em token e em árvore de análise de programas python, inserindo links duas vias entre tokens e nós de ast.
LibCST analisa o código como uma árvore de sintaxe concreta que se parece com uma árvore ast e mantém todos os detalhes de formatação. É útil para construir linters e aplicações de refatoração automatizada (codemod).
Parso é um analisador Python que oferece suporte a recuperação de erros e análise de ida e volta para diferentes versões do Python (em várias versões do Python). Parso também é capaz de listar vários erros de sintaxe em seu arquivo Python.