ast --- 抽象構文木

ソースコード: Lib/ast.py

---

ast モジュールは、Python の抽象構文を表す木を Python アプリケーションで処理するための機能を提供します。 抽象構文自体は Python のリリースごとに変わる可能性がありますが、このモジュールを使えば、現在の文法をプログラムから調べられます。

抽象構文木を作成するには、 ast.PyCF_ONLY_AST を組み込み関数 compile() のフラグとして渡すか、あるいはこのモジュールで提供されているヘルパー関数 parse() を使います。その結果は、 ast.AST を継承したクラスのオブジェクトのツリーとなります。抽象構文木は組み込み関数 compile() を使って Python コード・オブジェクトにコンパイルすることができます。

抽象文法

抽象文法は、現在次のように定義されています:

-- ASDL の四つの組み込み型:
-- 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' は括弧のない単純な名前へのアノテーションを示す
          | AnnAssign(expr target, expr annotation, expr? value, int simple)

          -- 対象言語では else がキーワードなので 'orelse' を使う
          | 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, int? is_lazy)
          | ImportFrom(identifier? module, alias* names, int? level, int? is_lazy)

          | Global(identifier* names)
          | Nonlocal(identifier* names)
          | Expr(expr value)
          | Pass | Break | Continue

          -- col_offset はパーサーが使う UTF-8 文字列内のバイトオフセット
          attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

          -- BoolOp() は 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)
         -- yield 式が現れる位置は文法によって制限される
         | Await(expr value)
         | Yield(expr? value)
         | YieldFrom(expr value)
         -- 次の二つを区別するため、比較にはシーケンスが必要
         -- x < 4 < 3 と (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)

         -- 以下の式は代入のコンテキストに現れうる
         | 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)

         -- Subscript 内にのみ現れる
         | Slice(expr? lower, expr? upper, expr? step)

          -- col_offset はパーサーが使う UTF-8 文字列内のバイトオフセット
          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)

    -- 呼び出しに渡すキーワード引数 (**kwargs の identifier は NULL)
    keyword = (identifier? arg, expr value)
               attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    -- インポート名と、省略可能な 'as' による別名。
    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)
            -- MatchMapping の省略可能な "rest" パラメーターで残りのマッピングのキーをキャプチャする

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

Node クラス

class ast.AST

すべての AST ノードクラスの抽象基底クラスです。 実際のノードクラスは、上に掲載した Parser/Python.asdl ファイルから生成されます。 これらは C モジュール _ast で定義され、ast から再エクスポートされます。

抽象文法の左辺のシンボル一つずつにそれぞれ一つのクラスがあります (たとえば ast.stmt や ast.expr)。それに加えて、右辺のコンストラクタ一つずつにそれぞれ一つのクラスがあり、これらのクラスは左辺のツリーのクラスを継承しています。たとえば、 ast.BinOp は ast.expr から継承しています。代替を伴った生成規則 (production rules with alternatives) (別名 "sums") の場合、左辺は抽象クラスとなり、特定のコンストラクタ・ノードのインスタンスのみが作成されます。

_fields

各具象クラスは属性 _fields を持っており、すべての子ノードの名前をそこに保持しています。

具象クラスのインスタンスは、各子ノードに対してそれぞれひとつの属性を持っています。この属性は、文法で定義された型となります。たとえば ast.BinOp のインスタンスは left という属性を持っており、その型は ast.expr です。

これらの属性が、文法上 (クエスチョンマークを用いて) オプションであるとマークされている場合は、その値が None となることもあります。属性が0個以上の複数の値をとりうる場合 (アスタリスクでマークされている場合) は、値は Python のリストで表されます。全ての属性は AST を compile() でコンパイルする際には存在しなければならず、そして妥当な値でなければなりません。

_field_types

各具象クラスの _field_types 属性は、フィールド名 (_fields にも列挙されています) をその型に対応付ける辞書です。

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

Added in version 3.13.

lineno

col_offset

end_lineno

end_col_offset

ast.expr と ast.stmt のサブクラスのインスタンスは、lineno、col_offset、end_lineno、end_col_offset 属性を持ちます。 lineno と end_lineno は、対応するソーステキストの最初と最後の行番号です (1 から数えるので、先頭行は 1 です)。 col_offset と end_col_offset は、ノードの生成元となった最初と最後のトークンに対応する UTF-8 バイトオフセットです。 パーサーは内部で UTF-8 を使うため、この形式のオフセットを記録します。

コンパイラは終了位置を必要としないことに注意してください。このため終了位置は省略可能です。終了位置を示すオフセットは最後のシンボルの 後の位置 になります。例えば一行で書かれた式のソースコードのセグメントは source_line[node.col_offset : node.end_col_offset] により取得できます。

クラス ast.T のコンストラクタは引数を次のように解析します:

• 位置引数があるとすれば、 T._fields にあるのと同じだけの個数が無ければなりません。これらの引数はそこにある名前を持った属性として割り当てられます。

• キーワード引数があるとすれば、それらはその名前の属性にその値を割り当てられます。

たとえば、 ast.UnaryOp ノードを生成して属性を埋めるには、次のようにすることができます

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

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

バージョン 3.8 で変更: ast.Constant が全ての定数に使われるようになりました。

バージョン 3.9 で変更: 単純なインデックスはその値で表現され、幅を持つスライスはタプルで表現されます。

バージョン 3.13 で変更: AST ノードのコンストラクターが、省略されたフィールドに適切なデフォルト値を設定するようになりました。 省略可能なフィールドは None、リストのフィールドは空リスト、ast.expr_context 型のフィールドは Load() がデフォルトになります。 以前は、省略された属性は作成したノードに存在せず、アクセスすると AttributeError が送出されていました。

バージョン 3.14 で変更: AST ノードの __repr__() の出力に、ノードのフィールドの値が含まれるようになりました。

バージョン 3.8 で非推奨、バージョン 3.14 で削除: 以前の Python には、AST クラス ast.Num、ast.Str、ast.Bytes、ast.NameConstant、ast.Ellipsis がありましたが、Python 3.8 で非推奨になりました。 これらは Python 3.14 で削除され、その機能は ast.Constant に置き換えられました。

バージョン 3.9 で非推奨: 古いクラス ast.Index と ast.ExtSlice はまだ利用できますが、将来の Python で削除されます。 現在、これらをインスタンス化すると、別のクラスのインスタンスが返されます。

バージョン 3.13 で非推奨、バージョン 3.15 で削除: 以前の Python では、必須のフィールドが欠けた AST ノードを作成できました。 また、AST ノードのコンストラクターに任意のキーワード引数を渡すことができ、ノードのフィールドに対応していなくても属性として設定されていました。 これらの場合に TypeError を送出するようになりました。

バージョン 3.15 で非推奨、バージョン 3.20 で削除予定: 上の文法 で選択肢のある生成規則 ("sums" とも呼ばれます) に対応する AST ノードクラスは、抽象クラスです。 以前の Python では、これらの抽象ノードクラスのインスタンスを直接作成できました。 この動作は非推奨で、Python 3.20 で削除されます。

