ast — Abstrakta syntaxträd

Källkod: Lib/ast.py

---

Modulen ast hjälper Python-program att bearbeta träd av Pythons abstrakta syntaxgrammatik. Den abstrakta syntaxen i sig kan ändras med varje Python-version; den här modulen hjälper till att programmatiskt ta reda på hur den aktuella grammatiken ser ut.

Ett abstrakt syntaxträd kan genereras genom att skicka ast.PyCF_ONLY_AST som en flagga till den inbyggda funktionen compile(), eller genom att använda hjälpen parse() som finns i den här modulen. Resultatet blir ett träd av objekt vars klasser alla ärver från ast.AST. Ett abstrakt syntaxträd kan kompileras till ett Python-kodobjekt med hjälp av den inbyggda funktionen compile().

Abstrakt grammatik

Den abstrakta grammatiken definieras för närvarande på följande sätt:

-- 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)
         | Interpolation(expr value, constant str, int conversion, expr? format_spec)
         | JoinedStr(expr* values)
         | TemplateStr(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)
}

Klasser för noder

class ast.AST

Detta är basen för alla AST-nodklasser. De faktiska nodklasserna härleds från filen Parser/Python.asdl, som reproduceras above. De definieras i C-modulen _ast och exporteras på nytt i ast.

Det finns en klass definierad för varje symbol på vänstersidan i den abstrakta grammatiken (t.ex. ast.stmt eller ast.expr). Dessutom finns det en klass definierad för varje konstruktör på högersidan; dessa klasser ärver från klasserna för vänstersidans träd. Till exempel ärver ast.BinOp från ast.expr. För produktionsregler med alternativ (även kallade ”summor”) är klassen på vänster sida abstrakt: endast instanser av specifika konstruktörsnoder skapas någonsin.

_fields

Varje konkret klass har ett attribut _fields som anger namnen på alla underordnade noder.

Varje instans av en konkret klass har ett attribut för varje underordnad nod, av den typ som definieras i grammatiken. Exempelvis har instanser av ast.BinOp ett attribut left av typen ast.expr.

Om dessa attribut är markerade som valfria i grammatiken (med ett frågetecken) kan värdet vara None. Om attributen kan ha noll eller fler värden (markerade med en asterisk), representeras värdena som Python-listor. Alla möjliga attribut måste finnas och ha giltiga värden när man kompilerar en AST med compile().

_field_types

Attributet _field_types på varje konkret klass är en ordbok som mappar fältnamn (som också listas i _fields) till deras typer.

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

Tillagd i version 3.13.

lineno

col_offset

end_lineno

end_col_offset

Instanser av underklasserna ast.expr och ast.stmt har attributen lineno, col_offset, end_lineno och end_col_offset. Attributen lineno och end_lineno är det första och sista radnumret i källtexten (1-indexerat så att den första raden är rad 1) och attributen col_offset och end_col_offset är motsvarande UTF-8-byteoffset för den första och sista tokens som genererade noden. UTF-8-offset registreras eftersom parsern använder UTF-8 internt.

Observera att slutpositionerna inte krävs av kompilatorn och därför är valfria. Slutoffsetet är efter den sista symbolen, till exempel kan man få källsegmentet för en nod med enradigt uttryck med hjälp av source_line[node.col_offset : node.end_col_offset].

Konstruktören för en klass ast.T analyserar sina argument på följande sätt:

• Om det finns positionella argument måste det finnas lika många som det finns objekt i T._fields; de kommer att tilldelas som attribut till dessa namn.

• Om det finns nyckelordsargument kommer de att ställa in attributen med samma namn till de angivna värdena.

Om du till exempel vill skapa och fylla i en ast.UnaryOp-nod kan du använda

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

Om ett fält som är valfritt i grammatiken utelämnas från konstruktorn, blir standardvärdet None. Om ett listfält utelämnas är standardvärdet den tomma listan. Om ett fält av typen ast.expr_context utelämnas, blir standardvärdet Load(). Om något annat fält utelämnas, kommer en DeprecationWarning att visas och AST-noden kommer inte att ha detta fält. I Python 3.15 kommer detta villkor att ge upphov till ett fel.

Ändrad i version 3.8: Klassen ast.Constant används nu för alla konstanter.

Ändrad i version 3.9: Enkla index representeras av sitt värde, extended slices representeras som tupler.

Ändrad i version 3.14: Utmatningen __repr__() av AST-noder innehåller värdena för nodfälten.

Föråldrad sedan version 3.8: Gamla klasser ast.Num, ast.Str, ast.Bytes, ast.NameConstant och ast.Ellipsis är fortfarande tillgängliga, men de kommer att tas bort i framtida Python-versioner. Under tiden kommer instansiering av dem att returnera en instans av en annan klass.

Föråldrad sedan version 3.9: Gamla klasser ast.Index och ast.ExtSlice är fortfarande tillgängliga, men de kommer att tas bort i framtida Python-versioner. Under tiden kommer instansiering av dem att returnera en instans av en annan klass.

Deprecated since version 3.13, will be removed in version 3.15: Tidigare versioner av Python tillät skapandet av AST-noder som saknade obligatoriska fält. På samma sätt tillät AST-nodkonstruktörer godtyckliga nyckelordsargument som sattes som attribut för AST-noden, även om de inte matchade något av fälten i AST-noden. Detta beteende är föråldrat och kommer att tas bort i Python 3.15.

Anteckning

