"ast" --- Abstract Syntax Trees
*******************************

**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, expr? default_value)
                  | ParamSpec(identifier name, expr? default_value)
                  | TypeVarTuple(identifier name, expr? default_value)
                  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 no "ast".

   Há uma classe definida para cada símbolo do lado esquerdo na
   gramática abstrata (por exemplo, "ast.stmt" ou "ast.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 de "ast.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

      Each concrete class has an attribute "_fields" which gives the
      names of all child nodes.

      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 atributo "left" do tipo
      "ast.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 com "compile()".

   _field_types

      The "_field_types" attribute on each concrete class is a
      dictionary mapping field names (as also listed in "_fields") to
      their types.

         >>> ast.TypeVar._field_types
         {'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr | None}

      Adicionado na versão 3.13.

   lineno
   col_offset
   end_lineno
   end_col_offset

      As instâncias das subclasses "ast.expr" e "ast.stmt" possuem os
      atributos "lineno", "col_offset", "end_lineno" e
      "end_col_offset". O "lineno" e "end_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 o "col_offset"
      e "end_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
   usar

      node = ast.UnaryOp(ast.USub(), ast.Constant(5, lineno=0, col_offset=0),
                         lineno=0, col_offset=0)

   If a field that is optional in the grammar is omitted from the
   constructor, it defaults to "None". If a list field is omitted, it
   defaults to the empty list. If a field of type "ast.expr_context"
   is omitted, it defaults to "Load()". If any other field is omitted,
   a "DeprecationWarning" is raised and the AST node will not have
   this field. In Python 3.15, this condition will raise an error.

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.

Descontinuado desde a versão 3.13, será removido na versão 3.15:
Previous versions of Python allowed the creation of AST nodes that
were missing required fields. Similarly, AST node constructors allowed
arbitrary keyword arguments that were set as attributes of the AST
node, even if they did not match any of the fields of the AST node.
This behavior is deprecated and will be removed in Python 3.15.

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* é uma "list" das Instruções do módulo.

   *type_ignores* é uma "list" dos comentários de ignorar tipo do
   módulo; veja "ast.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))])

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* é uma "list" 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):
          # type: (int, int) -> int
          return a + b

   *argtypes* é uma "list" 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 literal "Constant" contém
   o objeto Python que ele representa. Os valores representados podem
   ser tipos simples como um número, string ou "None", 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 string

     * 114: "!r" formatação de repr

     * 97: "!a" formatação ascii

   * "format_spec" é um nó "JoinedStr" que representa a formatação do
     valor, ou "None" se nenhum formato foi especificado. Tanto
     "conversion" quanto "format_spec" podem ser configurados ao mesmo
     tempo.

class ast.JoinedStr(values)

   Uma f-string, compreendendo uma série de nós "FormattedValue" e
   "Constant".

      >>> 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())]),
                      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"), e "Load" 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" e "values" contêm listas de nós que
   representam as chaves e os valores respectivamente, em ordem
   correspondente (o que seria retornado ao chamar "dictionary.keys()"
   e "dictionary.values()").

   Ao descompactar o dicionário usando literais de dicionário, a
   expressão a ser expandida vai para a lista "values", com um "None"
   na posição correspondente em "keys".

      >>> 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 e "ctx" é
   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()))])

      >>> print(ast.dump(ast.parse('a = 1'), indent=4))
      Module(
          body=[
              Assign(
                  targets=[
                      Name(id='a', ctx=Store())],
                  value=Constant(value=1))])

      >>> print(ast.dump(ast.parse('del a'), indent=4))
      Module(
          body=[
              Delete(
                  targets=[
                      Name(id='a', ctx=Del())])])

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()))])


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", um "Name", um
   "Lambda", um "Yield" ou "YieldFrom".

      >>> print(ast.dump(ast.parse('-a'), indent=4))
      Module(
          body=[
              Expr(
                  value=UnaryOp(
                      op=USub(),
                      operand=Name(id='a', ctx=Load())))])

class ast.UnaryOp(op, operand)

   Uma operação unária. "op" é o operador e "operand" 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 reservada "not",
   "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, e
   "left" e "right" 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" ou "And".
   "values" são os valores envolvidos. Operações consecutivas com o
   mesmo operador, como "a or b or c", são recolhidas em um nó com
   vários valores.

   Isso não inclui "not", que é um "UnaryOp".

      >>> 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.And
