创新互联Python教程：ast —- 抽象语法树

ast —- 抽象语法树

源代码： Lib/ast.py

创新互联建站是专业的淄博网站建设公司，淄博接单;提供成都网站设计、网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行淄博网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

ast 模块帮助 python 程序处理 Python 语法的抽象语法树。抽象语法或许会随着 Python 的更新发布而改变；该模块能够帮助理解当前语法在编程层面的样貌。

抽象语法树可通过将 ast.PyCF_ONLY_AST 作为旗标传递给 compile() 内置函数来生成，或是使用此模块中提供的 parse() 辅助函数。返回结果将是一个对象树，，其中的类都继承自 ast.AST。抽象语法树可被内置的 compile() 函数编译为一个 Python 代码对象。

抽象文法

抽象文法目前定义如下

 
 
 
 
      
  
  
  
  1. -- ASDL's 4 builtin types are:
    2.   
  
  
  
  2. -- identifier, int, string, constant
    3.   
  
  
  
    4.   
  
  
  
  4. module Python
    5.   
  
  
  
  5. {
    6.   
  
  
  
  6.  mod = Module(stmt* body, type_ignore* type_ignores)
    7.   
  
  
  
  7.  | Interactive(stmt* body)
    8.   
  
  
  
  8.  | Expression(expr body)
    9.   
  
  
  
  9.  | FunctionType(expr* argtypes, expr returns)
    10.   
  
  
  
    11.   
  
  
  
  11.  stmt = FunctionDef(identifier name, arguments args,
    12.   
  
  
  
  12.  stmt* body, expr* decorator_list, expr? returns,
    13.   
  
  
  
  13.  string? type_comment)
    14.   
  
  
  
  14.  | AsyncFunctionDef(identifier name, arguments args,
    15.   
  
  
  
  15.  stmt* body, expr* decorator_list, expr? returns,
    16.   
  
  
  
  16.  string? type_comment)
    17.   
  
  
  
    18.   
  
  
  
  18.  | ClassDef(identifier name,
    19.   
  
  
  
  19.  expr* bases,
    20.   
  
  
  
  20.  keyword* keywords,
    21.   
  
  
  
  21.  stmt* body,
    22.   
  
  
  
  22.  expr* decorator_list)
    23.   
  
  
  
  23.  | Return(expr? value)
    24.   
  
  
  
    25.   
  
  
  
  25.  | Delete(expr* targets)
    26.   
  
  
  
  26.  | Assign(expr* targets, expr value, string? type_comment)
    27.   
  
  
  
  27.  | AugAssign(expr target, operator op, expr value)
    28.   
  
  
  
  28.  -- 'simple' indicates that we annotate simple name without parens
    29.   
  
  
  
  29.  | AnnAssign(expr target, expr annotation, expr? value, int simple)
    30.   
  
  
  
    31.   
  
  
  
  31.  -- use 'orelse' because else is a keyword in target languages
    32.   
  
  
  
  32.  | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
    33.   
  
  
  
  33.  | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
    34.   
  
  
  
  34.  | While(expr test, stmt* body, stmt* orelse)
    35.   
  
  
  
  35.  | If(expr test, stmt* body, stmt* orelse)
    36.   
  
  
  
  36.  | With(withitem* items, stmt* body, string? type_comment)
    37.   
  
  
  
  37.  | AsyncWith(withitem* items, stmt* body, string? type_comment)
    38.   
  
  
  
    39.   
  
  
  
  39.  | Match(expr subject, match_case* cases)
    40.   
  
  
  
    41.   
  
  
  
  41.  | Raise(expr? exc, expr? cause)
    42.   
  
  
  
  42.  | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
    43.   
  
  
  
  43.  | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)
    44.   
  
  
  
  44.  | Assert(expr test, expr? msg)
    45.   
  
  
  
    46.   
  
  
  
  46.  | Import(alias* names)
    47.   
  
  
  
  47.  | ImportFrom(identifier? module, alias* names, int? level)
    48.   
  
  
  
    49.   
  
  
  
  49.  | Global(identifier* names)
    50.   
  
  
  
  50.  | Nonlocal(identifier* names)
    51.   
  
  
  
  51.  | Expr(expr value)
    52.   
  
  
  
  52.  | Pass | Break | Continue
    53.   
  
  
  
    54.   
  
  
  
  54.  -- col_offset is the byte offset in the utf8 string the parser uses
    55.   
  
  
  
  55.  attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
    56.   
  
  
  
    57.   
  
  
  
  57.  -- BoolOp() can use left & right?
    58.   
  
  
  
  58.  expr = BoolOp(boolop op, expr* values)
    59.   
  
  
  
  59.  | NamedExpr(expr target, expr value)
    60.   
  
  
  
  60.  | BinOp(expr left, operator op, expr right)
    61.   
  
  
  
  61.  | UnaryOp(unaryop op, expr operand)
    62.   
  
  
  
  62.  | Lambda(arguments args, expr body)
    63.   
  
  
  
  63.  | IfExp(expr test, expr body, expr orelse)
    64.   
  
  
  
  64.  | Dict(expr* keys, expr* values)
    65.   
  
  
  
  65.  | Set(expr* elts)
    66.   
  
  
  
  66.  | ListComp(expr elt, comprehension* generators)
    67.   
  
  
  
  67.  | SetComp(expr elt, comprehension* generators)
    68.   
  
  
  
  68.  | DictComp(expr key, expr value, comprehension* generators)
    69.   
  
  
  
  69.  | GeneratorExp(expr elt, comprehension* generators)
    70.   
  
  
  
  70.  -- the grammar constrains where yield expressions can occur
    71.   
  
  
  
  71.  | Await(expr value)
    72.   
  
  
  
  72.  | Yield(expr? value)
    73.   
  
  
  
  73.  | YieldFrom(expr value)
    74.   
  
  
  
  74.  -- need sequences for compare to distinguish between
    75.   
  
  
  
  75.  -- x < 4 < 3 and (x < 4) < 3
    76.   
  
  
  
  76.  | Compare(expr left, cmpop* ops, expr* comparators)
    77.   
  
  
  
  77.  | Call(expr func, expr* args, keyword* keywords)
    78.   
  
  
  
  78.  | FormattedValue(expr value, int conversion, expr? format_spec)
    79.   
  
  
  
  79.  | JoinedStr(expr* values)
    80.   
  
  
  
  80.  | Constant(constant value, string? kind)
    81.   
  
  
  
    82.   
  
  
  
  82.  -- the following expression can appear in assignment context
    83.   
  
  
  
  83.  | Attribute(expr value, identifier attr, expr_context ctx)
    84.   
  
  
  
  84.  | Subscript(expr value, expr slice, expr_context ctx)
    85.   
  
  
  
  85.  | Starred(expr value, expr_context ctx)
    86.   
  
  
  
  86.  | Name(identifier id, expr_context ctx)
    87.   
  
  
  
  87.  | List(expr* elts, expr_context ctx)
    88.   
  
  
  
  88.  | Tuple(expr* elts, expr_context ctx)
    89.   
  
  
  
    90.   
  
  
  
  90.  -- can appear only in Subscript
    91.   
  
  
  
  91.  | Slice(expr? lower, expr? upper, expr? step)
    92.   
  
  
  
    93.   
  
  
  
  93.  -- col_offset is the byte offset in the utf8 string the parser uses
    94.   
  
  
  
  94.  attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
    95.   
  
  
  
    96.   
  
  
  
  96.  expr_context = Load | Store | Del
    97.   
  
  
  
    98.   
  
  
  
  98.  boolop = And | Or
    99.   
  
  
  
    100.   
  
  
  
  100.  operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift
    101.   
  
  
  
  101.  | RShift | BitOr | BitXor | BitAnd | FloorDiv
    102.   
  
  
  
    103.   
  
  
  
  103.  unaryop = Invert | Not | UAdd | USub
    104.   
  
  
  
    105.   
  
  
  
  105.  cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn
    106.   
  
  
  
    107.   
  
  
  
  107.  comprehension = (expr target, expr iter, expr* ifs, int is_async)
    108.   
  
  
  
    109.   
  
  
  
  109.  excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)
    110.   
  
  
  
  110.  attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
    111.   
  
  
  
    112.   
  
  
  
  112.  arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,
    113.   
  
  
  
  113.  expr* kw_defaults, arg? kwarg, expr* defaults)
    114.   
  
  
  
    115.   
  
  
  
  115.  arg = (identifier arg, expr? annotation, string? type_comment)
    116.   
  
  
  
  116.  attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
    117.   
  
  
  
    118.   
  
  
  
  118.  -- keyword arguments supplied to call (NULL identifier for **kwargs)
    119.   
  
  
  
  119.  keyword = (identifier? arg, expr value)
    120.   
  
  
  
  120.  attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
    121.   
  
  
  
    122.   
  
  
  
  122.  -- import name with optional 'as' alias.
    123.   
  
  
  
  123.  alias = (identifier name, identifier? asname)
    124.   
  
  
  
  124.  attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)
    125.   
  
  
  
    126.   
  
  
  
  126.  withitem = (expr context_expr, expr? optional_vars)
    127.   
  
  
  
    128.   
  
  
  
  128.  match_case = (pattern pattern, expr? guard, stmt* body)
    129.   
  
  
  
    130.   
  
  
  
  130.  pattern = MatchValue(expr value)
    131.   
  
  
  
  131.  | MatchSingleton(constant value)
    132.   
  
  
  
  132.  | MatchSequence(pattern* patterns)
    133.   
  
  
  
  133.  | MatchMapping(expr* keys, pattern* patterns, identifier? rest)
    134.   
  
  
  
  134.  | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)
    135.   
  
  
  
    136.   
  
  
  
  136.  | MatchStar(identifier? name)
    137.   
  
  
  
  137.  -- The optional "rest" MatchMapping parameter handles capturing extra mapping keys
    138.   
  
  
  
    139.   
  
  
  
  139.  | MatchAs(pattern? pattern, identifier? name)
    140.   
  
  
  
  140.  | MatchOr(pattern* patterns)
    141.   
  
  
  
    142.   
  
  
  
  142.  attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)
    143.   
  
  
  
    144.   
  
  
  
  144.  type_ignore = TypeIgnore(int lineno, string tag)
    145.   
  
  
  
  145. }
    146.