注釈

ここに示されている特定のノードクラスについての記述は、素晴らしい Green Tree Snakes プロジェクトとそのすべての貢献者の成果物をもとにしています。

ルートノード

class ast.Module(body, type_ignores)

ファイル入力 のような Python モジュールを表します。 ast.parse() の mode がデフォルトの "exec" のときに生成されるノード型です。

body は、モジュールの 文 の list です。

type_ignores は、モジュールの型検査を無視するコメントの list です。 詳細は ast.parse() を参照してください。

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

Python の単一の 式入力 を表します。 ast.parse() の mode が "eval" のときに生成されるノード型です。

body は、式の型 のいずれかの単一ノードです。

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

class ast.Interactive(body)

対話モード などでの、単一の 対話的な入力 を表します。 ast.parse() の mode が "single" のときに生成されるノード型です。

body は 文ノード の list です。

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

関数の旧形式の型コメントを表します。 Python 3.5 より前のバージョンでは、PEP 484 のアノテーションはサポートされていませんでした。 ast.parse() の mode が "func_type" のときに生成されるノード型です。

この形式の型コメントは、次のようなものです。

def sum_two_number(a, b):
    # type: (int, int) -> int
    return a + b

argtypes は 式ノード の list です。

returns は単一の 式ノード です。

>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))
FunctionType(
    argtypes=[
        Name(id='int'),
        Name(id='str')],
    returns=Subscript(
        value=Name(id='List'),
        slice=Name(id='int')))

Added in version 3.8.

リテラル

class ast.Constant(value, kind)

定数値を表します。 Constant リテラルの value 属性には、それが表す Python オブジェクトが格納されます。 表せる値は、str、bytes、int、float、complex、bool のインスタンスと、定数 None、Ellipsis です。

kind 属性は省略可能な文字列です。 接頭辞 u のある文字列リテラルでは kind は 'u' になります。 それ以外の定数では None です。

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

class ast.FormattedValue(value, conversion, format_spec)

このノードは f-string における単一の書式指定置換フィールドを表現します。文字列が単一の置換フィールドしか持たず、他に何も含まない場合は、ノードは単独で存在できます。そうでない場合は JoinedStr の一部としてあらわれます。

• value は式ツリーのノードのいずれか (リテラル、変数、関数呼び出しなど) です。

• conversion は整数です:

  • -1: 書式指定なし

  • 97 (ord('a')): !a による ASCII 形式への変換

  • 114 (ord('r')): !r による repr() 形式への変換

  • 115 (ord('s')): !s による 文字列 への変換

• format_spec は値の書式指定を表現する JoinedStr ノード、もしくは書式指定がない場合は None です。 conversion と format_spec を同時に設定することができます。

class ast.JoinedStr(values)

FormattedValue ノードと Constant ノードの集まりからなる f-string です。

>>> 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'),
                conversion=-1),
            Constant(value=') is '),
            FormattedValue(
                value=Call(
                    func=Name(id='sin'),
                    args=[
                        Name(id='a')]),
                conversion=-1,
                format_spec=JoinedStr(
                    values=[
                        Constant(value='.3')]))]))

class ast.TemplateStr(values, /)

Added in version 3.14.

テンプレート文字列リテラルを表すノードで、一連の Interpolation ノードと Constant ノードからなります。 これらのノードはどのような順序でもよく、交互に並ぶ必要はありません。

>>> 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'),
                str='name',
                conversion=-1),
            Constant(value=' finished '),
            Interpolation(
                value=Name(id='place'),
                str='place',
                conversion=-1,
                format_spec=JoinedStr(
                    values=[
                        Constant(value='ordinal')]))]))

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

Added in version 3.14.

テンプレート文字列リテラル内の一つの補間フィールドを表すノードです。

• value は任意の式ノード (リテラル、変数、関数呼び出しなど) です。 FormattedValue.value と同じ意味を持ちます。

• str は、補間する式のテキストを格納する定数です。

  str を None に設定すると、ast.unparse() の呼び出し時には value からコードを生成します。 この場合、生成したコードが元のコードと同一である保証はなくなり、コード生成の用途を想定しています。

• conversion は整数です:

  • -1: 変換なし

  • 97 (ord('a')): !a による ASCII 形式への変換

  • 114 (ord('r')): !r による repr() 形式への変換

  • 115 (ord('s')): !s による 文字列 への変換

  FormattedValue.conversion と同じ意味を持ちます。

• format_spec は、値の書式指定を表す JoinedStr ノードです。 書式指定がなければ None になります。 conversion と format_spec は同時に指定できます。 FormattedValue.format_spec と同じ意味を持ちます。

class ast.List(elts, ctx)

class ast.Tuple(elts, ctx)

リストまたはタプルをあらわします。 elts は内包する要素を表現するノードのリストを保持します。 ctx はコンテナが代入のターゲットである場合 (たとえば (x,y)=something のような場合) は Store であり、そうでない場合は Load です。

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

class ast.Set(elts)

集合 (set) をあらわします。 elts は集合の各要素を表現するノードのリストを保持します。

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

辞書をあらわします。 keys と values はそれぞれキーと値のノードのリスト を順序が一致した形で (それぞれ dictionary.keys() と dictionary.values() を呼び出したときに返される順序で) 保持します。

辞書リテラルで辞書のアンパックを行う場合、展開対象の式が values リストに入り、keys の対応する位置には None が入ります。

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

変数

class ast.Name(id, ctx)

変数名をあらわします。 id は変数名を文字列で保持し、 ctx は以下に示す型のいずれかです。

class ast.Load

class ast.Store

class ast.Del

変数の参照は変数の値をロードするか、新しい値を割り当てるか、または値を削除するために使うことができます。変数の参照はこれら3つの場合を区別するためのコンテキストによって与えられます。

>>> print(ast.dump(ast.parse('a'), indent=4))
Module(
    body=[
        Expr(
            value=Name(id='a'))])

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

*var 形式の変数の参照をあらわします。 value は変数、典型的には Name ノード、を保持します。この型は *args を伴う関数呼び出しノード Call を構築する際に使用します。

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

式 (expression)

class ast.Expr(value)

関数呼び出しのような式がそれ自身で文となり、戻り値が使われないかまたは保存されないとき、その式はこのコンテナでラップされます。 value はこの節で説明する他のノード、 Constant ノード、 Name ノード、 Lambda ノード Yield ノードまたは YieldFrom ノードのいずれかを保持します。

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

class ast.UnaryOp(op, operand)

単項演算をあらわします。 op は演算子で、 operand は任意の式ツリーのノードです。

class ast.UAdd

class ast.USub

class ast.Not

class ast.Invert

単項演算の演算子をあらわします。 Not は論理否定キーワード not であり、 Invert はビット反転演算子 ~ です。

>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))
Expression(
    body=UnaryOp(
        op=Not(),
        operand=Name(id='x')))

class ast.BinOp(left, op, right)

加算や除算のような二項演算を表します。 op は演算子で、left と right は任意の式ノードです。