class ast.Or

   Tokens de operador booleano.

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 e "comparators" 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
   objeto "Name" ou "Attribute". Dos argumentos:

   * "args" contém uma lista dos argumentos passados ​​por posição.

   * "keywords" contém uma lista de objetos "keyword" representando
     argumentos passados como nomeados.

   The "args" and "keywords" arguments are optional and default to
   empty lists.

      >>> 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ós "Name".

      >>> 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 um "Name". "attr" é uma string simples fornecendo o
   nome do atributo, e "ctx" é "Load", "Store" ou "Del" 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 ambos "target" e "value" 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 uma "Tuple" e conter uma "Slice". "ctx" é "Load", "Store" ou
   "Del" 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" ou
   "lower:upper:step"). Pode ocorrer apenas dentro do campo *slice* de
   "Subscript", diretamente ou como um elemento de "Tuple".

      >>> 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" (ou "key" e "value") é um único nó que representa
   a parte que será avaliada para cada item.

   "generators" é uma lista de nós de "comprehension".

      >>> 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()),
                      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()),
                      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()),
                      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" ou "Tuple".
   "iter" é o objeto sobre o qual iterar. "ifs" é uma lista de
   expressões de teste: cada cláusula "for" pode ter múltiplos "ifs".

   "is_async" indica que uma compreensão é assíncrona (usando um
   "async for" em vez de "for"). 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())]),
              generators=[
                  comprehension(
                      target=Name(id='line', ctx=Store()),
                      iter=Name(id='file', ctx=Load()),
                      is_async=0),
                  comprehension(
                      target=Name(id='c', ctx=Store()),
                      iter=Name(id='line', ctx=Load()),
                      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()),
                      is_async=1)]))


Instruções
----------

class ast.Assign(targets, value, type_comment)

   Uma atribuição. "targets" é uma lista de nós e "value" é um único
   nó.

   Vários nós em "targets" representam a atribuição do mesmo valor a
   cada um. A descompactação é representada colocando uma "Tuple" ou
   "List" dentro de "targets".

   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))])

      >>> 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()))])

class ast.AnnAssign(target, annotation, value, simple)

   An assignment with a type annotation. "target" is a single node and
   can be a "Name", a "Attribute" or a "Subscript". "annotation" is
   the annotation, such as a "Constant" or "Name" node. "value" is a
   single optional node.

   "simple" is always either 0 (indicating a "complex" target) or 1
   (indicating a "simple" target). A "simple" target consists solely
   of a "Name" node that does not appear between parentheses; all
   other targets are considered complex. Only simple targets appear in
   the "__annotations__" dictionary of modules and 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)])

      >>> 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)])

      >>> 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)])

      >>> 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)])

class ast.AugAssign(target, op, value)

   Atribuição aumentada, como "a += 1". No exemplo a seguir, "target"
   é um nó "Name" para "x" (com o contexto "Store"), "op" é "Add", e
   "value" é uma "Constant" com valor para 1.

   O atributo "target" não pode ser da classe "Tuple" ou "List",
   diferentemente dos alvos de "Assign".

      >>> print(ast.dump(ast.parse('x += 2'), indent=4))
      Module(
          body=[
              AugAssign(
                  target=Name(id='x', ctx=Store()),
                  op=Add(),
                  value=Constant(value=2))])

class ast.Raise(exc, cause)

   Uma instrução "raise". "exc" é o objeto de exceção a ser levantado,
   normalmente uma "Call" ou "Name", ou "None" para um "raise"
   independente. "cause" é a parte opcional para "y" em "raise 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()))])

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()))])

class ast.Delete(targets)

   Representa uma instrução "del". "targets" é uma lista de nós, como
   nós "Name", "Attribute" ou "Subscript".

      >>> 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())])])

class ast.Pass

   Uma instrução "pass".

      >>> print(ast.dump(ast.parse('pass'), indent=4))
      Module(
          body=[
              Pass()])

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, e
   "value" é 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()),
                  value=Name(id='int', ctx=Load()))])

   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 de "alias".

      >>> print(ast.dump(ast.parse('import x,y,z'), indent=4))
      Module(
          body=[
              Import(
                  names=[
                      alias(name='x'),
                      alias(name='y'),
                      alias(name='z')])])