节点类

class ast.AST

This is the base of all AST node classes. The actual node classes are derived from the Parser/Python.asdl file, which is reproduced above. They are defined in the _ast C module and re-exported in ast.

抽象语法定义的每个左侧符号(比方说， ast.stmt 或者 ast.expr)定义了一个类。另外，在抽象语法定义的右侧，对每一个构造器也定义了一个类；这些类继承自树左侧的类。比如，ast.BinOp 继承自 ast.expr。对于多分支产生式(也就是”和规则”)，树右侧的类是抽象的；只有特定构造器结点的实例能被构造。

  • _fields

    每个具体类都有个属性 _fields, 用来给出所有子节点的名字。

    每个具体类的实例对它每个子节点都有一个属性，对应类型如文法中所定义。比如，ast.BinOp 的实例有个属性 left，类型是 ast.expr.

    如果这些属性在文法中标记为可选（使用问号），对应值可能会是 None。如果这些属性有零或多个（用星号标记），对应值会用Python的列表来表示。所有可能的属性必须在用 compile() 编译得到AST时给出，且是有效的值。

  • lineno

    col_offset

    end_lineno

    end_col_offset

    ast.expr 和 ast.stmt 子类的实例有 lineno、col_offset、end_lineno 和 end_lineno 属性。lineno 和 end_lineno 是源代码的第一行行数和最后一行行数（从1开始, 所以第一行行数是1），而 col_offset 和 end_col_offset 是该生成节点第一个和最后一个 token 的 UTF-8 字节偏移量。记录下 UTF-8 偏移量的原因是 parser 内部使用 UTF-8 。

    注意编译器不需要结束位置，所以结束位置是可选的。结束偏移在最后一个符号*之后*，例如你可以通过 source_line[node.col_offset : node.end_col_offset] 获得一个单行表达式节点的源码片段。