Beskrivningarna av de specifika nodklasserna som visas här anpassades ursprungligen från det fantastiska projektet Green Tree Snakes och alla dess bidragsgivare.

Rotnoder

class ast.Module(body, type_ignores)

En Python-modul, som med file input. Nodtyp genererad av ast.parse() i standard "exec" mode.

body är en lista av modulens Specifikation.

type_ignores är en lista över modulens kommentarer för ignorerade typer; se ast.parse() för mer information.

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

En enda Python uttrycksinmatning. Nodtyp som genereras av ast.parse() när mode är "eval".

body är en enskild nod, en av uttryckstyperna.

>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))
Expression(
    body=Constant(value=123))

class ast.Interactive(body)

En enda interaktiv inmatning, som i Interaktivt läge. Nodtyp som genereras av ast.parse() när mode är "single".

body är en list av statement nodes.

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

En representation av en gammal typkommentar för funktioner, eftersom Python-versioner före 3.5 inte hade stöd för PEP 484-annoteringar. Nodtyp som genereras av ast.parse() när mode är "func_type".

En sådan typ av kommentarer skulle se ut så här:

def sum_two_number(a, b):
    # typ: (int, int) -> int
    returnerar a + b

argtypes är en list av uttrycksnoder.

returns är en enda uttrycksnod.

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

Tillagd i version 3.8.

Bokstäver

class ast.Constant(value)

Ett konstant värde. Attributet value för Constant literalen innehåller det Python-objekt som den representerar. De värden som representeras kan vara instanser av str, bytes, int, float, complex och bool, samt konstanterna None och Ellipsis.

>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))
Expression(
    body=Constant(value=123))

class ast.FormattedValue(value, conversion, format_spec)

Nod som representerar ett enda formateringsfält i en f-sträng. Om strängen innehåller ett enda formateringsfält och inget annat kan noden isoleras, annars visas den i JoinedStr.

• värde är vilken uttrycksnod som helst (t.ex. en bokstav, en variabel eller ett funktionsanrop).

• konvertering är ett heltal:

  • -1: ingen formatering

  • 97 (ord('a')): !a ASCII-formatering

  • 114 (ord('r')): !r repr()-formatering

  • 115 (ord('s')): !s string-formatering

• format_spec är en JoinedStr-nod som representerar formateringen av värdet, eller None om inget format har angetts. Både conversion och format_spec kan anges samtidigt.

class ast.JoinedStr(values)

En f-sträng som består av en serie FormattedValue- och Constant-noder.

>>> 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.TemplateStr(values, /)

Tillagd i version 3.14.

Nod som representerar en mallsträngliteral, bestående av en serie Interpolation- och Constant-noder. Dessa noder kan vara i valfri ordning och behöver inte vara sammanflätade.

>>> expr = ast.parse('t"{name} finished {place:ordinal}"', mode='eval')
>>> print(ast.dump(expr, indent=4))
Expression(
    body=TemplateStr(
        values=[
            Interpolation(
                value=Name(id='name', ctx=Load()),
                str='name',
                conversion=-1),
            Constant(value=' finished '),
            Interpolation(
                value=Name(id='place', ctx=Load()),
                str='place',
                conversion=-1,
                format_spec=JoinedStr(
                    values=[
                        Constant(value='ordinal')]))]))

class ast.Interpolation(value, str, conversion, format_spec=None)

Tillagd i version 3.14.

Nod som representerar ett enskilt interpoleringsfält i en mallsträngliteral.

• value är vilken uttrycksnod som helst (t.ex. en litteral, en variabel eller ett funktionsanrop). Detta har samma betydelse som FormattedValue.value.

• str är en konstant som innehåller texten i interpoleringsuttrycket.

• konvertering är ett heltal:

  • -1: ingen konvertering

  • 97 (ord('a')): !a ASCII-konvertering

  • 114 (ord('r')): !r repr()-konvertering

  • 115 (ord('s')): !s string-konvertering

  Detta har samma betydelse som FormattedValue.conversion.

• format_spec är en JoinedStr-nod som representerar formateringen av värdet, eller None om inget format har angetts. Både conversion och format_spec kan anges samtidigt. Detta har samma betydelse som FormattedValue.format_spec.

class ast.List(elts, ctx)

class ast.Tuple(elts, ctx)

En lista eller tupel. elts innehåller en lista med noder som representerar elementen. ctx är Store` om behållaren är ett mål för en tilldelning (dvs. (x,y)=något), och Load` annars.

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

En uppsättning. elts innehåller en lista med noder som representerar setets element.

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

En ordbok. keys och values innehåller listor med noder som representerar nycklarna respektive värdena, i matchande ordning (vad som skulle returneras vid anrop av dictionary.keys() och dictionary.values()).

Vid uppackning av ordböcker med hjälp av ordbokslitteraler hamnar det uttryck som ska expanderas i listan values, med en None på motsvarande position i 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())]))

Variabler

class ast.Name(id, ctx)

Ett variabelnamn. id innehåller namnet som en sträng, och ctx är en av följande typer.

class ast.Load

class ast.Store

class ast.Del

Variabelreferenser kan användas för att ladda en variabels värde, tilldela den ett nytt värde eller ta bort den. Variabelreferenser ges ett sammanhang för att skilja dessa fall åt.

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

En *var variabelreferens. value innehåller variabeln, vanligtvis en Name-nod. Denna typ måste användas när man bygger en Call-nod med *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()))])

Uttryck