class ast.ImportFrom(module, names, level)

   Representa "from x import y". "module" é uma string bruta do nome
   'from', sem quaisquer pontos iniciais, ou "None" para instruções
   como "from . 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)])

class ast.alias(name, asname)

   Ambos os parâmetros são strings brutas dos nomes. "asname" pode ser
   "None" 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)])


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" e "orelse" 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 de "If" dentro da seção "orelse" 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))])])])

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ó de "Name", "Tuple", "List", "Attribute"
   ou "Subscript". "iter" contém o item a ser repetido, novamente como
   um único nó. "body" e "orelse" contêm listas de nós para executar.
   Aqueles em "orelse" são executados se o laço terminar normalmente,
   ao invés de através de uma instrução "break".

   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))])])

class ast.While(test, body, orelse)

   Um laço "while". "test" contém a condição, como um nó de "Compare".

      >> 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))])])

class ast.Break
class ast.Continue

   As instruções "break" e "continue".

      >>> 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()])])])

class ast.Try(body, handlers, orelse, finalbody)

   Blocos "try". Todos os atributos são uma lista de nós a serem
   executados, exceto "handlers", que é uma lista de nós de
   "ExceptHandler".

      >>> 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))])])

class ast.TryStar(body, handlers, orelse, finalbody)

   Blocos "try" que são seguidos por cláusulas "except*". Os atributos
   são os mesmos de "Try", mas os nós "ExceptHandler" em "handlers"
   são interpretados como blocos "except*" em vez de "except".

      >>> 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))])])])

   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ó de "Name" (ou "None" para uma
   cláusula abrangente "except:"). "name" é uma string bruta para o
   nome conter a exceção, ou "None" se a cláusula não tiver "as 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()])])])

class ast.With(items, body, type_comment)

   Um bloco "with". "items" é uma lista de nós "withitem"
   representando os gerenciadores de contexto, e "body" é 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ó de "Call".
   "optional_vars" é um "Name", "Tuple" ou "List" para a parte "as
   foo", ou "None" 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())]))])])


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) e
   "cases" contém um iterável de nós de "match_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ós "AST" 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())),
                          body=[
                              Expr(
                                  value=Constant(value=Ellipsis))])])])

   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))])])])

   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" ou
   "False". 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))])])])

   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))])])])

   Adicionado na versão 3.10.

class ast.MatchStar(name)

   Matches the rest of the sequence in a variable length match
   sequence pattern. If "name" is not "None", a list containing the
   remaining sequence elements is bound to that name if the overall
   sequence pattern is successful.

      >>> 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))])])])

   Adicionado na versão 3.10.

class ast.MatchMapping(keys, patterns, rest)

   A match mapping pattern. "keys" is a sequence of expression nodes.
   "patterns" is a corresponding sequence of pattern nodes. "rest" is
   an optional name that can be specified to capture the remaining
   mapping elements. Permitted key expressions are restricted as
   described in the match statement documentation.

   This pattern succeeds if the subject is a mapping, all evaluated
   key expressions are present in the mapping, and the value
   corresponding to each key matches the corresponding subpattern. If
   "rest" is not "None", a dict containing the remaining mapping
   elements is bound to that name if the overall mapping pattern is
   successful.

      >>> 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(rest='rest'),
                          body=[
                              Expr(
                                  value=Constant(value=Ellipsis))])])])

   Adicionado na versão 3.10.

class ast.MatchClass(cls, patterns, kwd_attrs, kwd_patterns)

   A match class pattern. "cls" is an expression giving the nominal
   class to be matched. "patterns" is a sequence of pattern nodes to
   be matched against the class defined sequence of pattern matching
   attributes. "kwd_attrs" is a sequence of additional attributes to
   be matched (specified as keyword arguments in the class pattern),
   "kwd_patterns" are the corresponding patterns (specified as keyword
   values in the class pattern).

   This pattern succeeds if the subject is an instance of the
   nominated class, all positional patterns match the corresponding
   class-defined attributes, and any specified keyword attributes
   match their corresponding pattern.

   Note: classes may define a property that returns self in order to
   match a pattern node against the instance being matched. Several
   builtin types are also matched that way, as described in the match
   statement documentation.

      >>> 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))]),
                          body=[
                              Expr(
                                  value=Constant(value=Ellipsis))]),
                      match_case(
                          pattern=MatchClass(
                              cls=Name(id='Point3D', ctx=Load()),
                              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))])])])

   Adicionado na versão 3.10.