一个类的构造器 ast.T 像下面这样parse它的参数。

  • 如果有位置参数，它们必须和 T._fields 中的元素一样多；他们会像这些名字的属性一样被赋值。

  • 如果有关键字参数，它们必须被设为和给定值同名的属性。

比方说，要创建和填充节点 ast.UnaryOp，你得用

 
 
 
 
      
  
  
  
  1. node = ast.UnaryOp()
    2.   
  
  
  
  2. node.op = ast.USub()
    3.   
  
  
  
  3. node.operand = ast.Constant()
    4.   
  
  
  
  4. node.operand.value = 5
    5.   
  
  
  
  5. node.operand.lineno = 0
    6.   
  
  
  
  6. node.operand.col_offset = 0
    7.   
  
  
  
  7. node.lineno = 0
    8.   
  
  
  
  8. node.col_offset = 0
    9.

或者更紧凑点

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

在 3.8 版更改: 类 ast.Constant 现在用于所有常量。

在 3.9 版更改: 简单索引由它们的值表示，扩展切片表示为元组。

3.8 版后已移除: 旧的类 ast.Num、ast.Str、 ast.Bytes、ast.NameConstant 和 ast.Ellipsis 仍然有效，但是它们会在未来的 Python 版本中被移除。同时，实例化它们会返回一个不同类的实例。

