ast — 抽象语法树¶

类型参数¶

类型参数 可以存在于类、函数和类型别名中。

class ast.TypeVar(name, bound)¶

一个 typing.TypeVar。 name 是类型变量的名称。 bound 是绑定或约束（如果有）。如果 bound 是一个 Tuple，它表示约束；否则它表示绑定。

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

在 3.12 版本中添加。

class ast.ParamSpec(name)¶

一个 typing.ParamSpec。 name 是参数规范的名称。

>>> print(ast.dump(ast.parse("type Alias[**P] = Callable[P, int]"), indent=4))
Module(
    body=[
        TypeAlias(
            name=Name(id='Alias', ctx=Store()),
            type_params=[
                ParamSpec(name='P')],
            value=Subscript(
                value=Name(id='Callable', ctx=Load()),
                slice=Tuple(
                    elts=[
                        Name(id='P', ctx=Load()),
                        Name(id='int', ctx=Load())],
                    ctx=Load()),
                ctx=Load()))],
    type_ignores=[])

在 3.12 版本中添加。

class ast.TypeVarTuple(name)¶

一个 typing.TypeVarTuple。 name 是类型变量元组的名称。

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

在 3.12 版本中添加。

函数和类定义¶

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(
                    posonlyargs=[],
                    args=[
                        arg(arg='x'),
                        arg(arg='y')],
                    kwonlyargs=[],
                    kw_defaults=[],
                    defaults=[]),
                body=Constant(value=Ellipsis)))],
    type_ignores=[])

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

函数的参数。

• posonlyargs、 args 和 kwonlyargs 是 arg 节点的列表。

• vararg 和 kwarg 是单个 arg 节点，分别指代 *args, **kwargs 参数。

• kw_defaults 是关键字参数的默认值列表。如果其中一个是 None，则相应的参数是必需的。

• defaults 是可以按位置传递的参数的默认值列表。如果默认值较少，则它们对应于最后 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(
                posonlyargs=[],
                args=[
                    arg(
                        arg='a',
                        annotation=Constant(value='annotation')),
                    arg(arg='b'),
                    arg(arg='c')],
                vararg=arg(arg='d'),
                kwonlyargs=[
                    arg(arg='e'),
                    arg(arg='f')],
                kw_defaults=[
                    None,
                    Constant(value=3)],
                kwarg=arg(arg='g'),
                defaults=[
                    Constant(value=1),
                    Constant(value=2)]),
            body=[
                Pass()],
            decorator_list=[
                Name(id='decorator1', ctx=Load()),
                Name(id='decorator2', ctx=Load())],
            returns=Constant(value='return annotation'),
            type_params=[])],
    type_ignores=[])

class ast.Return(value)¶

一个 return 语句。

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

class ast.Yield(value)¶

class ast.YieldFrom(value)¶

一个 yield 或 yield from 表达式。由于这些是表达式，因此如果发送回的值未使用，则必须将其包装在 Expr 节点中。

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

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

class ast.Global(names)¶

class ast.Nonlocal(names)¶

global 和 nonlocal 语句。 names 是原始字符串的列表。

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

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

class ast.ClassDef(name, bases, keywords, 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', ctx=Load()),
                Name(id='base2', ctx=Load())],
            keywords=[
                keyword(
                    arg='metaclass',
                    value=Name(id='meta', ctx=Load()))],
            body=[
                Pass()],
            decorator_list=[
                Name(id='decorator1', ctx=Load()),
                Name(id='decorator2', ctx=Load())],
            type_params=[])],
    type_ignores=[])

在 3.12 版本中更改: 添加了 type_params。

异步和等待¶

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 的主体中有效。

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

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

class ast.AsyncWith(items, body, type_comment)¶

async for 循环和 async with 上下文管理器。它们具有与 For 和 With 相同的字段。仅在 AsyncFunctionDef 的主体中有效。