class ast.MatchAs(pattern, name)

   A match "as-pattern", capture pattern or wildcard pattern.
   "pattern" contains the match pattern that the subject will be
   matched against. If the pattern is "None", the node represents a
   capture pattern (i.e a bare name) and will always succeed.

   The "name" attribute contains the name that will be bound if the
   pattern is successful. If "name" is "None", "pattern" must also be
   "None" and the node represents the wildcard pattern.

      >>> 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))])])])

   Adicionado na versão 3.10.

class ast.MatchOr(patterns)

   A match "or-pattern". An or-pattern matches each of its subpatterns
   in turn to the subject, until one succeeds. The or-pattern is then
   deemed to succeed. If none of the subpatterns succeed the or-
   pattern fails. The "patterns" attribute contains a list of match
   pattern nodes that will be matched against the subject.

      >>> 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))])])])

   Adicionado na versão 3.10.


Parâmetros de tipo
------------------

Type parameters can exist on classes, functions, and type aliases.

class ast.TypeVar(name, bound, default_value)

   A "typing.TypeVar". *name* is the name of the type variable.
   *bound* is the bound or constraints, if any. If *bound* is a
   "Tuple", it represents constraints; otherwise it represents the
   bound. *default_value* is the default value; if the "TypeVar" has
   no default, this attribute will be set to "None".

      >>> print(ast.dump(ast.parse("type Alias[T: int = bool] = list[T]"), indent=4))
      Module(
          body=[
              TypeAlias(
                  name=Name(id='Alias', ctx=Store()),
                  type_params=[
                      TypeVar(
                          name='T',
                          bound=Name(id='int', ctx=Load()),
                          default_value=Name(id='bool', ctx=Load()))],
                  value=Subscript(
                      value=Name(id='list', ctx=Load()),
                      slice=Name(id='T', ctx=Load()),
                      ctx=Load()))])

   Adicionado na versão 3.12.

   Alterado na versão 3.13: Added the *default_value* parameter.

class ast.ParamSpec(name, default_value)

   A "typing.ParamSpec". *name* is the name of the parameter
   specification. *default_value* is the default value; if the
   "ParamSpec" has no default, this attribute will be set to "None".

      >>> print(ast.dump(ast.parse("type Alias[**P = (int, str)] = Callable[P, int]"), indent=4))
      Module(
          body=[
              TypeAlias(
                  name=Name(id='Alias', ctx=Store()),
                  type_params=[
                      ParamSpec(
                          name='P',
                          default_value=Tuple(
                              elts=[
                                  Name(id='int', ctx=Load()),
                                  Name(id='str', ctx=Load())],
                              ctx=Load()))],
                  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()))])

   Adicionado na versão 3.12.

   Alterado na versão 3.13: Added the *default_value* parameter.

class ast.TypeVarTuple(name, default_value)

   A "typing.TypeVarTuple". *name* is the name of the type variable
   tuple. *default_value* is the default value; if the "TypeVarTuple"
   has no default, this attribute will be set to "None".

      >>> 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',
                          default_value=Tuple(ctx=Load()))],
                  value=Subscript(
                      value=Name(id='tuple', ctx=Load()),
                      slice=Tuple(
                          elts=[
                              Starred(
                                  value=Name(id='Ts', ctx=Load()),
                                  ctx=Load())],
                          ctx=Load()),
                      ctx=Load()))])

   Adicionado na versão 3.12.

   Alterado na versão 3.13: Added the *default_value* parameter.


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" is a raw string of the function name.

   * "args" é um nó "arguments".

   * "body" is the list of nodes inside the function.

   * "decorator_list" is the list of decorators to be applied, stored
     outermost first (i.e. the first in the list will be applied
     last).

   * "returns" is the return annotation.

   * "type_params" is a list of type parameters.

   type_comment

      "type_comment" é uma string opcional com a anotação de tipo como
      comentário.

   Alterado na versão 3.12: Added "type_params".