class ast.Expr(value)

När ett uttryck, t.ex. ett funktionsanrop, visas som en egen sats utan att dess returvärde används eller lagras, omsluts det av denna container. value innehåller en av de andra noderna i detta avsnitt, en Constant, en Name, en Lambda, en Yield eller YieldFrom nod.

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

En unär operation. op är operatorn och operand en uttrycksnod.

class ast.UAdd

class ast.USub

class ast.Not

class ast.Invert

Unära operatortokens. Not är nyckelordet not, Invert är operatorn ~.

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

En binär operation (som addition eller division). op är operatorn, och left och right är valfria uttrycksnoder.

>>> 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 för binära operatorer.

class ast.BoolOp(op, values)

En boolesk operation, ”eller” eller ”och”. op är Or eller And. values är de involverade värdena. På varandra följande operationer med samma operator, t.ex. a eller b eller c, slås samman till en nod med flera värden.

Detta inkluderar inte not, som är en 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 för booleska operatorer.

class ast.Compare(left, ops, comparators)

En jämförelse av två eller flera värden. left är det första värdet i jämförelsen, ops listan med operatorer och comparators listan med värden efter det första elementet i jämförelsen.

>>> 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 för jämförelseoperator.

class ast.Call(func, args, keywords)

Ett anrop av en funktion. func är funktionen, som ofta kommer att vara ett Name eller Attribute objekt. Av argumenten:

• args innehåller en lista över de argument som skickas med position.

• keywords innehåller en lista med keyword-objekt som representerar argument som skickas med keyword.

Argumenten args och keywords är valfria och är som standard tomma listor.

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

Ett nyckelordsargument till ett funktionsanrop eller en klassdefinition. arg är en rå sträng med parameternamnet, value är en nod att skicka in.

class ast.IfExp(test, body, orelse)

Ett uttryck som a if b else c. Varje fält innehåller en enda nod, så i följande exempel är alla tre Name-noder.

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

Attributåtkomst, t.ex. d.keys. value är en nod, vanligtvis en Name. attr är en naken sträng som anger namnet på attributet, och ctx är Load, Store eller Del beroende på hur attributet används.

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

Ett namngivet uttryck. Denna AST-nod produceras av operatorn för assignment-uttryck (även känd som valrossoperatorn). I motsats till Assign-noden där det första argumentet kan vara flera noder, måste i detta fall både target och value vara enstaka noder.

>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))
Expression(
    body=NamedExpr(
        target=Name(id='x', ctx=Store()),
        value=Constant(value=4)))

Tillagd i version 3.8.

Subskription

class ast.Subscript(value, slice, ctx)

Ett index, t.ex. l[1]. value är det subskriberade objektet (vanligtvis sekvens eller mappning). lice är ett index, en skiva eller en nyckel. Det kan vara en Tuple och innehålla en Slice. ctx är Load, Store eller Del beroende på vilken åtgärd som utförs med subskriptionen.

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

Vanlig skärning (på formen lower:upper eller lower:upper:step). Kan endast förekomma i fältet slice i Subscript, antingen direkt eller som ett element i 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()))

Förståelse

class ast.ListComp(elt, generators)

class ast.SetComp(elt, generators)

class ast.GeneratorExp(elt, generators)

class ast.DictComp(key, value, generators)

List- och set-förståelser, generatoruttryck och ordboksförståelser. elt (eller key och value) är en enda nod som representerar den del som kommer att utvärderas för varje objekt.

generators är en lista av comprehension noder.

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

En for -sats i en förståelse. target är referensen som ska användas för varje element - vanligtvis en Name eller Tuple -nod. iter är objektet som ska itereras över. ifs är en lista med testuttryck: varje for -sats kan ha flera ifs.

is_async indikerar att en förståelse är asynkron (använder en async for istället för for). Värdet är ett heltal (0 eller 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)]))

Specifikation

class ast.Assign(targets, value, type_comment)

En tilldelning. targets är en lista med noder och value är en enskild nod.

Flera noder i targets representerar att tilldela samma värde till alla. Uppackning representeras genom att sätta en Tuple eller List inom targets.

type_comment

type_comment är en valfri sträng med typannoteringen som en kommentar.

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

Ett uppdrag med en typannotering. target är en enskild nod och kan vara en Name, en Attribute eller en Subscript. annotation är annoteringen, t.ex. en nod av typen Constant eller Name. value är en enskild valfri nod.

simple är alltid antingen 0 (indikerar ett ”komplext” mål) eller 1 (indikerar ett ”enkelt” mål). Ett ”enkelt” mål består enbart av en Name-nod som inte förekommer inom parentes; alla andra mål betraktas som komplexa. Endast enkla mål visas i __annotations__-ordlistan över moduler och klasser.

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

Förstärkt tilldelning, t.ex. a += 1. I följande exempel är target en Name-nod för x (med Store-kontexten), op är Add, och value är en Constant med värdet 1.

Attributet target kan inte vara av klass Tuple eller List, till skillnad från målen i 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)

Ett raise-uttryck. exc är det undantagsobjekt som ska genereras, normalt ett Call eller Name, eller None för ett fristående raise. cause är den valfria delen för y i 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)

Ett påstående. test innehåller villkoret, t.ex. en Compare-nod. msg innehåller felmeddelandet.

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

Representerar ett del-uttryck. targets är en lista med noder, till exempel Name, Attribute eller Subscript -noder.

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

Ett ”godkänt” uttalande.

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