3.9 版后已移除: 旧的类 ast.Index 和 ast.ExtSlice 仍然有效，但是它们会在未来的 Python 版本中被移除。同时，实例化它们会返回一个不同类的实例。

备注

在此显示的特定节点类的描述最初是改编自杰出的 Green Tree Snakes 项目及其所有贡献者。

字面值

class ast.Constant(value)

一个常量。 Constant 字面值的 value 属性即为其代表的 Python 对象。它可以代表简单的数字，字符串或者 None 对象，但是也可以代表所有元素都是常量的不可变容器（例如元组或冻结集合）。

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

class ast.FormattedValue(value, conversion, format_spec)

节点是以一个 f-字符串形式的格式化字段来代表的。 如果该字符串只包含单个格式化字段而没有任何其他内容则节点可以被隔离，否则它将在 JoinedStr 中出现。

  • value 为任意的表达式节点（如一个字面值、变量或函数调用）。

  • conversion 是一个整数:

    • -1: 无格式化

    • 115: !s 字符串格式化

    • 114: !r repr 格式化

    • 97: !a ascii 格式化

  • format_spec 是一个代表值的格式化的 JoinedStr 节点，或者如果未指定格式则为 None。 conversion 和 format_spec 可以被同时设置。

class ast.JoinedStr(values)

一个 f-字符串，由一系列 FormattedValue 和 Constant 节点组成。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('f"sin({a}) is {sin(a):.3}"', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=JoinedStr(
    4.   
  
  
  
  4.  values=[
    5.   
  
  
  
  5.  Constant(value='sin('),
    6.   
  
  
  
  6.  FormattedValue(
    7.   
  
  
  
  7.  value=Name(id='a', ctx=Load()),
    8.   
  
  
  
  8.  conversion=-1),
    9.   
  
  
  
  9.  Constant(value=') is '),
    10.   
  
  
  
  10.  FormattedValue(
    11.   
  
  
  
  11.  value=Call(
    12.   
  
  
  
  12.  func=Name(id='sin', ctx=Load()),
    13.   
  
  
  
  13.  args=[
    14.   
  
  
  
  14.  Name(id='a', ctx=Load())],
    15.   
  
  
  
  15.  keywords=[]),
    16.   
  
  
  
  16.  conversion=-1,
    17.   
  
  
  
  17.  format_spec=JoinedStr(
    18.   
  
  
  
  18.  values=[
    19.   
  
  
  
  19.  Constant(value='.3')]))]))
    20.

class ast.List(elts, ctx)

class ast.Tuple(elts, ctx)

一个列表或元组。 elts 保存一个代表元素的节点的列表。 ctx 在容器为赋值的目标时 (如 (x,y)=something) 是 Store，否则是 Load。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=List(
    4.   
  
  
  
  4.  elts=[
    5.   
  
  
  
  5.  Constant(value=1),
    6.   
  
  
  
  6.  Constant(value=2),
    7.   
  
  
  
  7.  Constant(value=3)],
    8.   
  
  
  
  8.  ctx=Load()))
    9.   
  
  
  
  9. >>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))
    10.   
  
  
  
  10. Expression(
    11.   
  
  
  
  11.  body=Tuple(
    12.   
  
  
  
  12.  elts=[
    13.   
  
  
  
  13.  Constant(value=1),
    14.   
  
  
  
  14.  Constant(value=2),
    15.   
  
  
  
  15.  Constant(value=3)],
    16.   
  
  
  
  16.  ctx=Load()))
    17.