class ast.Lambda(args, body)

   "lambda" is a minimal function definition that can be used inside
   an expression. Unlike "FunctionDef", "body" holds a single node.

      >>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))
      Module(
          body=[
              Expr(
                  value=Lambda(
                      args=arguments(
                          args=[
                              arg(arg='x'),
                              arg(arg='y')]),
                      body=Constant(value=Ellipsis)))])

class ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)

   The arguments for a function.

   * "posonlyargs", "args" and "kwonlyargs" are lists of "arg" nodes.

   * "vararg" and "kwarg" are single "arg" nodes, referring to the
     "*args, **kwargs" parameters.

   * "kw_defaults" is a list of default values for keyword-only
     arguments. If one is "None", the corresponding argument is
     required.

   * "defaults" is a list of default values for arguments that can be
     passed positionally. If there are fewer defaults, they correspond
     to the last n arguments.

class ast.arg(arg, annotation, type_comment)

   A single argument in a list. "arg" is a raw string of the argument
   name; "annotation" is its annotation, such as a "Name" node.

   type_comment

      "type_comment" is an optional string with the type annotation as
      a comment

      >>> 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(
                      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'))])

class ast.Return(value)

   A "return" statement.

      >>> print(ast.dump(ast.parse('return 4'), indent=4))
      Module(
          body=[
              Return(
                  value=Constant(value=4))])

class ast.Yield(value)
class ast.YieldFrom(value)

   A "yield" or "yield from" expression. Because these are
   expressions, they must be wrapped in a "Expr" node if the value
   sent back is not used.

      >>> print(ast.dump(ast.parse('yield x'), indent=4))
      Module(
          body=[
              Expr(
                  value=Yield(
                      value=Name(id='x', ctx=Load())))])

      >>> print(ast.dump(ast.parse('yield from x'), indent=4))
      Module(
          body=[
              Expr(
                  value=YieldFrom(
                      value=Name(id='x', ctx=Load())))])

class ast.Global(names)
class ast.Nonlocal(names)

   "global" and "nonlocal" statements. "names" is a list of raw
   strings.

      >>> print(ast.dump(ast.parse('global x,y,z'), indent=4))
      Module(
          body=[
              Global(
                  names=[
                      'x',
                      'y',
                      'z'])])

      >>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))
      Module(
          body=[
              Nonlocal(
                  names=[
                      'x',
                      'y',
                      'z'])])

class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)

   Uma definição de classe

   * "name" is a raw string for the class name

   * "bases" is a list of nodes for explicitly specified base classes.

   * "keywords" is a list of "keyword" nodes, principally for
     'metaclass'. Other keywords will be passed to the metaclass, as
     per PEP-3115.

   * "body" is a list of nodes representing the code within the class
     definition.

   * "decorator_list" is a list of nodes, as in "FunctionDef".

   * "type_params" is a list of type parameters.

      >>> 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())])])

   Alterado na versão 3.12: Added "type_params".


Async e await
-------------

class ast.AsyncFunctionDef(name, args, body, decorator_list, returns, type_comment, type_params)

   An "async def" function definition. Has the same fields as
   "FunctionDef".

   Alterado na versão 3.12: Added "type_params".

class ast.Await(value)

   An "await" expression. "value" is what it waits for. Only valid in
   the body of an "AsyncFunctionDef".

   >>> print(ast.dump(ast.parse("""\
   ... async def f():
   ...     await other_func()
   ... """), indent=4))
   Module(
       body=[
           AsyncFunctionDef(
               name='f',
               args=arguments(),
               body=[
                   Expr(
                       value=Await(
                           value=Call(
                               func=Name(id='other_func', ctx=Load()))))])])

class ast.AsyncFor(target, iter, body, orelse, type_comment)
class ast.AsyncWith(items, body, type_comment)

   "async for" loops and "async with" context managers. They have the
   same fields as "For" and "With", respectively. Only valid in the
   body of an "AsyncFunctionDef".