class ast.TypeAlias(name, type_params, value)

Ett type-alias som skapas genom type-satsen. name är namnet på aliaset, type_params är en lista med type-parametrar, och value är värdet på typaliaset.

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

Tillagd i version 3.12.

Andra uttalanden som endast är tillämpliga inom funktioner eller loopar beskrivs i andra avsnitt.

Importer

class ast.Import(names)

En importförklaring. names är en lista med alias-noder.

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

Representerar from x import y. module är en rå sträng av ’from’-namnet, utan några inledande punkter, eller None för uttalanden som from . import foo. level är ett heltal som anger nivån på den relativa importen (0 betyder absolut import).

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

Båda parametrarna är råa strängar av namnen. asname kan vara None om det vanliga namnet ska användas.

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

Kontrollflöde

Anteckning

Valfria klausuler som else lagras som en tom lista om de inte finns med.

class ast.If(test, body, orelse)

En if-sats. test innehåller en enda nod, t.ex. en Compare-nod. body och orelse innehåller var och en en lista med noder.

elif -klausuler har ingen särskild representation i AST, utan visas istället som extra If -noder inom orelse -sektionen i den föregående.

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

En for-slinga. target innehåller den eller de variabler som slingan tilldelar, som en enda Name, Tuple, List, Attribute eller Subscript-nod. iter innehåller det objekt som ska slingas, återigen som en enda nod. body och orelse innehåller listor över noder som ska exekveras. De i orelse exekveras om slingan avslutas normalt, snarare än via ett break-uttryck.

type_comment

type_comment är en valfri sträng med typannoteringen som en kommentar.

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

En while -slinga. test innehåller villkoret, till exempel en Compare -nod.

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

Uttalandena bryt och fortsätt.

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

försök block. Alla attribut är listor över noder som ska köras, utom handlers, som är en lista över ExceptHandler-noder.

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

try -block som följs av except* -klausuler. Attributen är desamma som för Try, men ExceptHandler -noderna i handlers tolkas som except* -block istället för 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))])])])

Tillagd i version 3.11.

class ast.ExceptHandler(type, name, body)

En enda except klausul. type är undantagstypen som den kommer att matcha, vanligtvis en Name nod (eller None för en catch-all except: klausul). name är en rå sträng för namnet på undantaget, eller None om klausulen inte har as foo. body är en lista med noder.

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

Ett with -block. items är en lista med withitem -noder som representerar kontext hanterarna, och body är det indragna blocket inuti kontexten.

type_comment

type_comment är en valfri sträng med typannoteringen som en kommentar.

class ast.withitem(context_expr, optional_vars)

En enda kontextmanager i ett with -block. context_expr är kontextmanagern, ofta en Call -nod. optional_vars är en Name, Tuple eller List för delen as foo, eller None om den inte används.

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

Mönstermatchning

class ast.Match(subject, cases)

Ett match-uttryck. subject innehåller ämnet för matchningen (objektet som matchas mot fallen) och cases innehåller en iterabel av match_case -noder med olika fall.

Tillagd i version 3.10.

class ast.match_case(pattern, guard, body)

Ett enda fallmönster i ett match-uttryck. pattern innehåller det mönster som objektet ska matchas mot. Observera att AST -noder som skapas för mönster skiljer sig från de som skapas för uttryck, även om de har samma syntax.

Attributet guard innehåller ett uttryck som kommer att utvärderas om mönstret matchar ämnet.

body innehåller en lista med noder som ska köras om mönstret matchar och resultatet av utvärderingen av guard-uttrycket är sant.

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

Tillagd i version 3.10.

class ast.MatchValue(value)

Ett matchande bokstavs- eller värdemönster som jämförs genom likhet. value är en uttrycksnod. Tillåtna värdenoder är begränsade enligt beskrivningen i dokumentationen för match-satsen. Det här mönstret lyckas om matchningsobjektet är lika med det utvärderade värdet.

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

Tillagd i version 3.10.

class ast.MatchSingleton(value)

Ett litterärt matchningsmönster som jämför med identitet. value är den singleton som ska jämföras mot: None, True, eller False. Detta mönster lyckas om matchningsobjektet är den givna konstanten.

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

Tillagd i version 3.10.

class ast.MatchSequence(patterns)

Ett matchningsmönster för en sekvens. patterns innehåller de mönster som ska matchas mot ämneselementen om ämnet är en sekvens. Matchar en sekvens med variabel längd om ett av undermönstren är en MatchStar-nod, annars matchas en sekvens med fast längd.

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

Tillagd i version 3.10.

class ast.MatchStar(name)

Matchar resten av sekvensen i ett matchsekvensmönster med variabel längd. Om name inte är None, binds en lista som innehåller de återstående sekvenselementen till det namnet om det övergripande sekvensmönstret är framgångsrikt.

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

Tillagd i version 3.10.

class ast.MatchMapping(keys, patterns, rest)

Ett matchande mappningsmönster. keys är en sekvens av uttrycksnoder. patterns är en motsvarande sekvens av mönsternoder. rest är ett valfritt namn som kan anges för att fånga de återstående mappningselementen. Tillåtna nyckeluttryck begränsas på det sätt som beskrivs i dokumentationen för match statement.

Detta mönster lyckas om ämnet är en mappning, alla utvärderade nyckeluttryck finns i mappningen och värdet som motsvarar varje nyckel matchar motsvarande undermönster. Om rest inte är None, binds en dict som innehåller de återstående mappningselementen till namnet om det övergripande mappningsmönstret är framgångsrikt.

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