class ast.Set(elts)

一个集合。 elts 保存一个代表集合的元组的节点的列表。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=Set(
    4.   
  
  
  
  4.  elts=[
    5.   
  
  
  
  5.  Constant(value=1),
    6.   
  
  
  
  6.  Constant(value=2),
    7.   
  
  
  
  7.  Constant(value=3)]))
    8.

class ast.Dict(keys, values)

一个字典。 keys 和 values 保存分别代表键和值的节点的列表，按照匹配的顺序（即当调用 dictionary.keys() 和 dictionary.values() 时将返回的结果）。

当使用字典字面值进行字典解包操作时要扩展的表达式放入 values 列表，并将 None 放入 keys 的对应位置。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=Dict(
    4.   
  
  
  
  4.  keys=[
    5.   
  
  
  
  5.  Constant(value='a'),
    6.   
  
  
  
  6.  None],
    7.   
  
  
  
  7.  values=[
    8.   
  
  
  
  8.  Constant(value=1),
    9.   
  
  
  
  9.  Name(id='d', ctx=Load())]))
    10.

变量

class ast.Name(id, ctx)

一个变量名。 id 将名称保存为字符串，而 ctx 为下列类型之一。

class ast.Load

class ast.Store

class ast.Del

变量引用可被用来载入一个变量的值，为其赋一个新值，或是将其删除。 变量引用会给出一个上下文来区分这几种情况。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('a'), indent=4))
    2.   
  
  
  
  2. Module(
    3.   
  
  
  
  3.  body=[
    4.   
  
  
  
  4.  Expr(
    5.   
  
  
  
  5.  value=Name(id='a', ctx=Load()))],
    6.   
  
  
  
  6.  type_ignores=[])
    7.   
  
  
  
    8.   
  
  
  
  8. >>> print(ast.dump(ast.parse('a = 1'), indent=4))
    9.   
  
  
  
  9. Module(
    10.   
  
  
  
  10.  body=[
    11.   
  
  
  
  11.  Assign(
    12.   
  
  
  
  12.  targets=[
    13.   
  
  
  
  13.  Name(id='a', ctx=Store())],
    14.   
  
  
  
  14.  value=Constant(value=1))],
    15.   
  
  
  
  15.  type_ignores=[])
    16.   
  
  
  
    17.   
  
  
  
  17. >>> print(ast.dump(ast.parse('del a'), indent=4))
    18.   
  
  
  
  18. Module(
    19.   
  
  
  
  19.  body=[
    20.   
  
  
  
  20.  Delete(
    21.   
  
  
  
  21.  targets=[
    22.   
  
  
  
  22.  Name(id='a', ctx=Del())])],
    23.   
  
  
  
  23.  type_ignores=[])
    24.

class ast.Starred(value, ctx)

一个 *var 变量引用。 value 保存变量，通常为一个 Name 节点。 此类型必须在构建 Call 节点并传入 *args 时被使用。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('a, *b = it'), indent=4))
    2.   
  
  
  
  2. Module(
    3.   
  
  
  
  3.  body=[
    4.   
  
  
  
  4.  Assign(
    5.   
  
  
  
  5.  targets=[
    6.   
  
  
  
  6.  Tuple(
    7.   
  
  
  
  7.  elts=[
    8.   
  
  
  
  8.  Name(id='a', ctx=Store()),
    9.   
  
  
  
  9.  Starred(
    10.   
  
  
  
  10.  value=Name(id='b', ctx=Store()),
    11.   
  
  
  
  11.  ctx=Store())],
    12.   
  
  
  
  12.  ctx=Store())],
    13.   
  
  
  
  13.  value=Name(id='it', ctx=Load()))],
    14.   
  
  
  
  14.  type_ignores=[])
    15.

表达式

class ast.Expr(value)

