"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)
             | AsyncFunctionDef(identifier name, arguments args,
                                stmt* body, expr* decorator_list, expr? returns,
                                string? type_comment)

             | ClassDef(identifier name,
                expr* bases,
                keyword* keywords,
                stmt* body,
                expr* decorator_list)
             | Return(expr? value)

             | Delete(expr* targets)
             | Assign(expr* targets, expr value, string? type_comment)
             | 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)
             | 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)
   }


Classes de nós
==============

class ast.AST

   This is the base of all AST node classes.  The actual node classes
   are derived from the "Parser/Python.asdl" file, which is reproduced
   above.  They are defined in the "_ast" C module and re-exported in
   "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

      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 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()".

   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()
      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: Old classes "ast.Num", "ast.Str",
"ast.Bytes", "ast.NameConstant" and "ast.Ellipsis" are still
available, but they will be removed in future Python releases.  In the
meantime, instantiating them will return an instance of a different
class.

Obsoleto desde a versão 3.9: Old classes "ast.Index" and
"ast.ExtSlice" are still available, but they will be removed in future
Python releases. In the meantime, instantiating them will return an
instance of a different class.

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.


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())],
                          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"), 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 desempacotar 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()))],
          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", 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())))],
          type_ignores=[])

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, starargs, kwargs)

   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" holds a list of "keyword" objects representing
     arguments passed by keyword.

   When creating a "Call" node, "args" and "keywords" are required,
   but they can be empty lists. "starargs" and "kwargs" are optional.

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


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()),
                      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" 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())],
                  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 e "value" é um único
   nó.

   Vários nós em "targets" representam a atribuição do mesmo valor a
   cada um. O desempacotamento é 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))],
          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 um "Name", um "Attribute" ou um "Subscript". "annotation"
   é a anotação, como um nó de "Constant" ou "Name". "value" é um
   único nó opcional. "simple" é um inteiro booleano definido como
   True para um nó "Name" em "target" que não aparece entre parênteses
   e são, portanto, nomes puros e não expressões.

      >>> 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" 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))],
          type_ignores=[])

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()))],
          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ó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())])],
          type_ignores=[])

class ast.Pass

   Uma instrução "pass".

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

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')])],
          type_ignores=[])

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)],
          type_ignores=[])

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)],
          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" 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))])])],
          type_ignores=[])

class ast.For(target, iter, body, orelse, type_comment)

   A "for" loop. "target" holds the variable(s) the loop assigns to,
   as a single "Name", "Tuple" or "List" node. "iter" holds the item
   to be looped over, again as a single node. "body" and "orelse"
   contain lists of nodes to execute. Those in "orelse" are executed
   if the loop finishes normally, rather than via a "break" statement.

   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ó 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))])],
          type_ignores=[])

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()])],
                  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, 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))])],
          type_ignores=[])

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()])],
                  orelse=[],
                  finalbody=[])],
          type_ignores=[])

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())],
                              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) e
   "cases" contém um iterável de nós de "match_case" com os diferentes
   casos.

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()),
                              patterns=[],
                              kwd_attrs=[],
                              kwd_patterns=[]),
                          body=[
                              Expr(
                                  value=Constant(value=Ellipsis))])])],
          type_ignores=[])

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

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))])])],
          type_ignores=[])

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

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 for "None",
   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=[])

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 for "None", 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=[])

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

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 for "None", 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. Se "name" for "None", "pattern" também deverá ser
   "None" 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=[])

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


Definições de função e classe
-----------------------------

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

   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_comment

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

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 de "FunctionDef", "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" e "kwonlyargs" são listas de nós "arg".

   * "vararg" e "kwarg" são nós "arg" únicos, referindo-se aos
     parâmetros "*args, **kwargs".

   * "kw_defaults" é uma lista de valores padrão para argumentos
     somente-nomeados. Se um for "None", 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)

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

   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_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" ou "yield 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" e "nonlocal". "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, starargs, kwargs, body, decorator_list)

   Uma definição de classe

   * "name" é uma string bruta para o nome da classe

   * "bases" é uma lista de nós para classes base especificadas
     explicitamente.

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

   * "starargs" and "kwargs" are each a single node, as in a function
     call. starargs will be expanded to join the list of base classes,
     and kwargs will be passed to the metaclass.

   * "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 em "FunctionDef".

      >>> 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_ignores=[])


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

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

   Uma definição de função "async def". Possui os mesmos campos que
   "FunctionDef".

class ast.Await(value)

   Uma expressão "await". "value" é o que ela espera. Válido apenas no
   corpo de um "AsyncFunctionDef".

   >>> 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_ignores=[])

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

   Laços "async for" e gerenciadores de contexto "async with". Eles
   têm os mesmos campos que "For" e "With", respectivamente. Válido
   apenas no corpo de "AsyncFunctionDef".

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 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]".

   Além disso, definir "feature_version" como uma tupla "(maior,
   menor)" tentará analisar usando a gramática dessa versão do Python.
   Atualmente, "maior" deve ser igual a "3". Por exemplo, definir
   "feature_version=(3, 4)" permitirá o uso de "async" e "waitit" como
   nomes de variáveis. A versão mais baixa suportada é "(3, 4)"; a
   mais alta é "sys.version_info[0:2]".

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

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

ast.unparse(ast_obj)

   Desfaz análise de um objeto "ast.AST" e gera uma string com código
   que produziria um objeto "ast.AST" equivalente se analisado
   novamente com "ast.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".

   Novo 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" e "Ellipsis".

   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" e
     "RecursionError" 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" 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)

   Obtém o segmento de código-fonte de *source* que gerou *node*. Se
   algumas informações de local ("lineno", "end_lineno", "col_offset"
   ou "end_col_offset") estiverem faltando, retorna "None".

   Se *padded* for "True", a primeira linha de uma instrução
   multilinha será preenchida com espaços para corresponder à sua
   posição original.

   Novo na versão 3.8.

ast.fix_missing_locations(node)

   Quando você compila uma árvore de nós com "compile()", o compilador
   espera atributos "lineno" e "col_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" e
   "end_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 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.

   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)

   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.

   Novo 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.

ast.PyCF_TYPE_COMMENTS

   Habilita suporte para comentários do tipo **PEP 484** e **PEP 526**
   ("# type: <type>", "# type: ignore <stuff>").

   Novo na versão 3.8.


Uso na linha de comando
=======================

Novo 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.

-i <indent>
--indent <indent>

   indentação de nós em AST (número de espaços).

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 unifies the token-based and parse-tree-based views of
  python programs by inserting two-way links between tokens and ast
  nodes.

  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 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.