Tillagd i version 3.10.

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

Ett matchningsmönster för klass. cls är ett uttryck som anger den nominella klass som skall matchas. patterns är en sekvens av mönsternoder som skall matchas mot den klassdefinierade sekvensen av attribut för mönstermatchning. kwd_attrs är en sekvens av ytterligare attribut som skall matchas (specificerade som nyckelordsargument i klassmönstret), kwd_patterns är motsvarande mönster (specificerade som nyckelordsvärden i klassmönstret).

Detta mönster lyckas om ämnet är en instans av den nominerade klassen, alla positionsmönster matchar motsvarande klassdefinierade attribut och alla angivna nyckelordsattribut matchar motsvarande mönster.

Observera: Klasser kan definiera en egenskap som returnerar self för att matcha en mönsternod mot den instans som ska matchas. Flera inbyggda typer matchas också på detta sätt, vilket beskrivs i dokumentationen för match statement.

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

Tillagd i version 3.10.

class ast.MatchAs(pattern, name)

En matchning ”som mönster”, fångstmönster eller jokerteckenmönster. pattern innehåller det matchningsmönster som ämnet kommer att matchas mot. Om mönstret är None representerar noden ett fångstmönster (dvs. ett tomt namn) och kommer alltid att lyckas.

Attributet name innehåller det namn som kommer att bindas om mönstret är framgångsrikt. Om name är None måste pattern också vara None och noden representerar wildcard-mönstret.

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

Tillagd i version 3.10.

class ast.MatchOr(patterns)

En matchning ”eller-mönster”. Ett eller-mönster matchar vart och ett av sina undermönster i tur och ordning till ämnet, tills ett lyckas. Då anses or-mönstret vara framgångsrikt. Om inget av undermönstren lyckas misslyckas or-mönstret. Attributet patterns innehåller en lista över matchningsmönsternoder som kommer att matchas mot subjektet.

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

Tillagd i version 3.10.

Typ av anteckningar

class ast.TypeIgnore(lineno, tag)

En # type: ignore kommentar som finns på lineno. tag är den valfria tagg som anges av formuläret # type: ignore <tag>.

>>> print(ast.dump(ast.parse('x = 1 # type: ignore', type_comments=True), indent=4))
Module(
    body=[
        Assign(
            targets=[
                Name(id='x', ctx=Store())],
            value=Constant(value=1))],
    type_ignores=[
        TypeIgnore(lineno=1, tag='')])
>>> print(ast.dump(ast.parse('x: bool = 1 # type: ignore[assignment]', type_comments=True), indent=4))
Module(
    body=[
        AnnAssign(
            target=Name(id='x', ctx=Store()),
            annotation=Name(id='bool', ctx=Load()),
            value=Constant(value=1),
            simple=1)],
    type_ignores=[
        TypeIgnore(lineno=1, tag='[assignment]')])

Anteckning

TypeIgnore-noder genereras inte när parametern type_comments är inställd på False (standard). Se ast.parse() för mer information.

Tillagd i version 3.8.

Typ av parametrar

Typ-parametrar kan finnas i klasser, funktioner och typaliaser.

class ast.TypeVar(name, bound, default_value)

En typing.TypeVar. name är namnet på typvariabeln. bound är bindningen eller begränsningarna, om sådana finns. Om bound är en Tuple representerar den begränsningar; annars representerar den bindningen. default_value är standardvärdet; om TypeVar inte har något standardvärde kommer detta attribut att sättas till 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()))])

Tillagd i version 3.12.

Ändrad i version 3.13: Parametern default_value har lagts till.

class ast.ParamSpec(name, default_value)

En typing.ParamSpec. name är namnet på parameterspecifikationen. default_value är standardvärdet; om ParamSpec inte har något standardvärde kommer detta attribut att sättas till 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=List(
                        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()))])

Tillagd i version 3.12.

Ändrad i version 3.13: Parametern default_value har lagts till.

class ast.TypeVarTuple(name, default_value)

En typing.TypeVarTuple. name är namnet på typvariabeln tuple. default_value är standardvärdet; om TypeVarTuple inte har något standardvärde kommer detta attribut att sättas till 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()))])

Tillagd i version 3.12.

Ändrad i version 3.13: Parametern default_value har lagts till.

Funktions- och klassdefinitioner

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

En funktionsdefinition.

• name är en rå sträng med funktionens namn.

• args är en nod i arguments.

• body är listan över noder i funktionen.

• decorator_list är listan över dekoratorer som ska tillämpas, lagrade längst ut först (dvs. den första i listan kommer att tillämpas sist).

• returns är returannoteringen.

• type_params är en lista med typ-parametrar.

type_comment

type_comment är en valfri sträng med typannoteringen som en kommentar.

Ändrad i version 3.12: Lagt till type_params.

class ast.Lambda(args, body)

lambda är en minimal funktionsdefinition som kan användas inuti ett uttryck. Till skillnad från FunctionDef innehåller body en enda nod.

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

Argumenten för en funktion.

• posonlyargs, args och kwonlyargs är listor av arg-noder.

• vararg och kwarg är enskilda arg-noder som refererar till parametrarna *args, **kwargs.

• kw_defaults är en lista med standardvärden för argument som endast innehåller nyckelord. Om ett är None krävs motsvarande argument.