当一个表达式，例如函数调用，本身作为一个语句出现并且其返回值未被使用或存储时，它会被包装在此容器中。 value 保存本节中的其他节点之一，一个 Constant, Name, Lambda, Yield 或者 YieldFrom 节点。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('-a'), indent=4))
    2.   
  
  
  
  2. Module(
    3.   
  
  
  
  3.  body=[
    4.   
  
  
  
  4.  Expr(
    5.   
  
  
  
  5.  value=UnaryOp(
    6.   
  
  
  
  6.  op=USub(),
    7.   
  
  
  
  7.  operand=Name(id='a', ctx=Load())))],
    8.   
  
  
  
  8.  type_ignores=[])
    9.

class ast.UnaryOp(op, operand)

一个单目运算。 op 是运算符，而 operand 是任意表达式节点。

class ast.UAdd

class ast.USub

class ast.Not

class ast.Invert

单目运算符对应的形符。 Not 是 not 关键字，Invert 是 ~ 运算符。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=UnaryOp(
    4.   
  
  
  
  4.  op=Not(),
    5.   
  
  
  
  5.  operand=Name(id='x', ctx=Load())))
    6.

class ast.BinOp(left, op, right)

一个双目运算（如相加或相减）。 op 是运算符，而 left 和 right 是任意表达式节点。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=BinOp(
    4.   
  
  
  
  4.  left=Name(id='x', ctx=Load()),
    5.   
  
  
  
  5.  op=Add(),
    6.   
  
  
  
  6.  right=Name(id='y', ctx=Load())))
    7.

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。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=BoolOp(
    4.   
  
  
  
  4.  op=Or(),
    5.   
  
  
  
  5.  values=[
    6.   
  
  
  
  6.  Name(id='x', ctx=Load()),
    7.   
  
  
  
  7.  Name(id='y', ctx=Load())]))
    8.

class ast.And

class ast.Or

布尔运算符对应的形符。

class ast.Compare(left, ops, comparators)

两个或更多值之间的比较运算。 left 是参加比较的第一个值，ops 是由运算符组成的列表，而 comparators 是由参加比较的第一个元素之后的值组成的列表。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=Compare(
    4.   
  
  
  
  4.  left=Constant(value=1),
    5.   
  
  
  
  5.  ops=[
    6.   
  
  
  
  6.  LtE(),
    7.   
  
  
  
  7.  Lt()],
    8.   
  
  
  
  8.  comparators=[
    9.   
  
  
  
  9.  Name(id='a', ctx=Load()),
    10.   
  
  
  
  10.  Constant(value=10)]))
    11.

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

一个函数调用。 func 是函数，它通常是一个 Name 或 Attribute 对象。 对于其参数:

  • args 保存由按位置传入的参数组成的列表。

  • keywords 保存了一个代表以关键字传入的参数的 keyword 对象的列表。

当创建一个 Call 节点时，需要有 args 和 keywords，但它们可以为空列表。 starargs 和 kwargs 是可选的。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=Call(
    4.   
  
  
  
  4.  func=Name(id='func', ctx=Load()),
    5.   
  
  
  
  5.  args=[
    6.   
  
  
  
  6.  Name(id='a', ctx=Load()),
    7.   
  
  
  
  7.  Starred(
    8.   
  
  
  
  8.  value=Name(id='d', ctx=Load()),
    9.   
  
  
  
  9.  ctx=Load())],
    10.   
  
  
  
  10.  keywords=[
    11.   
  
  
  
  11.  keyword(
    12.   
  
  
  
  12.  arg='b',
    13.   
  
  
  
  13.  value=Name(id='c', ctx=Load())),
    14.   
  
  
  
  14.  keyword(
    15.   
  
  
  
  15.  value=Name(id='e', ctx=Load()))]))
    16.

class ast.keyword(arg, value)

传给函数调用或类定义的关键字参数。 arg 是形参名称对应的原始字符串，value 是要传入的节点。

class ast.IfExp(test, body, orelse)

一个表达式例如 a if b else c。 每个字段保存一个单独节点，因而在下面的示例中，三个节点均为 Name 节点。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=IfExp(
    4.   
  
  
  
  4.  test=Name(id='b', ctx=Load()),
    5.   
  
  
  
  5.  body=Name(id='a', ctx=Load()),
    6.   
  
  
  
  6.  orelse=Name(id='c', ctx=Load())))
    7.

class ast.Attribute(value, attr, ctx)