>>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))
Expression(
    body=BinOp(
        left=Name(id='x'),
        op=Add(),
        right=Name(id='y')))

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

二項演算の演算子をあらわします。

class ast.BoolOp(op, values)

'or' や 'and' のような論理演算をあらわします。 op は Or または And です。 values は必要な値のリストです。 a or b or c のように同じ演算子を使う連続した演算は、複数の値を持った単一のノードとして表現されます。

not は単項演算 UnaryOp のため、ここには含まれません。

>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))
Expression(
    body=BoolOp(
        op=Or(),
        values=[
            Name(id='x'),
            Name(id='y')]))

class ast.And

class ast.Or

論理演算の演算子をあらわします。

class ast.Compare(left, ops, comparators)

2つ以上の値の比較をあらわします。 left 比較の中の最初の値、ops は演算子のリスト、 comparators は2つ目以降の値のリストです。

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

比較演算の演算子をあらわします。

class ast.Call(func, args, keywords)

関数呼び出しをあらわします。 func は関数で、多くの場合 Name または Attribute のオブジェクトです。 関数呼び出しの引数:

• args は位置引数のリストを保持します。

• keywords は、キーワードで渡す引数を表す keyword オブジェクトのリストを保持します。

args と keywords 引数は省略可能で、デフォルトは空リストです。

>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))
Expression(
    body=Call(
        func=Name(id='func'),
        args=[
            Name(id='a'),
            Starred(
                value=Name(id='d'))],
        keywords=[
            keyword(
                arg='b',
                value=Name(id='c')),
            keyword(
                value=Name(id='e'))]))

class ast.keyword(arg, value)

関数呼び出しまたはクラス定義のキーワード引数をあらわします。 arg はパラメータ名をあらわす文字列、 value は引数に渡す値をあらわすノードです。

class ast.IfExp(test, body, orelse)

a if b else c のような式をあらわします。各フィールドは単一のノードを保持します。以下の例では、3つの式ノードはすべて Name ノードです。

>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))
Expression(
    body=IfExp(
        test=Name(id='b'),
        body=Name(id='a'),
        orelse=Name(id='c')))

class ast.Attribute(value, attr, ctx)

たとえば d.keys のような属性へのアクセスです。 value はノードで、典型的には Name です。 attr は属性名を与える生の文字列で、 ctx はその属性がどのように振る舞うかに応じて Load、 Store または Del のいずれかです。

>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))
Expression(
    body=Attribute(
        value=Name(id='snake'),
        attr='colour'))

class ast.NamedExpr(target, value)

代入式です。この AST ノードは代入式演算子（ウォルラス演算子、または「セイウチ演算子」としても知られています）によって生成されます。第一引数が複数のノードであってもよい Assign ノードと異なり、このノードの場合は target と value の両方が単一のノードでなければなりません。

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

Added in version 3.8.

配列要素の参照 (Subscripting)

class ast.Subscript(value, slice, ctx)

l[1] のような配列要素の参照をあらわします。 value は参照元のオブジェクトです (通常シーケンス型またはマッピング型)。 slice はインデックス、スライス、またはキーです。 Slice を含む Tuple でもかまいません。 ctx は要素の参照により実行されるアクションに応じて Load、 Store または Del のいずれかです。

>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))
Expression(
    body=Subscript(
        value=Name(id='l'),
        slice=Tuple(
            elts=[
                Slice(
                    lower=Constant(value=1),
                    upper=Constant(value=2)),
                Constant(value=3)])))

class ast.Slice(lower, upper, step)

基本的なスライス操作 (lower:upper や lower:upper:step の形式) をあらわします。 Subscript の slice フィールドでの直接指定か、または Tuple の要素として指定する場合のみ利用可能です。

>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), indent=4))
Expression(
    body=Subscript(
        value=Name(id='l'),
        slice=Slice(
            lower=Constant(value=1),
            upper=Constant(value=2))))

内包表記 (Comprehension)

class ast.ListComp(elt, generators)

class ast.SetComp(elt, generators)

class ast.GeneratorExp(elt, generators)

class ast.DictComp(key, value, generators)

リストや集合の内包表記、ジェネレータ、および辞書の内包表記です。 elt (または key と value) は各要素として評価される部品をあらわす単一のノードです。

{**item for item in items} のようにアンパックを使う辞書内包表記では、展開する式が key に入り、value は None になります。

generators は comprehension ノードのリストです。

>>> print(ast.dump(
...     ast.parse('[x for x in numbers]', mode='eval'),
...     indent=4,
... ))
Expression(
    body=ListComp(
        elt=Name(id='x'),
        generators=[
            comprehension(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers'),
                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'),
        value=BinOp(
            left=Name(id='x'),
            op=Pow(),
            right=Constant(value=2)),
        generators=[
            comprehension(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers'),
                is_async=0)]))
>>> print(ast.dump(
...     ast.parse('{x for x in numbers}', mode='eval'),
...     indent=4,
... ))
Expression(
    body=SetComp(
        elt=Name(id='x'),
        generators=[
            comprehension(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers'),
                is_async=0)]))

class ast.comprehension(target, iter, ifs, is_async)

内包表記におけるひとつの for 節をあらわします。 target は各要素への参照です - 典型的には Name または Tuple ノードです。 iter はイテレートする対象のオブジェクトです。 ifs は条件節のリストです: 各 for 節は複数の ifs を持つことができます。

is_async は内包表記が非同期であることを示します (async for を for の代わりに使います)。値は整数です (0 または 1)。

>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),
...                indent=4)) # 一つの内包表記に複数の for 節。
Expression(
    body=ListComp(
        elt=Call(
            func=Name(id='ord'),
            args=[
                Name(id='c')]),
        generators=[
            comprehension(
                target=Name(id='line', ctx=Store()),
                iter=Name(id='file'),
                is_async=0),
            comprehension(
                target=Name(id='c', ctx=Store()),
                iter=Name(id='line'),
                is_async=0)]))

>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),
...                indent=4)) # ジェネレーター式
Expression(
    body=GeneratorExp(
        elt=BinOp(
            left=Name(id='n'),
            op=Pow(),
            right=Constant(value=2)),
        generators=[
            comprehension(
                target=Name(id='n', ctx=Store()),
                iter=Name(id='it'),
                ifs=[
                    Compare(
                        left=Name(id='n'),
                        ops=[
                            Gt()],
                        comparators=[
                            Constant(value=5)]),
                    Compare(
                        left=Name(id='n'),
                        ops=[
                            Lt()],
                        comparators=[
                            Constant(value=10)])],
                is_async=0)]))

>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),
...                indent=4)) # 非同期内包表記
Expression(
    body=ListComp(
        elt=Name(id='i'),
        generators=[
            comprehension(
                target=Name(id='i', ctx=Store()),
                iter=Name(id='soc'),
                is_async=1)]))

文 (Statements)

class ast.Assign(targets, value, type_comment)

代入です。 targets はノードのリスト、 value は単一のノードです。