• defaults är en lista med standardvärden för argument som kan skickas positionellt. Om det finns färre standardvärden motsvarar de de sista n argumenten.

class ast.arg(arg, annotation, type_comment)

Ett enskilt argument i en lista. arg är en rå sträng med argumentets namn; annotation är dess annotation, t.ex. en Name-nod.

type_comment

type_comment är en valfri sträng med typannoteringen som en kommentar

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

Ett retur uttalande.

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

class ast.Yield(value)

class ast.YieldFrom(value)

Ett yield eller yield from uttryck. Eftersom det här är uttryck måste de omslutas av en Expr-nod om värdet som skickas tillbaka inte ska användas.

>>> 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 och nonlocal satser. names är en lista med råa strängar.

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

En klassdefinition.

• name är en rå sträng för klassnamnet

• bases är en lista med noder för explicit angivna basklasser.

• keywords är en lista med keyword-noder, huvudsakligen för ’metaclass’. Andra nyckelord kommer att skickas till metaklassen, enligt PEP 3115.

• body är en lista med noder som representerar koden i klassdefinitionen.

• decorator_list är en lista med noder, som i FunctionDef.

• type_params är en lista med typ-parametrar.

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

Ändrad i version 3.12: Lagt till type_params.

Asynkron och await

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

En async def funktionsdefinition. Har samma fält som FunctionDef.

Ändrad i version 3.12: Lagt till type_params.

class ast.Await(value)

Ett await-uttryck. value är det som väntas på. Endast giltigt i kroppen av en 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 -slingor och async with-kontexthanterare. De har samma fält som For respektive With. Endast giltigt i kroppen av en AsyncFunctionDef.

Anteckning

När en sträng analyseras av ast.parse(), kommer operator-noder (underklasser till ast.operator, ast.unaryop, ast.cmpop, ast.boolop och ast.expr_context) på det returnerade trädet att vara singletons. Ändringar i ett av dem kommer att återspeglas i alla andra förekomster av samma värde (t.ex. ast.Add).

ast hjälpare

Förutom nodklasserna definierar modulen ast dessa verktygsfunktioner och klasser för genomgång av abstrakta syntaxträd:

ast.parse(source, filename='<unknown>', mode='exec', *, type_comments=False, feature_version=None, optimize=-1)

Parsar källan till en AST-nod. Motsvarar compile(source, filename, mode, flags=FLAGS_VALUE, optimize=optimize), där FLAGS_VALUE är ast.PyCF_ONLY_AST om optimize <= 0 och ast.PyCF_OPTIMIZED_AST annars.

Om type_comments=True anges, modifieras parsern för att kontrollera och returnera typkommentarer som specificeras av PEP 484 och PEP 526. Detta är likvärdigt med att lägga till ast.PyCF_TYPE_COMMENTS till flaggorna som skickas till compile(). Detta kommer att rapportera syntaxfel för felplacerade typkommentarer. Utan denna flagga kommer typkommentarer att ignoreras och fältet type_comment på valda AST-noder kommer alltid att vara None. Dessutom kommer platserna för # type: ignore kommentarer att returneras som type_ignores attributet för Module (annars är det alltid en tom lista).

Dessutom, om mode är 'func_type', ändras inmatningssyntaxen för att motsvara PEP 484 ”signaturtypskommentarer”, t.ex. (str, int) -> List[str].

Om du anger feature_version till en tupel (major, minor) kommer det att resultera i ett ”best-effort” försök att analysera med hjälp av den Python-versionens grammatik. Till exempel, att sätta feature_version=(3, 9) kommer att försöka att inte tillåta parsning av match-satser. För närvarande måste major vara lika med 3. Den lägsta versionen som stöds är (3, 7) (och detta kan öka i framtida Python-versioner); den högsta är sys.version_info[0:2]. ”Best-effort”-försök innebär att det inte finns någon garanti för att parsen (eller att parsen lyckas) är densamma som när den körs på den Python-version som motsvarar feature_version.

Om källan innehåller ett null-tecken (\0), ValueError.

Varning

Observera att en lyckad parsning av källkod till ett AST-objekt inte garanterar att den källkod som tillhandahålls är giltig Python-kod som kan exekveras eftersom kompileringssteget kan ge upphov till ytterligare SyntaxError-undantag. Till exempel genererar källan return 42 en giltig AST-nod för en return-sats, men den kan inte kompileras ensam (den måste vara inuti en funktionsnod).

I synnerhet kommer ast.parse() inte att göra några scoping-kontroller, vilket kompileringssteget gör.

Varning

Det är möjligt att krascha Python-tolken med en tillräckligt stor/komplex sträng på grund av begränsningar i stackdjupet i Pythons AST-kompilator.

Ändrad i version 3.8: Lagt till type_comments, mode='func_type' och feature_version.

Ändrad i version 3.13: Den minsta versionen som stöds för feature_version är nu (3, 7). Argumentet optimize har lagts till.

ast.unparse(ast_obj)

Unparse ett ast.AST-objekt och generera en sträng med kod som skulle producera ett motsvarande ast.AST-objekt om det analyserades tillbaka med ast.parse().

Varning

Den kodsträng som produceras kommer inte nödvändigtvis att vara lika med den ursprungliga koden som genererade ast.AST-objektet (utan några kompilatoroptimeringar, t.ex. konstanta tuples/frozensets).

Varning

Försök att unparsa ett mycket komplext uttryck skulle resultera i RecursionError.

Tillagd i version 3.9.

ast.literal_eval(node_or_string)

