"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 ファイル内の複数の構文エ
  ラーを列挙することもできます。