Nota:

  When a string is parsed by "ast.parse()", operator nodes (subclasses
  of "ast.operator", "ast.unaryop", "ast.cmpop", "ast.boolop" and
  "ast.expr_context") on the returned tree will be singletons. Changes
  to one will be reflected in all other occurrences of the same value
  (e.g. "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, optimize=-1)

   Parse the source into an AST node.  Equivalent to "compile(source,
   filename, mode, flags=FLAGS_VALUE, optimize=optimize)", where
   "FLAGS_VALUE" is "ast.PyCF_ONLY_AST" if "optimize <= 0" and
   "ast.PyCF_OPTIMIZED_AST" otherwise.

   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 adicionar
   "ast.PyCF_TYPE_COMMENTS" aos sinalizadores passados para
   "compile()". Isso relatará erros de sintaxe para comentários do
   tipo extraviado. Sem esse sinalizador, os comentários do tipo serão
   ignorados e o campo "type_comment" nos nós AST selecionados sempre
   será "None". Além disso, os locais dos comentários "# type: ignore"
   serão retornados como o atributo "type_ignores" de "Module" (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, setting "feature_version=(3, 9)" will attempt
   to disallow parsing of "match" statements. Currently "major" must
   equal to "3". The lowest supported version is "(3, 7)" (and this
   may increase in future Python versions); the highest is
   "sys.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 to "feature_version".

   If source contains a null character ("\0"), "ValueError" is raised.

   Aviso:

     Note that successfully parsing source code into an AST object
     doesn't guarantee that the source code provided is valid Python
     code that can be executed as the compilation step can raise
     further "SyntaxError" exceptions. For instance, the source
     "return 42" generates a valid AST node for a return statement,
     but it cannot be compiled alone (it needs to be inside a function
     node).In particular, "ast.parse()" won't do any scoping checks,
     which the compilation step does.

   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'" e "feature_version".

   Alterado na versão 3.13: The minimum supported version for
   "feature_version" is now "(3, 7)". The "optimize" argument was
   added.

ast.unparse(ast_obj)

   Unparse an "ast.AST" object and generate a string with code that
   would produce an equivalent "ast.AST" object if parsed back with
   "ast.parse()".

   Aviso:

     The produced code string will not necessarily be equal to the
     original code that generated the "ast.AST" object (without any
     compiler optimizations, such as constant tuples/frozensets).

   Aviso:

     Trying to unparse a highly complex expression would result with
     "RecursionError".

   Adicionado na versão 3.9.

ast.literal_eval(node_or_string)

   Evaluate an expression node or a string containing only a Python
   literal or container display.  The string or node provided may only
   consist of the following Python literal structures: strings, bytes,
   numbers, tuples, lists, dicts, sets, booleans, "None" and
   "Ellipsis".

   This can be used for evaluating strings containing Python values
   without the need to parse the values oneself.  It is not capable of
   evaluating arbitrarily complex expressions, for example involving
   operators or indexing.

   This function had been documented as "safe" in the past without
   defining what that meant. That was misleading. This is specifically
   designed not to execute Python code, unlike the more general
   "eval()". There is no namespace, no name lookups, or ability to
   call out. But it is not free from attack: A relatively small input
   can lead to memory exhaustion or to C stack exhaustion, crashing
   the process. There is also the possibility for excessive CPU
   consumption denial of service on some inputs. Calling it on
   untrusted data is thus not recommended.

   Aviso:

     It is possible to crash the Python interpreter due to stack depth
     limitations in Python's AST compiler.It can raise "ValueError",
     "TypeError", "SyntaxError", "MemoryError" and "RecursionError"
     depending on the malformed input.

   Alterado na versão 3.2: Agora permite bytes e literais de
   conjuntos.

   Alterado na versão 3.9: Now supports creating empty sets with
   "'set()'".

   Alterado na versão 3.10: For string inputs, leading spaces and tabs
   are now stripped.

ast.get_docstring(node, clean=True)

   Retorna a docstring do *node* dado (que deve ser um nó
   "FunctionDef", "AsyncFunctionDef", "ClassDef" ou "Module") ou
   "None" se não tiver uma docstring. Se *clean* for verdadeiro, limpa
   o recuo da docstring com "inspect.cleandoc()".

   Alterado na versão 3.5: Não há suporte a "AsyncFunctionDef".

ast.get_source_segment(source, node, *, padded=False)

   Get source code segment of the *source* that generated *node*. If
   some location information ("lineno", "end_lineno", "col_offset", or
   "end_col_offset") is missing, return "None".

   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)

   When you compile a node tree with "compile()", the compiler expects
   "lineno" and "col_offset" attributes for every node that supports
   them.  This is rather tedious to fill in for generated nodes, so
   this helper adds these attributes recursively where not already
   set, by setting them to the values of the parent node.  It works
   recursively starting at *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)

   Copy source location ("lineno", "col_offset", "end_lineno", and
   "end_col_offset") from *old_node* to *new_node* if possible, and
   return *new_node*.