Utvärderar en uttrycksnod eller en sträng som endast innehåller en Python-litteral eller containervisning. Den angivna strängen eller noden får endast bestå av följande Python-litteralstrukturer: strängar, bytes, tal, tupler, listor, dicts, set, booleaner, None och Ellipsis.

Detta kan användas för att utvärdera strängar som innehåller Python-värden utan att man behöver analysera värdena själv. Den kan inte utvärdera godtyckligt komplexa uttryck, t.ex. med operatorer eller indexering.

Denna funktion har tidigare dokumenterats som ”säker” utan att det har definierats vad det innebär. Det var missvisande. Detta är specifikt utformat för att inte exekvera Python-kod, till skillnad från den mer allmänna eval(). Det finns ingen namnrymd, inga namnuppslagningar eller möjlighet att ringa ut. Men det är inte fritt från angrepp: En relativt liten inmatning kan leda till att minnet eller C-stacken tar slut och att processen kraschar. Det finns också möjlighet till överdriven CPU-konsumtion, denial of service, för vissa indata. Att anropa den på icke betrodda data rekommenderas därför inte.

Varning

Det är möjligt att krascha Python-tolken på grund av begränsningar i stackdjupet i Pythons AST-kompilator.

Det kan ge upphov till ValueError, TypeError, SyntaxError, MemoryError och RecursionError beroende på den felaktiga indata.

Ändrad i version 3.2: Tillåter nu bytes och set-litteraler.

Ändrad i version 3.9: Stöder nu skapandet av tomma uppsättningar med 'set()'.

Ändrad i version 3.10: För stränginmatningar tas nu inledande mellanslag och tabbar bort.

ast.get_docstring(node, clean=True)

Returnerar dokumentsträngen för den givna noden (som måste vara en FunctionDef, AsyncFunctionDef, ClassDef, eller Module nod), eller None om den inte har någon dokumentsträng. Om clean är true, rensa upp dokumentsträngens indrag med inspect.cleandoc().

Ändrad i version 3.5: AsyncFunctionDef stöds nu.

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

Hämta källkodssegmentet för den källa som genererade nod. Om någon platsinformation (lineno, end_lineno, col_offset, eller end_col_offset) saknas, returneras None.

Om padded är True, kommer den första raden i ett flerradigt uttalande att fyllas med mellanslag för att matcha dess ursprungliga position.

Tillagd i version 3.8.

ast.fix_missing_locations(node)

När du kompilerar ett nodträd med compile() förväntar sig kompilatorn attributen lineno och col_offset för varje nod som stöder dem. Detta är ganska tråkigt att fylla i för genererade noder, så den här hjälpen lägger till dessa attribut rekursivt där de inte redan är inställda, genom att ställa in dem till värdena för den överordnade noden. Det fungerar rekursivt med början på node.

ast.increment_lineno(node, n=1)

Öka radnumret och slutradnumret för varje nod i trädet som börjar vid nod med n. Detta är användbart för att ”flytta kod” till en annan plats i en fil.

ast.copy_location(new_node, old_node)

Kopiera källplatsen (lineno, col_offset, end_lineno, och end_col_offset) från old_node till new_node om möjligt, och returnera new_node.

ast.iter_fields(node)

Ger en tupel av (fältnamn, värde) för varje fält i node._fields som finns på node.

ast.iter_child_nodes(node)

Ger alla direkta underordnade noder till node, dvs. alla fält som är noder och alla fältobjekt som är listor över noder.

ast.walk(node)

Ger rekursivt alla nedstigande noder i trädet som börjar på node (inklusive node själv), utan specificerad ordning. Detta är användbart om du bara vill modifiera noder på plats och inte bryr dig om sammanhanget.

class ast.NodeVisitor

En basklass för nodbesökare som går igenom det abstrakta syntaxträdet och anropar en besökarfunktion för varje nod som hittas. Denna funktion kan returnera ett värde som vidarebefordras av visit()-metoden.

Denna klass är avsedd att underklassificeras, varvid underklassen lägger till besöksmetoder.

visit(node)

Besöker en nod. Standardimplementeringen anropar metoden som heter self.visit_classname där klassnamn är namnet på nodklassen, eller generic_visit() om den metoden inte finns.

generic_visit(node)

Den här besökaren anropar visit() på alla barn till noden.

Observera att barnnoder till noder som har en anpassad besöksmetod inte kommer att besökas om inte besökaren anropar generic_visit() eller besöker dem själv.

visit_Constant(node)

Hanterar alla konstanta noder.

Använd inte NodeVisitor om du vill göra ändringar i noder under traversal. För detta finns en speciell besökare (NodeTransformer) som tillåter ändringar.

Föråldrad sedan version 3.8: Metoderna visit_Num(), visit_Str(), visit_Bytes(), visit_NameConstant() och visit_Ellipsis() är föråldrade nu och kommer inte att anropas i framtida Python-versioner. Lägg till metoden visit_Constant() för att hantera alla konstanta noder.

class ast.NodeTransformer

En NodeVisitor-underklass som går igenom det abstrakta syntaxträdet och tillåter modifiering av noder.

NodeTransformer kommer att gå igenom AST och använda returvärdet från besöksmetoderna för att ersätta eller ta bort den gamla noden. Om besöksmetodens returvärde är None kommer noden att tas bort från sin plats, annars ersätts den med returvärdet. Returvärdet kan vara den ursprungliga noden och i så fall sker ingen ersättning.