属性访问，例如 d.keys。 value 是一个节点，通常为 Name。 attr 是一个给出属性名称的纯字符串，而 ctx 根据属性操作的方式可以为 Load, Store 或 Del。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('snake.colour', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=Attribute(
    4.   
  
  
  
  4.  value=Name(id='snake', ctx=Load()),
    5.   
  
  
  
  5.  attr='colour',
    6.   
  
  
  
  6.  ctx=Load()))
    7.

class ast.NamedExpr(target, value)

一个带名称的表达式。 此 AST 节点是由赋值表达式运算符（或称海象运算符）产生的。 与第一个参数可以有多个节点的 Assign 节点不同，在此情况下 target 和 value 都必须为单独节点。

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

抽取

class ast.Subscript(value, slice, ctx)

抽取操作，如 l[1]。 value 是被抽取的对象（通常为序列或映射）。 slice 是索引号、切片或键。 它可以是一个包含 Slice 的 Tuple。 ctx 根据抽取所执行的操作可以为 Load, Store 或 Del。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=Subscript(
    4.   
  
  
  
  4.  value=Name(id='l', ctx=Load()),
    5.   
  
  
  
  5.  slice=Tuple(
    6.   
  
  
  
  6.  elts=[
    7.   
  
  
  
  7.  Slice(
    8.   
  
  
  
  8.  lower=Constant(value=1),
    9.   
  
  
  
  9.  upper=Constant(value=2)),
    10.   
  
  
  
  10.  Constant(value=3)],
    11.   
  
  
  
  11.  ctx=Load()),
    12.   
  
  
  
  12.  ctx=Load()))
    13.

class ast.Slice(lower, upper, step)

常规切片 (形式如 lower:upper 或 lower:upper:step)。 只能在 Subscript 的 slice 字段内部出现，可以是直接切片对象或是作为 Tuple 的元素。

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

推导式

class ast.ListComp(elt, generators)

class ast.SetComp(elt, generators)

class ast.GeneratorExp(elt, generators)

class ast.DictComp(key, value, generators)

列表和集合推导式、生成器表达式以及字典推导式。 elt (或 key 和 value) 是一个代表将针对每个条目被求值的部分的单独节点。

generators 是一个由 comprehension 节点组成的列表。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('[x for x in numbers]', mode='eval'), indent=4))
    2.   
  
  
  
  2. Expression(
    3.   
  
  
  
  3.  body=ListComp(
    4.   
  
  
  
  4.  elt=Name(id='x', ctx=Load()),
    5.   
  
  
  
  5.  generators=[
    6.   
  
  
  
  6.  comprehension(
    7.   
  
  
  
  7.  target=Name(id='x', ctx=Store()),
    8.   
  
  
  
  8.  iter=Name(id='numbers', ctx=Load()),
    9.   
  
  
  
  9.  ifs=[],
    10.   
  
  
  
  10.  is_async=0)]))
    11.   
  
  
  
  11. >>> print(ast.dump(ast.parse('{x: x**2 for x in numbers}', mode='eval'), indent=4))
    12.   
  
  
  
  12. Expression(
    13.   
  
  
  
  13.  body=DictComp(
    14.   
  
  
  
  14.  key=Name(id='x', ctx=Load()),
    15.   
  
  
  
  15.  value=BinOp(
    16.   
  
  
  
  16.  left=Name(id='x', ctx=Load()),
    17.   
  
  
  
  17.  op=Pow(),
    18.   
  
  
  
  18.  right=Constant(value=2)),
    19.   
  
  
  
  19.  generators=[
    20.   
  
  
  
  20.  comprehension(
    21.   
  
  
  
  21.  target=Name(id='x', ctx=Store()),
    22.   
  
  
  
  22.  iter=Name(id='numbers', ctx=Load()),
    23.   
  
  
  
  23.  ifs=[],
    24.   
  
  
  
  24.  is_async=0)]))
    25.   
  
  
  
  25. >>> print(ast.dump(ast.parse('{x for x in numbers}', mode='eval'), indent=4))
    26.   
  
  
  
  26. Expression(
    27.   
  
  
  
  27.  body=SetComp(
    28.   
  
  
  
  28.  elt=Name(id='x', ctx=Load()),
    29.   
  
  
  
  29.  generators=[
    30.   
  
  
  
  30.  comprehension(
    31.   
  
  
  
  31.  target=Name(id='x', ctx=Store()),
    32.   
  
  
  
  32.  iter=Name(id='numbers', ctx=Load()),
    33.   
  
  
  
  33.  ifs=[],
    34.   
  
  
  
  34.  is_async=0)]))
    35.

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