targets の複数のノードは、それぞれに対して同じ値を代入することをあらわします。分割代入は targets 内に Tuple または List を置くことで表現されます。

type_comment

type_comment はコメントとして型アノテーションをあらわすオプション文字列です。

>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) # 多重代入
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)) # アンパック
Module(
    body=[
        Assign(
            targets=[
                Tuple(
                    elts=[
                        Name(id='a', ctx=Store()),
                        Name(id='b', ctx=Store())],
                    ctx=Store())],
            value=Name(id='c'))])

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

型アノテーションを伴う代入です。 target は単一のノードで、Name、Attribute、Subscript のいずれかです。 annotation はアノテーションを表す Constant や Name などのノードです。 value は省略可能な単一のノードです。

simple は常に 0 (「複雑な」代入先) または 1 (「単純な」代入先) のいずれかです。 「単純な」代入先は、括弧で囲まれていない Name ノードだけからなり、それ以外はすべて複雑な代入先とみなされます。 モジュールやクラスの __annotations__ 辞書に含まれるのは、単純な代入先だけです。

>>> print(ast.dump(ast.parse('c: int'), indent=4))
Module(
    body=[
        AnnAssign(
            target=Name(id='c', ctx=Store()),
            annotation=Name(id='int'),
            simple=1)])

>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # 括弧を伴うアノテーション
Module(
    body=[
        AnnAssign(
            target=Name(id='a', ctx=Store()),
            annotation=Name(id='int'),
            value=Constant(value=1),
            simple=0)])

>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) # 属性のアノテーション
Module(
    body=[
        AnnAssign(
            target=Attribute(
                value=Name(id='a'),
                attr='b',
                ctx=Store()),
            annotation=Name(id='int'),
            simple=0)])

>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) # 添字付きのアノテーション
Module(
    body=[
        AnnAssign(
            target=Subscript(
                value=Name(id='a'),
                slice=Constant(value=1),
                ctx=Store()),
            annotation=Name(id='int'),
            simple=0)])

class ast.AugAssign(target, op, value)

a += 1 のような累積代入をあらわします。下記の例では、 target は (Store コンテキストを伴う) x のための Name ノード、 op は Add 演算子、そして value は定数1をあらわす Constant ノードです。

Assign と異なり、 target 属性は class Tuple や List であってはいけません。

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

raise 文をあらわします。 exc は送出される例外オブジェクトで、通常は Call または Name、 もしくは単独の raise では None を指定します。 cause はオプションで、 raise x from y の y にあたります。

>>> print(ast.dump(ast.parse('raise x from y'), indent=4))
Module(
    body=[
        Raise(
            exc=Name(id='x'),
            cause=Name(id='y'))])

class ast.Assert(test, msg)

アサーションです。 test は Compare ノードなどのような条件を保持します。 msg は失敗した時のメッセージを保持します。

>>> print(ast.dump(ast.parse('assert x,y'), indent=4))
Module(
    body=[
        Assert(
            test=Name(id='x'),
            msg=Name(id='y'))])

class ast.Delete(targets)

del 文をあらわします。 targets は Name, Attribute, Subscript などのノードのリストです。

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

class ast.Pass

pass 文をあらわします。

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

class ast.TypeAlias(name, type_params, value)

type 文で作成した 型エイリアス です。 name はエイリアスの名前、type_params は 型パラメーター のリスト、value は型エイリアスの値です。

>>> print(ast.dump(ast.parse('type Alias = int'), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            value=Name(id='int'))])

Added in version 3.12.

関数またはループの内部でのみ適用可能な他の文は、別のセクションで説明します。

インポート

class ast.Import(names)

インポート文です。 names は 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')],
            is_lazy=0)])

class ast.ImportFrom(module, names, level)

from x import y をあらわします。 module は 'from' でインポートする先頭がドットでないモジュール名をあらわす文字列か、または from . import foo のような構文の場合は None を指定します。 level は相対インポートのレベルを表す整数を保持します (0 は絶対インポートを意味します)。

>>> 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,
            is_lazy=0)])

class ast.alias(name, asname)

いずれのパラメータも名前をあらわす生の文字列です。 asname は標準の名前を使う場合は None を指定できます。

>>> 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,
            is_lazy=0)])

制御フロー

注釈

else 節のようなオプションの節が存在しない場合は、空のリストとして保存されます。

class ast.If(test, body, orelse)

if 文です。 test は Compare ノードなどの単一のノードを保持します。 body と orelse はそれぞれノードのリストを保持します。

elif 節は AST において固有の表現を持たず、先行する節をあらわすノードの orelse セクションに追加の If ノードとして現れます。

>>> print(ast.dump(ast.parse("""
... if x:
...    ...
... elif y:
...    ...
... else:
...    ...
... """), indent=4))
Module(
    body=[
        If(
            test=Name(id='x'),
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            orelse=[
                If(
                    test=Name(id='y'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))],
                    orelse=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

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

for ループです。 target はループの代入先となる変数を、単一の Name、Tuple、List、Attribute、Subscript のいずれかのノードとして保持します。 iter は繰り返しの対象となるオブジェクトを、同じく単一のノードとして保持します。 body と orelse は実行するノードのリストを保持します。 orelse 内のノードは、break 文によらずループが正常に終了した場合に実行されます。

type_comment

type_comment はコメントとして型アノテーションをあらわすオプション文字列です。

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

class ast.While(test, body, orelse)

while ループです。 test は Compare のような条件をあらわすノードを保持します。

>>> print(ast.dump(ast.parse("""
... while x:
...    ...
... else:
...    ...
... """), indent=4))
Module(
    body=[
        While(
            test=Name(id='x'),
            body=[
                Expr(
                    value=Constant(value=Ellipsis))],
            orelse=[
                Expr(
                    value=Constant(value=Ellipsis))])])

class ast.Break

class ast.Continue

break 文および 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'),
            body=[
                If(
                    test=Compare(
                        left=Name(id='a'),
                        ops=[
                            Gt()],
                        comparators=[
                            Constant(value=5)]),
                    body=[
                        Break()],
                    orelse=[
                        Continue()])])])

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

try ブロックです。 ExceptHandler ノードのリストである handlers を除き、全ての属性はそれぞれの節で実行するノードのリストです。

>>> 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'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                ExceptHandler(
                    type=Name(id='OtherException'),
                    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)

except* 節を伴う try ブロックです。 属性は Try と同じですが、handlers 内の ExceptHandler ノードは except ではなく 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'),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

Added in version 3.11.

class ast.ExceptHandler(type, name, body)

単一の except 節をあらわします。 type はこの節にマッチする例外のタイプで、典型的には Name ノードです (None を指定すると全ての例外をキャッチする except: 節をあらわします)。 name は例外オブジェクトを保持する変数の名前をあらわす生の文字列で、 as foo を持たない節の場合は None を指定します。 body はノードのリストです。