Här är ett exempel på en transformator som skriver om alla förekomster av namnuppslagningar (foo) till 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
        )

Tänk på att om den nod du använder har underordnade noder måste du antingen transformera de underordnade noderna själv eller anropa metoden generic_visit() för noden först.

För noder som ingick i en samling uttalanden (det gäller alla uttalandenoder) kan besökaren också returnera en lista med noder i stället för bara en enda nod.

Om NodeTransformer introducerar nya noder (som inte var en del av det ursprungliga trädet) utan att ge dem platsinformation (t.ex. lineno), bör fix_missing_locations() anropas med det nya delträdet för att räkna om platsinformationen:

träd = ast.parse('foo', mode='eval')
new_tree = fix_missing_locations(RewriteName().visit(tree))

Vanligtvis använder du transformatorn på följande sätt:

nod = DinTransformator().visit(nod)

ast.dump(node, annotate_fields=True, include_attributes=False, *, indent=None, show_empty=False)

Returnerar en formaterad dumpning av trädet i node. Detta är främst användbart för felsökning. Om annotate_fields är true (standard) kommer den returnerade strängen att visa namn och värden för fälten. Om annotate_fields är false blir resultatsträngen mer kompakt genom att otvetydiga fältnamn utelämnas. Attribut som radnummer och kolumnoffset dumpas inte som standard. Om detta önskas kan include_attributes sättas till true.

Om indent är ett icke-negativt heltal eller en sträng, kommer trädet att skrivas ut med den indragsnivån. En indragsnivå på 0, negativ eller "" kommer endast att infoga nya rader. None (standard) väljer representation med en rad. Om du använder ett positivt heltal indenteras så många mellanslag per nivå. Om indent är en sträng (t.ex. "\t") används den strängen för att dra in varje nivå.

Om show_empty är false (standard) kommer valfria tomma listor att utelämnas från utdata. Valfria None-värden utelämnas alltid.

Ändrad i version 3.9: Lagt till alternativet indent.

Ändrad i version 3.13: Lagt till alternativet show_empty.

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

Flaggor för kompilator

Följande flaggor kan skickas till compile() för att ändra effekterna på kompileringen av ett program:

ast.PyCF_ALLOW_TOP_LEVEL_AWAIT

Aktiverar stöd för toppnivå await, async for, async with och async-förståelser.

Tillagd i version 3.8.

ast.PyCF_ONLY_AST

Genererar och returnerar ett abstrakt syntaxträd i stället för att returnera ett kompilerat kodobjekt.

ast.PyCF_OPTIMIZED_AST

Den returnerade AST:n optimeras enligt optimize-argumentet i compile() eller ast.parse().

Tillagd i version 3.13.

ast.PyCF_TYPE_COMMENTS

Aktiverar stöd för typkommentarer i stil med PEP 484 och PEP 526 (# type: <type>, # type: ignore <stuff>).

Tillagd i version 3.8.

ast.compare(a, b, /, *, compare_attributes=False)

Jämför rekursivt två AST:er.

compare_attributes påverkar om AST-attribut ska beaktas i jämförelsen. Om compare_attributes är False (standard) ignoreras attributen. Annars måste de alla vara lika. Det här alternativet är användbart för att kontrollera om AST:erna är strukturellt lika men skiljer sig åt i blanksteg eller liknande detaljer. Attribut inkluderar radnummer och kolumnoffset.

Tillagd i version 3.14.

Användning av kommandoraden

Tillagd i version 3.9.

Modulen ast kan köras som ett skript från kommandoraden. Det är så enkelt som att:

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

Följande alternativ accepteras:

-h, --help

Visa hjälpmeddelandet och avsluta.

-m <mode>

--mode <mode>

Ange vilken typ av kod som ska kompileras, som mode-argumentet i parse().

--no-type-comments

Analysera inte typkommentarer.

-a, --include-attributes

Inkludera attribut som radnummer och kolumnförskjutningar.

-i <indent>

--indent <indent>

Indragning av noder i AST (antal mellanslag).

--feature-version <version>

Python-version i formatet 3.x (t.ex. 3.10). Standardvärdet är den aktuella versionen av tolken.

Tillagd i version 3.14.

-O <level>

--optimize <level>

Optimeringsnivå för parsern. Standardvärdet är ingen optimering.

Tillagd i version 3.14.

--show-empty

Visa tomma listor och fält som är None. Standardinställningen är att inte visa tomma objekt.

Tillagd i version 3.14.

Om infile anges analyseras dess innehåll till AST och dumpas till stdout. I annat fall läses innehållet från stdin.

Se även

Green Tree Snakes, en extern dokumentationsresurs, har bra detaljer om hur man arbetar med Python ASTs.

ASTTokens annoterar Python ASTs med positionerna för tokens och text i källkoden som genererade dem. Detta är användbart för verktyg som gör källkodstransformationer.

leoAst.py förenar de tokenbaserade och parse-tree-baserade vyerna av pythonprogram genom att infoga tvåvägslänkar mellan tokens och ast-noder.

LibCST analyserar kod som ett konkret syntaxträd som ser ut som ett asträd och behåller alla formateringsdetaljer. Det är användbart för att bygga automatiserade refaktoriseringsprogram (codemod) och linters.

Parso är en Python-parser som stöder felåterställning och round-trip-parsing för olika Python-versioner (i flera Python-versioner). Parso kan också lista flera syntaxfel i din Python-fil.