推导式中的一个 for 子句。 target 是针对每个元素使用的引用 —— 通常为一个 Name 或 Tuple 节点。 iter 是要执行迭代的对象。 ifs 是一个由测试表达式组成的列表：每个 for 子句都可以拥有多个 ifs。

is_async 表明推导式是异步的 (使用 async for 而不是 for)。 它的值是一个整数 (0 或 1)。

 
 
 
 
      
  
  
  
  1. >>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),
    2.   
  
  
  
  2. ... indent=4)) # Multiple comprehensions in one.
    3.   
  
  
  
  3. Expression(
    4.   
  
  
  
  4.  body=ListComp(
    5.   
  
  
  
  5.  elt=Call(
    6.   
  
  
  
  6.  func=Name(id='ord', ctx=Load()),
    7.   
  
  
  
  7.  args=[
    8.   
  
  
  
  8.  Name(id='c', ctx=Load())],
    9.   
  
  
  
  9.  keywords=[]),
    10.   
  
  
  
  10.  generators=[
    11.   
  
  
  
  11.  comprehension(
    12.   
  
  
  
  12.  target=Name(id='line', ctx=Store()),
    13.   
  
  
  
  13.  iter=Name(id='file', ctx=Load()),
    14.   
  
  
  
  14.  ifs=[],
    15.   
  
  
  
  15.  is_async=0),
    16.   
  
  
  
  16.  comprehension(
    17.   
  
  
  
  17.  target=Name(id='c', ctx=Store()),
    18.   
  
  
  
  18.  iter=Name(id='line', ctx=Load()),
    19.   
  
  
  
  19.  ifs=[],
    20.   
  
  
  
  20.  is_async=0)]))
    21.   
  
  
  
    22.   
  
  
  
  22. >>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),
    23.   
  
  
  
  23. ... indent=4)) # generator comprehension
    24.   
  
  
  
  24. Expression(
    25.   
  
  
  
  25.  body=GeneratorExp(
    26.   
  
  
  
  26.  elt=BinOp(
    27.   
  
  
  
  27.  left=Name(id='n', ctx=Load()),
    28.   
  
  
  
  28.  op=Pow(),
    29.   
  
  
  
  29.  right=Constant(value=2)),
    30.   
  
  
  
  30.  generators=[
    31.   
  
  
  
  31.  comprehension(
    32.   
  
  
  
  32.  target=Name(id='n', ctx=Store()),
    33.   
  
  
  
  33.  iter=Name(id='it', ctx=Load()),
    34.   
  
  
  
  34.  ifs=[
    35.   
  
  
  
  35.  Compare(
    36.   
  
  
  
  36.  left=Name(id='n', ctx=Load()),
    37.   
  
  
  
  37.  ops=[
    38.   
  
  
  
  38.  Gt()],
    39.   
  
  
  
  39.  comparators=[
    40.   
  
  
  
  40.  Constant(value=5)]),
    41.   
  
  
  
  41.  Compare(
    42.   
  
  
  
  42.  left=Name(id='n', ctx=Load()),
    43.   
  
  
  
  43.  ops=[
    44.   
  
  
  
  44.  Lt
                网站栏目：创新互联Python教程：ast —- 抽象语法树
                
    
                本文路径：http://www.shufengxianlan.com/qtweb/news22/44072.html
            
    
            
    
                网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                创新互联

猜你还喜欢下面的内容

营销型网站建设知识

同城分类信息

微信开发　　 　南充服务器托管　　 　盐亭网站建设　　 　关键词优化　　 　微信小程序开发　　 　高端网站定制　　 　德阳电信服务器托管　　 　成都电信光华数据中心　　 　边坡防护网厂家　　 　企业网站建设　　 　做网站　　 　成都印刷厂　　 　成都网络营销　　 　成都营销型网站建设　　 　网站SEO优化　　 　网络推广公司　　 　网站排名　　 　广汉锦华建材　　 　成都广告公司　　 　成都网站推广