>>> print(ast.dump(ast.parse("""\
... try:
...     a + 1
... except TypeError:
...     pass
... """), indent=4))
Module(
    body=[
        Try(
            body=[
                Expr(
                    value=BinOp(
                        left=Name(id='a'),
                        op=Add(),
                        right=Constant(value=1)))],
            handlers=[
                ExceptHandler(
                    type=Name(id='TypeError'),
                    body=[
                        Pass()])])])

class ast.With(items, body, type_comment)

with ブロックです。 items は withitem ノードのリストで、コンテキストマネージャのリストをあらわします。また body はコンテキスト内にインデントされたブロックです。

type_comment

type_comment はコメントとして型アノテーションをあらわすオプション文字列です。

class ast.withitem(context_expr, optional_vars)

with ブロックにおける単一のコンテキストマネージャをあらわします。 context_expr はコンテキストマネージャで、しばしば Call ノードが設定されます。 optional_vars は as foo に相当する Name, Tuple または List のいずれかのノードか、または、この部分が不要な場合は None を設定します。

>>> 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'),
                    optional_vars=Name(id='b', ctx=Store())),
                withitem(
                    context_expr=Name(id='c'),
                    optional_vars=Name(id='d', ctx=Store()))],
            body=[
                Expr(
                    value=Call(
                        func=Name(id='something'),
                        args=[
                            Name(id='b'),
                            Name(id='d')]))])])

パターンマッチ

class ast.Match(subject, cases)

match 文です。 subject はマッチ対象 (各 case と照合するオブジェクト) を保持し、cases は各 case を表す match_case ノードのイテラブルを保持します。

Added in version 3.10.

class ast.match_case(pattern, guard, body)

match 文の一つの case パターンです。 pattern は、対象と照合するパターンを保持します。 構文が同じでも、パターン用に生成される AST ノードは、式用に生成されるノードとは異なります。

guard 属性は、パターンが対象にマッチした場合に評価する式を保持します。

body は、パターンがマッチし、ガード式の評価結果が真だった場合に実行するノードのリストを保持します。

>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] if x>0:
...         ...
...     case tuple():
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchAs(name='x')]),
                    guard=Compare(
                        left=Name(id='x'),
                        ops=[
                            Gt()],
                        comparators=[
                            Constant(value=0)]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))]),
                match_case(
                    pattern=MatchClass(
                        cls=Name(id='tuple')),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

Added in version 3.10.

class ast.MatchValue(value)

等価比較を行うリテラルパターンまたは値パターンです。 value は式ノードです。 指定できる値ノードは、match 文のドキュメントに記載されたとおりに制限されます。 マッチ対象が、式を評価した値と等しければ成功します。

>>> print(ast.dump(ast.parse("""
... match x:
...     case "Relevant":
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchValue(
                        value=Constant(value='Relevant')),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

Added in version 3.10.

class ast.MatchSingleton(value)

同一性を比較するリテラルパターンです。 value は比較対象のシングルトンで、None、True、False のいずれかです。 マッチ対象がこの定数と同一のオブジェクトなら成功します。

>>> print(ast.dump(ast.parse("""
... match x:
...     case None:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchSingleton(value=None),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

Added in version 3.10.

class ast.MatchSequence(patterns)

シーケンスパターンです。 patterns は、対象がシーケンスである場合にその各要素と照合するパターンを保持します。 サブパターンの一つが MatchStar ノードなら可変長のシーケンスに、それ以外なら固定長のシーケンスにマッチします。

>>> print(ast.dump(ast.parse("""
... match x:
...     case [1, 2]:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchSequence(
                        patterns=[
                            MatchValue(
                                value=Constant(value=1)),
                            MatchValue(
                                value=Constant(value=2))]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

Added in version 3.10.

class ast.MatchStar(name)

可変長のシーケンスパターンで、シーケンスの残りの部分にマッチします。 name が None でなければ、シーケンスパターン全体が成功したときに、残りの要素を含むリストをその名前に束縛します。

>>> print(ast.dump(ast.parse("""
... match x:
...     case [1, 2, *rest]:
...         ...
...     case [*_]:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            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))])])])

Added in version 3.10.

class ast.MatchMapping(keys, patterns, rest)

マッピングパターンです。 keys は式ノードのシーケンス、patterns はそれに対応するパターンノードのシーケンスです。 rest は省略可能な名前で、マッピングの残りの要素を取得する場合に指定します。 キーに使える式は、match 文のドキュメントに記載されたとおりに制限されます。

対象がマッピングで、すべてのキー式の評価結果がそのマッピングに存在し、各キーに対応する値が対応するサブパターンにマッチすれば成功します。 rest が None でなければ、マッピングパターン全体が成功したときに、残りの要素を含む辞書をその名前に束縛します。