ast.iter_fields(node)

   Produz uma tupla de "(fieldname, value)" para cada campo em
   "node._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ó, ou "generic_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)

      Handles all constant nodes.

   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()" e
   "visit_Ellipsis()" estão agora descontinuados e não serão chamados
   em futuras versões do Python. Adicione um método "visit_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 for "None", 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") para "data['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 (como
   "lineno"), "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, show_empty=False)

   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.

   If *indent* is a non-negative integer or string, then the tree will
   be pretty-printed with that indent level.  An indent level of 0,
   negative, or """" will only insert newlines.  "None" (the default)
   selects the single line representation. Using a positive integer
   indent indents that many spaces per level.  If *indent* is a string
   (such as ""\t""), that string is used to indent each level.

   If *show_empty* is "False" (the default), empty lists and fields
   that are "None" will be omitted from the output.

   Alterado na versão 3.9: Added the *indent* option.

   Alterado na versão 3.13: Added the *show_empty* option.

      >>> print(ast.dump(ast.parse("""\
      ... async def f():
      ...     await other_func()
      ... """), indent=4, show_empty=True))
      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=[])


Compiler Flags
==============

The following flags may be passed to "compile()" in order to change
effects on the compilation of a program:

ast.PyCF_ALLOW_TOP_LEVEL_AWAIT

   Enables support for top-level "await", "async for", "async with"
   and async comprehensions.

   Adicionado na versão 3.8.

ast.PyCF_ONLY_AST

   Generates and returns an abstract syntax tree instead of returning
   a compiled code object.

ast.PyCF_OPTIMIZED_AST

   The returned AST is optimized according to the *optimize* argument
   in "compile()" or "ast.parse()".

   Adicionado na versão 3.13.

ast.PyCF_TYPE_COMMENTS

   Enables support for **PEP 484** and **PEP 526** style type comments
   ("# type: <type>", "# type: ignore <stuff>").

   Adicionado na versão 3.8.


Uso da linha de comando
=======================

Adicionado na versão 3.9.

The "ast" module can be executed as a script from the command line. It
is as simple as:

   python -m ast [-m <mode>] [-a] [infile]

As seguintes opções são aceitas:

-h, --help

   Show the help message and exit.

-m <mode>
--mode <mode>

   Specify what kind of code must be compiled, like the *mode*
   argument in "parse()".

--no-type-comments

   Don't parse type comments.

-a, --include-attributes

   Include attributes such as line numbers and column offsets.

-i <indent>
--indent <indent>

   Indentation of nodes in AST (number of spaces).

If "infile" is specified its contents are parsed to AST and dumped to
stdout.  Otherwise, the content is read from stdin.

Ver também:

  Green Tree Snakes, um recurso de documentação externo, possui bons
  detalhes sobre trabalhar com ASTs do Python.

  ASTTokens annotates Python ASTs with the positions of tokens and
  text in the source code that generated them. This is helpful for
  tools that make source code transformations.

  leoAst.py unifies the token-based and parse-tree-based views of
  python programs by inserting two-way links between tokens and ast
  nodes.

  LibCST parses code as a Concrete Syntax Tree that looks like an ast
  tree and keeps all formatting details. It's useful for building
  automated refactoring (codemod) applications and linters.

  Parso is a Python parser that supports error recovery and round-trip
  parsing for different Python versions (in multiple Python versions).
  Parso is also able to list multiple syntax errors in your Python
  file.