>>> print(ast.dump(ast.parse("""
... match x:
...     case {1: _, 2: _}:
...         ...
...     case {**rest}:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            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))])])])

Added in version 3.10.

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

クラスパターンです。 cls は照合に使うクラスを表す式です。 patterns はパターンノードのシーケンスで、クラスが定義するパターンマッチ用の属性の並びと照合します。 kwd_attrs は追加で照合する属性のシーケンス (クラスパターンのキーワード引数の名前)、kwd_patterns はそれらに対応するパターン (クラスパターンのキーワード引数の値) です。

対象が指定したクラスのインスタンスで、すべての位置パターンがクラスで定義した対応する属性にマッチし、キーワードで指定した属性もそれぞれ対応するパターンにマッチすれば成功します。

クラスに self を返すプロパティを定義すると、パターンノードをインスタンス自体と照合できます。 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'),
            cases=[
                match_case(
                    pattern=MatchClass(
                        cls=Name(id='Point2D'),
                        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'),
                        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))])])])

Added in version 3.10.

class ast.MatchAs(pattern, name)

AS パターン、キャプチャパターン、またはワイルドカードパターンです。 pattern は、対象と照合するパターンを保持します。 pattern が None の場合、このノードはキャプチャパターン (名前だけのパターン) を表し、常に成功します。

name 属性は、パターンが成功した場合に束縛する名前を保持します。 name が None の場合は pattern も None でなければならず、ノードはワイルドカードパターンを表します。

>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] as y:
...         ...
...     case _:
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            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))])])])

Added in version 3.10.

class ast.MatchOr(patterns)

OR パターンです。 各サブパターンを順に対象と照合し、どれか一つが成功すれば OR パターン全体が成功します。 どのサブパターンも成功しなければ失敗します。 patterns 属性は、対象と照合するパターンノードのリストを保持します。

>>> print(ast.dump(ast.parse("""
... match x:
...     case [x] | (y):
...         ...
... """), indent=4))
Module(
    body=[
        Match(
            subject=Name(id='x'),
            cases=[
                match_case(
                    pattern=MatchOr(
                        patterns=[
                            MatchSequence(
                                patterns=[
                                    MatchAs(name='x')]),
                            MatchAs(name='y')]),
                    body=[
                        Expr(
                            value=Constant(value=Ellipsis))])])])

Added in version 3.10.

型アノテーション

class ast.TypeIgnore(lineno, tag)

lineno 行にある # type: ignore コメントです。 tag は、# 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'),
            value=Constant(value=1),
            simple=1)],
    type_ignores=[
        TypeIgnore(lineno=1, tag='[assignment]')])

注釈

type_comments パラメーターが False (デフォルト) の場合、TypeIgnore ノードは生成されません。 詳細は ast.parse() を参照してください。

Added in version 3.8.

型パラメーター

クラス、関数、型エイリアスには 型パラメーター を定義できます。

class ast.TypeVar(name, bound, default_value)

typing.TypeVar を表します。 name は型変数の名前です。 bound は、指定されていれば上限または制約を保持します。 Tuple なら制約、それ以外なら上限を表します。 default_value はデフォルト値で、TypeVar にデフォルトがなければ 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'),
                    default_value=Name(id='bool'))],
            value=Subscript(
                value=Name(id='list'),
                slice=Name(id='T')))])

Added in version 3.12.

バージョン 3.13 で変更: default_value パラメーターが追加されました。

class ast.ParamSpec(name, default_value)

typing.ParamSpec を表します。 name はパラメーター仕様の名前です。 default_value はデフォルト値で、ParamSpec にデフォルトがなければ 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'),
                            Name(id='str')]))],
            value=Subscript(
                value=Name(id='Callable'),
                slice=Tuple(
                    elts=[
                        Name(id='P'),
                        Name(id='int')])))])

Added in version 3.12.

バージョン 3.13 で変更: default_value パラメーターが追加されました。

class ast.TypeVarTuple(name, default_value)

typing.TypeVarTuple を表します。 name は型変数タプルの名前です。 default_value はデフォルト値で、TypeVarTuple にデフォルトがなければ 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())],
            value=Subscript(
                value=Name(id='tuple'),
                slice=Tuple(
                    elts=[
                        Starred(
                            value=Name(id='Ts'))])))])

Added in version 3.12.

バージョン 3.13 で変更: default_value パラメーターが追加されました。

関数およびクラス定義

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

関数定義です。

• name は関数名をあらわす生の文字列です。

• args は引数をあらわす arguments ノードです。

• body は関数の本体をあらわすノードのリストです。

• decorator_list は関数に適用されるデコレータのリストで、外側のデコレータがリストの先頭に保存されます (すなわち、リストの先頭にあるデコレータが最後に適用されます)。

• returns は戻り値に対する注釈です。

• type_params は 型パラメーター のリストです。

type_comment

type_comment はコメントとして型アノテーションをあらわすオプション文字列です。

バージョン 3.12 で変更: type_params が追加されました。

class ast.Lambda(args, body)

lambda は式の中で使うことができる最小限の関数定義です。 FunctionDef ノードと異なり、 body は単一のノードとなります。

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

関数の引数

• posonlyargs, args および kwonlyargs はそれぞれ arg ノードのリストです。

• vararg と kwarg はそれぞれ単一の arg ノードで、 *args, **kwargs パラメータに相当します。

• kw_defaults はキーワード専用引数に対するデフォルト値のリストです。値が None の場合、対応する引数は必須となります。

• defaults は位置引数として渡すことのできる引数に対するデフォルト値のリストです。デフォルト値の数nが位置引数の数より少ない場合、それらは最後のn個の引数に割り当てられます。

class ast.arg(arg, annotation, type_comment)

引数リスト内の一つの引数を表します。 arg は引数名の文字列で、annotation は Name ノードなどで表すアノテーションです。

type_comment

type_comment はコメントとして型アノテーションをあらわすオプション文字列です。

>>> print(ast.dump(ast.parse("""\
... @decorator1
... @decorator2
... def f(a: 'annotation', b=1, c=2, *d, e, f=3, **g) -> 'return annotation':
...     pass
... """), indent=4))
Module(
    body=[
        FunctionDef(
            name='f',
            args=arguments(
                args=[
                    arg(
                        arg='a',
                        annotation=Constant(value='annotation')),
                    arg(arg='b'),
                    arg(arg='c')],
                vararg=arg(arg='d'),
                kwonlyargs=[
                    arg(arg='e'),
                    arg(arg='f')],
                kw_defaults=[
                    None,
                    Constant(value=3)],
                kwarg=arg(arg='g'),
                defaults=[
                    Constant(value=1),
                    Constant(value=2)]),
            body=[
                Pass()],
            decorator_list=[
                Name(id='decorator1'),
                Name(id='decorator2')],
            returns=Constant(value='return annotation'))])

class ast.Return(value)

return 文です。

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

class ast.Yield(value)

class ast.YieldFrom(value)

yield 式または yield from 式です。 これらは式なので、返されてきた値を使わない場合は Expr ノードで囲む必要があります。

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

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

class ast.Global(names)

class ast.Nonlocal(names)

global および nonlocal 文です。 names は生の文字列のリストです。

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

クラス定義です。

• name はクラス名をあらわす生の文字列です。

• bases は明示的に指定された基底クラスをあらわすノードのリストです。

• keywords は keyword ノードのリストで、主に 'metaclass' の指定に使います。 それ以外のキーワードは PEP 3115 に従ってメタクラスに渡されます。

• body はクラス定義に含まれるコードをあらわすノードのリストです。

• decorator_list はノードのリストで、関数定義 FunctionDef の場合と同様に解釈されます。

• type_params は 型パラメーター のリストです。

>>> 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'),
                Name(id='base2')],
            keywords=[
                keyword(
                    arg='metaclass',
                    value=Name(id='meta'))],
            body=[
                Pass()],
            decorator_list=[
                Name(id='decorator1'),
                Name(id='decorator2')])])

バージョン 3.12 で変更: type_params が追加されました。

async と await

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

async def 形式の関数定義です。通常の関数定義 FunctionDef と同じフィールドを持ちます。

バージョン 3.12 で変更: type_params が追加されました。

class ast.Await(value)

await 式をあらわします。 value は待ち受ける値です。 AsyncFunctionDef の本体 (body) の中でのみ有効です。

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

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

class ast.AsyncWith(items, body, type_comment)

async for ループと async with コンテキストマネージャです。それぞれ For および With と同じフィールドを持ちます。 AsyncFunctionDef の本体 (body) の中でのみ有効です。

注釈

ast.parse() で文字列を解析すると、返される木の演算子ノード (ast.operator、ast.unaryop、ast.cmpop、ast.boolop、ast.expr_context のサブクラス) はシングルトンになります。 一つを変更すると、同じ値 (例えば ast.Add) を持つ他のすべての箇所にも反映されます。

ast の補助機能

ast モジュールは、ノードクラスに加えて、抽象構文木をたどるための次の関数とクラスを定義しています。

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

ソースコードを解析し、AST ノードにします。 compile(source, filename, mode, flags=FLAGS_VALUE, optimize=optimize, module=module) と同じです。 ここで FLAGS_VALUE は、optimize <= 0 なら ast.PyCF_ONLY_AST、それ以外なら ast.PyCF_OPTIMIZED_AST です。

type_comments=True を指定すると、パーサーは PEP 484 と PEP 526 で定義された型コメントを検査して返すようになります。 これは compile() に渡すフラグに ast.PyCF_TYPE_COMMENTS を追加するのと同じです。 不適切な位置に型コメントがあると構文エラーを報告します。 このフラグがなければ型コメントは無視され、対応する AST ノードの type_comment フィールドは常に None になります。 また、# type: ignore コメントの位置は Module の type_ignores 属性として返されます (このフラグがなければ常に空リストです)。

さらに、mode が 'func_type' の場合、(str, int) -> List[str] のような PEP 484 の「シグネチャ型コメント」に対応する入力構文を使います。

feature_version にタプル (major, minor) を指定すると、できる限りその Python バージョンの文法を使って解析します。 例えば feature_version=(3, 9) なら、match 文を受け付けないようにします。 現在、major は 3 でなければなりません。 サポートする最も古いバージョンは (3, 7) (将来の Python では引き上げられる可能性があります)、最も新しいバージョンは sys.version_info[0:2] です。 あくまで可能な限り合わせるものであり、解析結果や解析の成否が feature_version に対応する Python で実行した場合と同じになる保証はありません。

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

警告

ソースコードを AST オブジェクトに解析できても、実行可能な正しい Python コードであるとは限りません。 コンパイルの段階で、さらに SyntaxError が送出される可能性があります。 例えば、return 42 というソースからは有効な return 文の AST ノードが生成されますが、単独ではコンパイルできません (関数ノードの内部に置く必要があります)。

特に、ast.parse() はスコープの検査を行いません。 これはコンパイルの段階で行われます。

警告

十分に大きい文字列や複雑な文字列によって Python の抽象構文木コンパイラのスタックの深さの限界を越えることで、 Python インタプリタをクラッシュさせることができます。

バージョン 3.8 で変更: type_comments、mode='func_type'、feature_version が追加されました。

バージョン 3.13 で変更: feature_version でサポートする最も古いバージョンが (3, 7) になりました。 optimize 引数が追加されました。

Added in version 3.15: module 引数が追加されました。

ast.unparse(ast_obj)

ast.AST オブジェクトを逆に構文解析して、 ast.parse() が元の ast.AST と等価なオブジェクトを生成できるような文字列を生成します。

警告

ast.AST オブジェクトの生成元となったコードと、生成されたコード文字列が一致するとは限りません (定数タプルや frozenset などに対するコンパイラ最適化を行わない場合でも同様です)。

警告

非常に複雑な式を逆構文解析すると RecursionError となることがあります。

Added in version 3.9.

ast.literal_eval(node_or_string)

Python のリテラルやコンテナ表現のみを含む式ノードまたは文字列を評価します。与えられる文字列またはノードは次の Python リテラル構造のみからなるものに限られます: 文字列、バイト列、数、タプル、リスト、辞書、集合、ブール値、None、Ellipsis。

この関数を使うと、Python の値を含む文字列を、自分で解析する処理を書かずに評価できます。 演算子やインデックス参照を含む式など、任意の複雑な式を評価することはできません。

この関数は以前、意味を明確にしないまま「安全」と説明されていましたが、これは誤解を招く表現でした。 より汎用的な eval() とは異なり、Python コードを実行しないように設計されています。 名前空間や名前の検索はなく、関数などを呼び出すこともできません。 しかし、攻撃を受けないわけではありません。 比較的小さな入力でも、メモリや C スタックを使い果たし、プロセスをクラッシュさせる可能性があります。 入力によっては、過剰な CPU 使用によるサービス拒否を引き起こす可能性もあります。 そのため、信頼できないデータに対して呼び出すことは推奨しません。

警告

Python の抽象構文木コンパイラのスタックの深さの限界を越えることで、 Python インタプリタをクラッシュさせる可能性があります。

不正な入力の内容によっては、ValueError、TypeError、SyntaxError、MemoryError、RecursionError を送出することがあります。

バージョン 3.2 で変更: バイト列リテラルと集合リテラルが受け取れるようになりました。

バージョン 3.9 で変更: 'set()' による空の集合の生成をサポートするようになりました。

バージョン 3.10 で変更: 文字列の入力では、先頭のスペースとタブを取り除くようになりました。

ast.get_docstring(node, clean=True)

与えられた node (これは FunctionDef, AsyncFunctionDef, ClassDef, Module のいずれかのノードでなければなりません) のドキュメント文字列を返します。もしドキュメント文字列が無ければ None を返します。 clean が真ならば、ドキュメント文字列のインデントを inspect.cleandoc() を用いて一掃します。

バージョン 3.5 で変更: AsyncFunctionDef がサポートされました。

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

source から、node の生成元となったソースコードの部分を取得します。 位置情報 (lineno、end_lineno、col_offset、end_col_offset) のいずれかが欠けていれば None を返します。

padded が True の場合、複数行にわたる文の最初の行が元の位置に一致するように空白文字でパディングされます。

Added in version 3.8.

ast.fix_missing_locations(node)

ノードの木を compile() でコンパイルする際、コンパイラは、対応するすべてのノードに lineno と col_offset 属性があることを前提とします。 生成したノードにこれらを手作業で設定するのは煩雑なので、この補助関数は、まだ設定されていない属性に親ノードの値を再帰的に設定します。 処理は node から始まります。

ast.increment_lineno(node, n=1)

node で始まるツリー内の各ノードの行番号と終了行番号を n ずつ増やします。これはファイルの中で別の場所に "コードを移動する" ときに便利です。

ast.copy_location(new_node, old_node)

可能であれば、old_node のソース上の位置 (lineno、col_offset、end_lineno、end_col_offset) を new_node にコピーし、new_node を返します。

ast.iter_fields(node)

node にある node._fields のそれぞれのフィールドを (フィールド名, 値) のタプルとして yield します。

ast.iter_child_nodes(node)

node の直接の子ノード全てを yield します。すなわち、yield されるのは、ノードであるような全てのフィールドおよびノードのリストであるようなフィールドの全てのアイテムです。

ast.walk(node)

node の全ての子孫ノード(node 自体を含む)を再帰的に yield します。順番は決められていません。この関数はノードをその場で変更するだけで文脈を気にしないような場合に便利です。

class ast.NodeVisitor

抽象構文木を渡り歩いてビジター関数を見つけたノードごとに呼び出すノード・ビジターの基底クラスです。この関数は visit() メソッドに送られる値を返してもかまいません。

このクラスはビジター・メソッドを付け加えたサブクラスを派生させることを意図しています。

visit(node)

ノードを訪れます。デフォルトの実装では self.visit_classname というメソッド (ここで classname はノードのクラス名です) を呼び出すか、そのメソッドがなければ generic_visit() を呼び出します。

generic_visit(node)

このビジターはノードの全ての子について visit() を呼び出します。

注意して欲しいのは、専用のビジター・メソッドを具えたノードの子ノードは、このビジターが generic_visit() を呼び出すかそれ自身で子ノードを訪れない限り訪れられないということです。

visit_Constant(node)

すべての定数ノードを処理します。

トラバースの途中でノードを変化させたいならば NodeVisitor を使ってはいけません。そうした目的のために変更を許す特別なビジター (NodeTransformer) があります。

バージョン 3.8 で非推奨、バージョン 3.14 で削除: Python 3.14 以降では、visit_Num()、visit_Str()、visit_Bytes()、visit_NameConstant()、visit_Ellipsis() メソッドは呼び出されません。 代わりに visit_Constant() メソッドを追加して、すべての定数ノードを処理してください。

class ast.NodeTransformer

NodeVisitor のサブクラスで抽象構文木を渡り歩きながらノードを変更することを許すものです。

NodeTransformer は抽象構文木(AST)を渡り歩き、ビジター・メソッドの戻り値を使って古いノードを置き換えたり削除したりします。ビジター・メソッドの戻り値が None ならば、ノードはその場から取り去られ、そうでなければ戻り値で置き換えられます。置き換えない場合は戻り値が元のノードそのものであってもかまいません。

それでは例を示しましょう。Name (たとえば foo) を見つけるたび全て data['foo'] に書き換える変換器 (transformer) です:

class RewriteName(NodeTransformer):

    def visit_Name(self, node):
        return Subscript(
            value=Name(id='data'),
            slice=Constant(value=node.id),
            ctx=node.ctx
        )

処理するノードに子ノードがある場合は、子ノードを自分で変換するか、先にそのノードに対して generic_visit() メソッドを呼び出す必要があります。

文のコレクションの要素であるノード (すべての文ノードが該当します) に対しては、ビジターは単一のノードの代わりにノードのリストを返すこともできます。

NodeTransformer で元の木にない新しいノードを追加し、lineno などの位置情報を設定していない場合は、新しい部分木に対して fix_missing_locations() を呼び出し、位置情報を補ってください。

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

たいてい、変換器の使い方は次のようになります:

node = YourTransformer().visit(node)

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

node 内のツリーのフォーマットされたダンプを返します。主な使い道はデバッグです。 annotate_fields が true の場合 (デフォルト)、返される文字列はフィールドの名前と値を示します。 annotate_fields が false の場合、あいまいさのないフィールド名を省略することにより、結果文字列はよりコンパクトになります。行番号や列オフセットのような属性はデフォルトではダンプされません。これが必要であれば、 include_attributes を true にすると表示できます。

color が True の場合、返される文字列は ANSI エスケープシーケンスで構文を色分けします。 False (デフォルト) の場合、色付きの出力は常に無効になります。

indent が非負の整数または文字列の場合、ツリーは指定されたインデントレベルで整形されて出力されます (pretty-printed)。インデントレベルがゼロ、負の数、または "" の場合は改行だけを挿入します。 None (デフォルト値) は単一行での表記になります。正の整数を指定すると各インデントレベルでその数だけの空白でインデントされます。 indent が文字列 ("\t" など) の場合、その文字列が各レベルのインデントに使われます。

show_empty が偽 (デフォルト) の場合、省略可能な空リストと Load() の値は出力から省かれます。 省略可能な None の値は常に省かれます。

>>> tree = ast.parse('print(None)', '?', 'eval')
>>> print(ast.dump(tree, indent=4))
Expression(
    body=Call(
        func=Name(id='print'),
        args=[
            Constant(value=None)]))
>>> print(ast.dump(tree, indent=4, show_empty=True))
Expression(
    body=Call(
        func=Name(id='print', ctx=Load()),
        args=[
            Constant(value=None)],
        keywords=[]))

バージョン 3.9 で変更: indent オプションを追加しました。

バージョン 3.13 で変更: show_empty オプションが追加されました。

バージョン 3.15 で変更: 省略可能な Load() の値をデフォルトで省くようになりました。

バージョン 3.15 で変更: color パラメーターが追加されました。

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

二つの AST を再帰的に比較します。

compare_attributes は、比較に AST の属性を含めるかどうかを指定します。 False (デフォルト) の場合は属性を無視し、それ以外の場合はすべての属性が等しい必要があります。 このオプションは、空白などの細部が異なっていても AST の構造が等しいかどうかを調べる際に便利です。 属性には行番号や列オフセットが含まれます。

Added in version 3.14.

コンパイラのフラグ

以下のフラグはプログラムのコンパイルにおける効果を変更するために compile() に渡すことができます:

ast.PyCF_ALLOW_TOP_LEVEL_AWAIT

トップレベルの await, async for, async with および async 内包表記のサポートを有効化します。

Added in version 3.8.

ast.PyCF_ONLY_AST

コンパイルされたコードオブジェクトの代わりに抽象構文木を生成して返します。

ast.PyCF_OPTIMIZED_AST

返される AST は、compile() または ast.parse() の optimize 引数に従って最適化されます。

Added in version 3.13.

ast.PyCF_TYPE_COMMENTS

PEP 484 および PEP 526 形式の型コメント (# type: <type>, # type: ignore <stuff>) のサポートを有効化します。

Added in version 3.8.

コマンドラインでの使用

Added in version 3.9.

バージョン 3.15 で変更: デフォルトで、出力の構文を色分けするようになりました。 この動作は 環境変数で制御できます。

ast モジュールは、次のようにコマンドラインからスクリプトとして実行できます。

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

以下のオプションが使用できます:

-h, --help

ヘルプメッセージを表示して終了します。

-m <mode>

--mode <mode>

parse() 関数の mode 引数と同様、コンパイルするコードの種類を指定します。

--no-type-comments

型コメントをパースしません。

-a, --include-attributes

行番号や列オフセットなどの属性を含めます。

-i <indent>

--indent <indent>

AST におけるノードのインデント (空白の数) です。

--feature-version <version>

3.x 形式の Python バージョン (例: 3.10)。 デフォルトは現在のインタープリタのバージョンです。

Added in version 3.14.

-O <level>

--optimize <level>

パーサーの最適化レベル。 デフォルトでは最適化しません。

Added in version 3.14.

--show-empty

Show empty lists and fields that are None. Defaults to not showing empty objects.

Added in version 3.14.

infile を指定するとその内容が AST にパースされて標準出力に出力されます。そうでない場合は標準入力から入力を読み込みます。

参考

外部ドキュメント Green Tree Snakes には Python AST についての詳細が書かれています。

ASTTokens は Python AST を、生成元のソースコードのトークン位置やテキストで注解します。これはソースコード変換を行うツールで有用です。

leoAst.py は、トークンと AST ノードの間に双方向のリンクを挿入することで、Python プログラムのトークンに基づく表現と構文木に基づく表現を結び付けます。

LibCST はコードを ast ツリーに似た構文木 (Concrete Syntax Tree) にパースし、かつ全ての書式設定の詳細を保持します。これは自動リファクタリングアプリケーション (codemod) やリンタを作成する際に有用です。

Parso は、エラーからの回復と、ソースコードを解析して元に戻す処理をサポートする Python パーサーです。 複数の Python バージョン上で動作し、異なるバージョンの構文を扱えます。 Python ファイル内の複数の構文エラーを列挙することもできます。