ast --- Cây cú pháp trừu tượng

Source code: Lib/ast.py

---

Mô-đun ast giúp các ứng dụng Python xử lý cây ngữ pháp cú pháp trừu tượng Python. Bản thân cú pháp trừu tượng có thể thay đổi theo từng bản phát hành Python; mô-đun này giúp tìm hiểu theo cách lập trình ngữ pháp hiện tại trông như thế nào.

Có thể tạo cây cú pháp trừu tượng bằng cách chuyển ast.PyCF_ONLY_AST làm cờ cho hàm tích hợp compile() hoặc sử dụng trình trợ giúp parse() được cung cấp trong mô-đun này. Kết quả sẽ là một cây đối tượng mà tất cả các lớp đều kế thừa từ ast.AST. Cây cú pháp trừu tượng có thể được biên dịch thành đối tượng mã Python bằng hàm compile() tích hợp sẵn.

Ngữ pháp trừu tượng

Ngữ pháp trừu tượng hiện được định nghĩa như sau:

-- 4 loại nội dung của ASDL là:
-- định danh, int, chuỗi, hằng

mô-đun Python
{
    mod = Mô-đun(stmt* nội dung, type_ignore* type_ignores)
        | Tương tác(stmt* nội dung)
        | Biểu thức(cơ thể expr)
        | FunctionType(expr* argtypes, expr trả về)

    stmt = FunctionDef(tên định danh, đối số args,
                       nội dung stmt*, expr* trang trí_list, expr? trở lại,
                       chuỗi? type_comment, type_param* type_params)
          | AsyncFunctionDef(tên định danh, đối số,
                             nội dung stmt*, expr* trang trí_list, expr? trở lại,
                             chuỗi? type_comment, type_param* type_params)

          | ClassDef(tên định danh,
             cơ sở expr*,
             từ khóa* từ khóa,
             cơ thể stmt*,
             expr* trang trí_list,
             type_param* type_params)
          | Trả về(giá trị expr?)

          | Xóa(mục tiêu expr*)
          | Gán(mục tiêu expr*, giá trị expr, chuỗi? type_comment)
          | TypeAlias(tên expr, type_param* type_params, giá trị expr)
          | AugAssign(mục tiêu expr, toán tử op, giá trị expr)
          -- 'đơn giản' biểu thị rằng chúng ta chú thích tên đơn giản không có dấu ngoặc đơn
          | AnnAssign(mục tiêu expr, chú thích expr, giá trị expr?, int đơn giản)

          -- sử dụng 'orelse' vì else là từ khóa trong ngôn ngữ đích
          | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)
          | AsyncFor(mục tiêu expr, expr iter, thân stmt*, stmt* orelse, chuỗi? 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(các trường hợp chủ đề expr, match_case*)

          | Tăng(expr? exc, expr? nguyên nhân)
          | Try(stmt* body, các trình xử lý ngoại trừ*, stmt* orelse, stmt* Finalbody)
          | TryStar(stmt* body, các trình xử lý ngoại trừ*, stmt* orelse, stmt* Finalbody)
          | Khẳng định(expr test, expr? msg)

          | Nhập (bí danh* tên)
          | ImportFrom(mã định danh? mô-đun, tên bí danh*, cấp độ int?)

          | Toàn cầu(tên định danh*)
          | Không cục bộ(tên định danh*)
          | Expr(giá trị expr)
          | Pass | Nghỉ | Tiếp tục

          -- col_offset là byte offset trong chuỗi utf8 mà trình phân tích cú pháp sử dụng
          thuộc tính (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

          -- BoolOp() có thể sử dụng trái & phải không?
    expr = BoolOp(giá trị boolop op, expr*)
         | NamedExpr(mục tiêu expr, giá trị expr)
         | BinOp(expr trái, toán tử op, expr phải)
         | UnaryOp(unaryop op, expr toán hạng)
         | Lambda(đối số args, expr body)
         | IfExp(expr test, expr body, expr orelse)
         | Dict(khóa expr?*, giá trị expr*)
         | Đặt(expr* els)
         | ListComp(expr elt, Comphiểu* máy phát điện)
         | SetComp(trình tạo expr elt, hiểu*)
         | DictComp(khóa expr, giá trị expr, trình tạo mức độ hiểu*)
         | GeneratorExp(expr elt, hiểu* máy phát điện)
         -- các ràng buộc ngữ pháp nơi biểu thức lợi nhuận có thể xuất hiện
         | Đang chờ(giá trị expr)
         | Năng suất(giá trị expr?)
         | YieldFrom(giá trị expr)
         -- cần trình tự so sánh để phân biệt giữa
         -- x < 4 < 3 và (x < 4) < 3
         | So sánh(bộ so sánh expr left, cmpop* ops, expr*)
         | Gọi(expr func, expr* args, từ khóa* từ khóa)
         | FormattedValue(giá trị expr, chuyển đổi int, expr? format_spec)
         | Nội suy(giá trị expr, hằng số str, chuyển đổi int, expr? format_spec)
         | JoinedStr(giá trị expr*)
         | Bản mẫuStr(giá trị expr*)
         | Hằng(giá trị không đổi, chuỗi? loại)

         -- biểu thức sau có thể xuất hiện trong ngữ cảnh bài tập
         | Thuộc tính(giá trị expr, mã định danh attr, expr_context ctx)
         | Chỉ số dưới(giá trị expr, lát expr, expr_context ctx)
         | Được gắn dấu sao(giá trị expr, expr_context ctx)
         | Tên(id định danh, expr_context ctx)
         | Danh sách(expr* elts, expr_context ctx)
         | Bộ dữ liệu(expr* elts, expr_context ctx)

         -- chỉ có thể xuất hiện trong Chỉ mục
         | Slice(expr? dưới, expr? trên, expr? bước)

          -- col_offset là byte offset trong chuỗi utf8 mà trình phân tích cú pháp sử dụng
          thuộc tính (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    expr_context=Tải | Store | Del

    boolop = Và | Hoặc

    toán tử = Thêm | Sub | Mult | MatMult | Div | Mod | Pow | LShift
                 | RShift | BitOr | BitXor | BitAnd | TầngDiv

    unaryop = Đảo ngược | Not | UAdd | USub

    cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Là | IsNot | Trong | Không có trong

    hiểu = (mục tiêu expr, expr iter, expr* ifs, int is_async)

    ngoại trừ=ExceptionHandler(expr? type, định danh? tên, stmt* nội dung)
                    thuộc tính (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    đối số = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,
                 expr?* kw_defaults, arg? kwarg, expr* mặc định)

    arg = (định danh arg, expr? chú thích, chuỗi? type_comment)
           thuộc tính (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    -- đối số từ khóa được cung cấp để gọi (mã định danh NULL cho **kwargs)
    từ khóa = (định danh? arg, giá trị expr)
               thuộc tính (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    -- nhập tên với bí danh 'as' tùy chọn.
    bí danh = (tên định danh, định danh? asname)
             thuộc tính (int lineno, int col_offset, int? end_lineno, int? end_col_offset)

    withitem = (expr bối cảnh_expr, expr? tùy chọn_vars)

    match_case = (mẫu mẫu, expr? Guard, stmt* nội dung)

    mẫu = MatchValue(giá trị expr)
            | MatchSingleton(giá trị không đổi)
            | MatchSequence(mẫu* mẫu)
            | MatchMapping(khóa expr*, mẫu*, mã định danh? phần còn lại)
            | MatchClass(expr cls, mẫu* mẫu, mã định danh* kwd_attrs, mẫu* kwd_patterns)

            | MatchStar(định danh? tên)
            -- Tham số MatchMapping "còn lại" tùy chọn xử lý việc ghi lại các khóa ánh xạ bổ sung

            | MatchAs(mẫu? mẫu, mã định danh? tên)
            | MatchOr(mẫu* mẫu)

             thuộc tính (int lineno, int col_offset, int end_lineno, int end_col_offset)

    type_ignore=TypeIgnore(int lineno, thẻ chuỗi)

    type_param = TypeVar(tên định danh, expr? giới hạn, expr? default_value)
               | ParamSpec(tên định danh, expr? default_value)
               | TypeVarTuple(tên định danh, expr? default_value)
               thuộc tính (int lineno, int col_offset, int end_lineno, int end_col_offset)
}

Các lớp nút

class ast.AST

Đây là cơ sở của tất cả các lớp nút AST. Các lớp nút thực tế được lấy từ tệp Parser/Python.asdl, được sao chép above. Chúng được xác định trong mô-đun _ast C và được xuất lại trong ast.

Có một lớp được xác định cho mỗi ký hiệu bên trái trong ngữ pháp trừu tượng (ví dụ: ast.stmt hoặc ast.expr). Ngoài ra, có một lớp được định nghĩa cho mỗi hàm tạo ở phía bên phải; các lớp này kế thừa từ các lớp dành cho cây bên trái. Ví dụ: ast.BinOp kế thừa từ ast.expr. Đối với các quy tắc sản xuất có các lựa chọn thay thế (còn gọi là "tổng"), lớp bên trái là trừu tượng: chỉ các phiên bản của nút hàm tạo cụ thể mới được tạo.

_fields

Mỗi lớp cụ thể có một thuộc tính _fields cung cấp tên của tất cả các nút con.

Mỗi phiên bản của một lớp cụ thể có một thuộc tính cho mỗi nút con, thuộc loại như được định nghĩa trong ngữ pháp. Ví dụ: các phiên bản ast.BinOp có thuộc tính left thuộc loại ast.expr.

Nếu các thuộc tính này được đánh dấu là tùy chọn trong ngữ pháp (sử dụng dấu chấm hỏi), giá trị có thể là None. Nếu các thuộc tính có thể có nhiều giá trị 0 hoặc nhiều hơn (được đánh dấu bằng dấu hoa thị), thì các giá trị đó sẽ được biểu thị dưới dạng danh sách Python. Tất cả các thuộc tính có thể có phải có mặt và có giá trị hợp lệ khi biên dịch AST với compile().

_field_types

Thuộc tính _field_types trên mỗi lớp cụ thể là tên trường ánh xạ từ điển (cũng được liệt kê trong _fields) theo loại của chúng.

>>> ast.TypeVar._field_types
{'name': <class 'str'>, 'bound': ast.expr | None, 'default_value': ast.expr | Không có}

Added in version 3.13.

lineno

col_offset

end_lineno

end_col_offset

Các phiên bản của lớp con ast.expr và ast.stmt có các thuộc tính lineno, col_offset, end_lineno và end_col_offset. lineno và end_lineno là số dòng đầu tiên và cuối cùng của khoảng văn bản nguồn (được lập chỉ mục 1 nên dòng đầu tiên là dòng 1) và col_offset và end_col_offset là độ lệch byte UTF-8 tương ứng của mã thông báo đầu tiên và cuối cùng đã tạo ra nút. Phần bù UTF-8 được ghi lại do trình phân tích cú pháp sử dụng UTF-8 bên trong.

Lưu ý rằng trình biên dịch không yêu cầu các vị trí cuối và do đó là tùy chọn. Phần bù cuối là after ký hiệu cuối cùng, ví dụ: người ta có thể lấy đoạn nguồn của nút biểu thức một dòng bằng cách sử dụng source_line[node.col_offset : node.end_col_offset].

Hàm tạo của lớp ast.T phân tích các đối số của nó như sau:

• Nếu có các đối số vị trí thì phải có nhiều mục trong T._fields; chúng sẽ được chỉ định làm thuộc tính của những tên này.

• Nếu có đối số từ khóa, chúng sẽ đặt các thuộc tính có cùng tên thành các giá trị nhất định.

Ví dụ: để tạo và điền vào nút ast.UnaryOp, bạn có thể sử dụng

nút = ast.UnaryOp(ast.USu(), ast.Constant(5, lineno=0, col_offset=0),
                   lineno=0, col_offset=0)

Nếu một trường tùy chọn trong ngữ pháp bị bỏ qua khỏi hàm tạo thì nó sẽ mặc định là None. Nếu một trường danh sách bị bỏ qua, nó sẽ mặc định là danh sách trống. Nếu trường loại ast.expr_context bị bỏ qua, nó sẽ mặc định là Load(). Nếu bất kỳ trường nào khác bị bỏ qua, DeprecationWarning sẽ được nâng lên và nút AST sẽ không có trường này. Trong Python 3.15, tình trạng này sẽ gây ra lỗi.

Thay đổi trong phiên bản 3.8: Lớp ast.Constant hiện được sử dụng cho tất cả các hằng số.

Thay đổi trong phiên bản 3.9: Các chỉ số đơn giản được biểu diễn bằng giá trị của chúng, các lát mở rộng được biểu diễn dưới dạng bộ dữ liệu.

Thay đổi trong phiên bản 3.13: Các hàm tạo nút AST đã được thay đổi để cung cấp các giá trị mặc định hợp lý cho các trường bị bỏ qua: các trường tùy chọn hiện được mặc định là None, các trường danh sách mặc định là danh sách trống và các trường thuộc loại ast.expr_context mặc định là Load(). Trước đây, các thuộc tính bị bỏ qua sẽ không tồn tại trên các nút được xây dựng (truy cập chúng bằng AttributeError).

Thay đổi trong phiên bản 3.14: Đầu ra __repr__() của các nút AST bao gồm các giá trị của các trường nút.

Không được dùng nữa kể từ phiên bản 3.8, đã bị xóa trong phiên bản 3.14: Các phiên bản trước của Python đã cung cấp các lớp AST ast.Num, ast.Str, ast.Bytes, ast.NameConstant và ast.Ellipsis, những lớp này không được dùng nữa trong Python 3.8. Các lớp này đã bị xóa trong Python 3.14 và chức năng của chúng đã được thay thế bằng ast.Constant.

Sắp loại bỏ từ phiên bản 3.9: Các lớp cũ ast.Index và ast.ExtSlice vẫn có sẵn nhưng chúng sẽ bị xóa trong các bản phát hành Python trong tương lai. Trong khi chờ đợi, việc khởi tạo chúng sẽ trả về một thể hiện của một lớp khác.

Không được dùng nữa kể từ phiên bản 3.13, sẽ bị xóa trong phiên bản 3.15: Các phiên bản trước của Python cho phép tạo các nút AST thiếu các trường bắt buộc. Tương tự, các hàm tạo nút AST cho phép các đối số từ khóa tùy ý được đặt làm thuộc tính của nút AST, ngay cả khi chúng không khớp với bất kỳ trường nào của nút AST. Hành vi này không được dùng nữa và sẽ bị xóa trong Python 3.15.

Ghi chú

Mô tả về các lớp nút cụ thể được hiển thị ở đây ban đầu được điều chỉnh từ dự án Green Tree Snakes tuyệt vời và tất cả những người đóng góp cho dự án đó.

Nút gốc

class ast.Module(body, type_ignores)

Một mô-đun Python, như với file input. Loại nút được tạo bởi ast.parse() trong "exec" mode mặc định.

body là list của Báo cáo của mô-đun.

type_ignores là một list thuộc loại mô-đun bỏ qua nhận xét; xem ast.parse() để biết thêm chi tiết.

>>> print(ast.dump(ast.parse('x = 1'), thụt lề=4))
mô-đun(
    cơ thể=[
        Chỉ định(
            mục tiêu=[
                Tên(id='x', ctx=Store())],
            value=Hằng số(giá trị=1))])

class ast.Expression(body)

Một expression input Python duy nhất. Loại nút được tạo bởi ast.parse() khi mode là "eval".

body là một nút duy nhất, một trong expression types.

>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))
Biểu thức(
    body=Hằng số(giá trị=123))

class ast.Interactive(body)

Một interactive input duy nhất, giống như trong Chế độ tương tác. Loại nút được tạo bởi ast.parse() khi mode là "single".

body là list của statement nodes.

>>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), thụt lề=4))
Tương tác(
    cơ thể=[
        Chỉ định(
            mục tiêu=[
                Tên(id='x', ctx=Store())],
            giá trị=Hằng số(giá trị=1)),
        Chỉ định(
            mục tiêu=[
                Tên(id='y', ctx=Store())],
            value=Hằng số(giá trị=2))])

class ast.FunctionType(argtypes, returns)

Sự thể hiện kiểu nhận xét kiểu cũ cho các hàm, vì các phiên bản Python trước 3.5 không hỗ trợ chú thích PEP 484. Loại nút được tạo bởi ast.parse() khi mode là "func_type".

Những nhận xét kiểu như vậy sẽ trông như thế này:

def sum_two_number(a, b):
    # type: (int, int) -> int
    trả về a + b

argtypes là list của expression nodes.

returns là một expression node duy nhất.

>>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))
Loại hàm(
    argtypes=[
        Tên(id='int', ctx=Load()),
        Tên(id='str', ctx=Load())],
    trả về=Chỉ số dưới(
        value=Name(id='List', ctx=Load()),
        slice=Name(id='int', ctx=Load()),
        ctx=Tải()))

Added in version 3.8.

chữ

class ast.Constant(value)

Một giá trị không đổi. Thuộc tính value của chữ Constant chứa đối tượng Python mà nó đại diện. Các giá trị được biểu thị có thể là các thể hiện của str, bytes, int, float, complex và bool, cũng như các hằng số None và Ellipsis.

>>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))
Biểu thức(
    body=Hằng số(giá trị=123))

class ast.FormattedValue(value, conversion, format_spec)

Nút đại diện cho một trường định dạng trong chuỗi f. Nếu chuỗi chứa một trường định dạng duy nhất và không có gì khác thì nút đó có thể bị cô lập nếu không nó sẽ xuất hiện trong JoinedStr.

• value là bất kỳ nút biểu thức nào (chẳng hạn như một chữ, một biến hoặc một lệnh gọi hàm).

• conversion là một số nguyên:

  • -1: không có định dạng

  • 97 (ord('a')): định dạng !a ASCII

  • 114 (ord('r')): định dạng !r repr()

  • 115 (ord('s')): định dạng !s string

• format_spec là nút JoinedStr biểu thị định dạng của giá trị hoặc None nếu không có định dạng nào được chỉ định. Cả conversion và format_spec đều có thể được đặt cùng một lúc.

class ast.JoinedStr(values)

Một chuỗi f, bao gồm một loạt các nút FormattedValue và Constant.

>>> print(ast.dump(ast.parse('f"sin({a}) là {sin(a):.3}"', mode='eval'), thụt lề=4))
Biểu thức(
    body=JoinedStr(
        giá trị=[
            Hằng số(giá trị='sin('),
            Giá trị được định dạng(
                value=Name(id='a', ctx=Load()),
                chuyển đổi=-1),
            Hằng số(giá trị=') là '),
            Giá trị được định dạng(
                value=Gọi(
                    func=Name(id='sin', ctx=Load()),
                    args=[
                        Tên(id='a', ctx=Load())]),
                chuyển đổi=-1,
                format_spec=Đã tham gia(
                    giá trị=[
                        Hằng số(giá trị='.3')]))]))

class ast.TemplateStr(values, /)

Added in version 3.14.

Nút đại diện cho một chuỗi ký tự mẫu, bao gồm một loạt các nút Interpolation và Constant. Các nút này có thể theo thứ tự bất kỳ và không cần phải xen kẽ.

>>> expr = ast.parse('t"{name} đã hoàn thành {place:thứ tự}"', mode='eval')
>>> print(ast.dump(expr, indent=4))
Biểu thức(
    body=TemplateStr(
        giá trị=[
            Nội suy(
                value=Name(id='name', ctx=Load()),
                str='tên',
                chuyển đổi=-1),
            Hằng số(giá trị=' đã hoàn thành '),
            Nội suy(
                value=Name(id='place', ctx=Load()),
                str='địa điểm',
                chuyển đổi=-1,
                format_spec=Đã tham gia(
                    giá trị=[
                        Hằng số(giá trị='thứ tự')]))]))

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

Added in version 3.14.

Nút đại diện cho một trường nội suy duy nhất trong một chuỗi ký tự mẫu.

• value là bất kỳ nút biểu thức nào (chẳng hạn như một chữ, một biến hoặc một lệnh gọi hàm). Điều này có ý nghĩa tương tự như FormattedValue.value.

• str là hằng số chứa văn bản của biểu thức nội suy.

  Nếu str được đặt thành None thì value được sử dụng để tạo mã khi gọi ast.unparse(). Điều này không còn đảm bảo rằng mã được tạo giống hệt với mã gốc và được dùng để tạo mã.

• conversion là một số nguyên:

  • -1: không chuyển đổi

  • 97 (ord('a')): chuyển đổi !a ASCII

  • 114 (ord('r')): chuyển đổi !r repr()

  • 115 (ord('s')): chuyển đổi !s string

  Điều này có ý nghĩa tương tự như FormattedValue.conversion.

• format_spec là nút JoinedStr biểu thị định dạng của giá trị hoặc None nếu không có định dạng nào được chỉ định. Cả conversion và format_spec đều có thể được đặt cùng một lúc. Điều này có ý nghĩa tương tự như FormattedValue.format_spec.

class ast.List(elts, ctx)

class ast.Tuple(elts, ctx)

Một danh sách hoặc bộ dữ liệu. elts chứa danh sách các nút đại diện cho các phần tử. ctx là Store nếu vùng chứa là mục tiêu được chỉ định (tức là (x,y)=something) và Load nếu ngược lại.

>>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))
Biểu thức(
    nội dung=Danh sách(
        elts=[
            Hằng số(giá trị=1),
            Hằng số(giá trị=2),
            Hằng số(giá trị=3)],
        ctx=Tải()))
>>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), thụt lề=4))
Biểu thức(
    phần thân=Tuple(
        elts=[
            Hằng số(giá trị=1),
            Hằng số(giá trị=2),
            Hằng số(giá trị=3)],
        ctx=Tải()))

class ast.Set(elts)

Một bộ. elts chứa danh sách các nút đại diện cho các phần tử của tập hợp.

>>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))
Biểu thức(
    body=Set(
        elts=[
            Hằng số(giá trị=1),
            Hằng số(giá trị=2),
            Hằng số(giá trị=3)]))

class ast.Dict(keys, values)

Một cuốn từ điển. keys và values giữ danh sách các nút đại diện cho khóa và giá trị tương ứng, theo thứ tự khớp (điều gì sẽ được trả về khi gọi dictionary.keys() và dictionary.values()).

Khi thực hiện giải nén từ điển bằng cách sử dụng các ký tự từ điển, biểu thức cần mở rộng sẽ nằm trong danh sách values, với None ở vị trí tương ứng trong keys.

>>> print(ast.dump(ast.parse('{"a":1, **d}', mode='eval'), indent=4))
Biểu thức(
    cơ thể=Dict(
        phím=[
            Hằng số(giá trị='a'),
            không có],
        giá trị=[
            Hằng số(giá trị=1),
            Tên(id='d', ctx=Load())]))

Biến

class ast.Name(id, ctx)

Một tên biến. id giữ tên dưới dạng chuỗi và ctx là một trong các loại sau.

class ast.Load

class ast.Store

class ast.Del

Tham chiếu biến có thể được sử dụng để tải giá trị của một biến, gán một giá trị mới cho nó hoặc để xóa nó. Các tham chiếu biến được cung cấp một bối cảnh để phân biệt các trường hợp này.

>>> print(ast.dump(ast.parse('a'), indent=4))
mô-đun(
    cơ thể=[
        Expr(
            value=Name(id='a', ctx=Load()))])

>>> print(ast.dump(ast.parse('a = 1'), indent=4))
mô-đun(
    cơ thể=[
        Chỉ định(
            mục tiêu=[
                Tên(id='a', ctx=Store())],
            value=Hằng số(giá trị=1))])

>>> print(ast.dump(ast.parse('del a'), indent=4))
mô-đun(
    cơ thể=[
        Xóa(
            mục tiêu=[
                Tên(id='a', ctx=Del())])])

class ast.Starred(value, ctx)

Một tham chiếu biến *var. value giữ biến, thường là nút Name. Loại này phải được sử dụng khi xây dựng nút Call với *args.

>>> print(ast.dump(ast.parse('a, *b = it'), indent=4))
mô-đun(
    cơ thể=[
        Chỉ định(
            mục tiêu=[
                Bộ dữ liệu(
                    elts=[
                        Tên(id='a', ctx=Store()),
                        Được gắn dấu sao(
                            value=Name(id='b', ctx=Store()),
                            ctx=Cửa hàng())],
                    ctx=Cửa hàng())],
            value=Name(id='it', ctx=Load()))])

Biểu thức

class ast.Expr(value)

Khi một biểu thức, chẳng hạn như một lệnh gọi hàm, xuất hiện dưới dạng một câu lệnh với giá trị trả về không được sử dụng hoặc lưu trữ, nó sẽ được gói trong vùng chứa này. value giữ một trong các nút khác trong phần này, nút Constant, Name, Lambda, Yield hoặc YieldFrom.

>>> print(ast.dump(ast.parse('-a'), indent=4))
mô-đun(
    cơ thể=[
        Expr(
            value=UnaryOp(
                op=USu(),
                toán hạng=Tên(id='a', ctx=Load())))])

class ast.UnaryOp(op, operand)

Một hoạt động đơn nhất. op là toán tử và operand là bất kỳ nút biểu thức nào.

class ast.UAdd

class ast.USub

class ast.Not

class ast.Invert

Mã thông báo toán tử đơn nhất. Not là từ khóa not, Invert là toán tử ~.

>>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))
Biểu thức(
    body=UnaryOp(
        op=Không(),
        toán hạng=Tên(id='x', ctx=Load())))

class ast.BinOp(left, op, right)

Một phép toán nhị phân (như cộng hoặc chia). op là toán tử, left và right là bất kỳ nút biểu thức nào.

>>> print(ast.dump(ast.parse('x + y', mode='eval'), thụt lề=4))
Biểu thức(
    cơ thể=BinOp(
        left=Name(id='x', ctx=Load()),
        op=Thêm(),
        right=Name(id='y', ctx=Load())))

class ast.Add

class ast.Sub

class ast.Mult

class ast.Div

class ast.FloorDiv

class ast.Mod

class ast.Pow

class ast.LShift

class ast.RShift

class ast.BitOr

class ast.BitXor

class ast.BitAnd

class ast.MatMult

Mã thông báo toán tử nhị phân.

class ast.BoolOp(op, values)

Một phép toán boolean, 'hoặc' hoặc 'và'. op là Or hoặc And. values là các giá trị liên quan. Các hoạt động liên tiếp với cùng một toán tử, chẳng hạn như a or b or c, được thu gọn thành một nút có nhiều giá trị.

Điều này không bao gồm not, tức là UnaryOp.

>>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))
Biểu thức(
    cơ thể=BoolOp(
        op=Hoặc(),
        giá trị=[
            Tên(id='x', ctx=Load()),
            Tên(id='y', ctx=Load())]))

class ast.And

class ast.Or

Mã thông báo toán tử Boolean.

class ast.Compare(left, ops, comparators)

Sự so sánh của hai hoặc nhiều giá trị. left là giá trị đầu tiên trong phép so sánh, ops là danh sách các toán tử và comparators là danh sách các giá trị sau phần tử đầu tiên trong phép so sánh.

>>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), thụt lề=4))
Biểu thức(
    thân=So sánh(
        left=Hằng số(giá trị=1),
        ops=[
            LtE(),
            Lt()],
        bộ so sánh=[
            Tên(id='a', ctx=Load()),
            Hằng số(giá trị=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

Mã thông báo toán tử so sánh.

class ast.Call(func, args, keywords)

Một cuộc gọi chức năng. func là hàm, thường sẽ là đối tượng Name hoặc Attribute. Trong số các đối số:

• args chứa danh sách các đối số được truyền theo vị trí.

• keywords chứa danh sách các đối tượng keyword đại diện cho các đối số được truyền theo từ khóa.

Các đối số args và keywords là tùy chọn và mặc định là danh sách trống.

>>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), thụt lề=4))
Biểu thức(
    body=Gọi(
        func=Name(id='func', ctx=Load()),
        args=[
            Tên(id='a', ctx=Load()),
            Được gắn dấu sao(
                value=Name(id='d', ctx=Load()),
                ctx=Tải())],
        từ khóa=[
            từ khóa(
                arg='b',
                value=Name(id='c', ctx=Load())),
            từ khóa(
                value=Name(id='e', ctx=Load()))]))

class ast.keyword(arg, value)

Đối số từ khóa cho lệnh gọi hàm hoặc định nghĩa lớp. arg là một chuỗi thô của tên tham số, value là một nút để truyền vào.

class ast.IfExp(test, body, orelse)

Một biểu thức như a if b else c. Mỗi trường chứa một nút duy nhất, vì vậy trong ví dụ sau, cả ba đều là nút Name.

>>> print(ast.dump(ast.parse('a if b else c', mode='eval'), indent=4))
Biểu thức(
    cơ thể=IfExp(
        test=Name(id='b', ctx=Load()),
        body=Name(id='a', ctx=Load()),
        orelse=Name(id='c', ctx=Load())))

class ast.Attribute(value, attr, ctx)

Quyền truy cập thuộc tính, ví dụ: d.keys. value là một nút, thường là Name. attr là một chuỗi trần cung cấp tên của thuộc tính và ctx là Load, Store hoặc Del tùy theo cách hành động của thuộc tính.

>>> print(ast.dump(ast.parse('snake.colour', mode='eval'), thụt lề=4))
Biểu thức(
    body=Thuộc tính(
        value=Name(id='snake', ctx=Load()),
        attr='màu',
        ctx=Tải()))

class ast.NamedExpr(target, value)

Một biểu thức được đặt tên. Nút AST này được tạo bởi toán tử biểu thức gán (còn được gọi là toán tử hải mã). Ngược lại với nút Assign trong đó đối số đầu tiên có thể là nhiều nút, trong trường hợp này cả target và value đều phải là các nút đơn.

>>> print(ast.dump(ast.parse('(x := 4)', mode='eval'), indent=4))
Biểu thức(
    body=NamedExpr(
        target=Name(id='x', ctx=Store()),
        value=Hằng số(giá trị=4)))

Added in version 3.8.

Đăng ký

class ast.Subscript(value, slice, ctx)

Chỉ số dưới, chẳng hạn như l[1]. value là đối tượng được đăng ký (thường là trình tự hoặc ánh xạ). slice là một chỉ mục, lát cắt hoặc khóa. Nó có thể là Tuple và chứa Slice. ctx là Load, Store hoặc Del tùy theo hành động được thực hiện với chỉ số dưới.

>>> print(ast.dump(ast.parse('l[1:2, 3]', mode='eval'), indent=4))
Biểu thức(
    body=Chỉ số dưới(
        value=Name(id='l', ctx=Load()),
        lát=Tuple(
            elts=[
                Lát(
                    thấp hơn=Không đổi(giá trị=1),
                    trên=Hằng số(giá trị=2)),
                Hằng số(giá trị=3)],
            ctx=Tải()),
        ctx=Tải()))

class ast.Slice(lower, upper, step)

Cắt lát thông thường (theo mẫu lower:upper hoặc lower:upper:step). Chỉ có thể xảy ra bên trong trường slice của Subscript, trực tiếp hoặc dưới dạng một phần tử của Tuple.

>>> print(ast.dump(ast.parse('l[1:2]', mode='eval'), thụt lề=4))
Biểu thức(
    body=Chỉ số dưới(
        value=Name(id='l', ctx=Load()),
        lát=Lát(
            thấp hơn=Không đổi(giá trị=1),
            trên=Hằng số(giá trị=2)),
        ctx=Tải()))

Hiểu biết

class ast.ListComp(elt, generators)

class ast.SetComp(elt, generators)

class ast.GeneratorExp(elt, generators)

class ast.DictComp(key, value, generators)

Liệt kê và thiết lập các cách hiểu, biểu thức tạo và hiểu từ điển. elt (hoặc key và value) là một nút duy nhất đại diện cho phần sẽ được đánh giá cho từng mục.

generators là danh sách các nút comprehension.

>>> print(ast.dump(
... ast.parse('[x for x in number]', mode='eval'),
... thụt lề=4,
... ))
Biểu thức(
    body=ListComp(
        elt=Name(id='x', ctx=Load()),
        máy phát điện=[
            sự hiểu biết(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers', ctx=Load()),
                is_async=0)]))
>>> print(ast.dump(
... ast.parse('{x: x**2 for x in number}', mode='eval'),
... thụt lề=4,
... ))
Biểu thức(
    body=DictComp(
        key=Name(id='x', ctx=Load()),
        giá trị=BinOp(
            left=Name(id='x', ctx=Load()),
            op=Pow(),
            right=Hằng số(giá trị=2)),
        máy phát điện=[
            sự hiểu biết(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers', ctx=Load()),
                is_async=0)]))
>>> print(ast.dump(
... ast.parse('{x for x in number}', mode='eval'),
... thụt lề=4,
... ))
Biểu thức(
    body=SetComp(
        elt=Name(id='x', ctx=Load()),
        máy phát điện=[
            sự hiểu biết(
                target=Name(id='x', ctx=Store()),
                iter=Name(id='numbers', ctx=Load()),
                is_async=0)]))

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

Một mệnh đề for được hiểu một cách dễ hiểu. target là tham chiếu để sử dụng cho từng phần tử - thường là nút Name hoặc Tuple. iter là đối tượng để lặp lại. ifs là danh sách các biểu thức kiểm tra: mỗi mệnh đề for có thể có nhiều ifs.

is_async cho biết khả năng hiểu không đồng bộ (sử dụng async for thay vì for). Giá trị là một số nguyên (0 hoặc 1).

>>> print(ast.dump(ast.parse('[ord(c) for line in file for c in line]', mode='eval'),
... thụt lề=4)) # Multiple hiểu trong một.
Biểu thức(
    body=ListComp(
        elt=Gọi(
            func=Name(id='ord', ctx=Load()),
            args=[
                Tên(id='c', ctx=Load())]),
        máy phát điện=[
            sự hiểu biết(
                target=Name(id='line', ctx=Store()),
                iter=Name(id='file', ctx=Load()),
                is_async=0),
            sự hiểu biết(
                target=Name(id='c', ctx=Store()),
                iter=Name(id='line', ctx=Load()),
                is_async=0)]))

>>> print(ast.dump(ast.parse('(n**2 for n in it if n>5 if n<10)', mode='eval'),
... thụt lề=4)) # generator hiểu
Biểu thức(
    body=GeneratorExp(
        elt=BinOp(
            left=Name(id='n', ctx=Load()),
            op=Pow(),
            right=Hằng số(giá trị=2)),
        máy phát điện=[
            sự hiểu biết(
                target=Name(id='n', ctx=Store()),
                iter=Name(id='it', ctx=Load()),
                nếu = [
                    So sánh(
                        left=Name(id='n', ctx=Load()),
                        ops=[
                            Gt()],
                        bộ so sánh=[
                            Hằng số(giá trị=5)]),
                    So sánh(
                        left=Name(id='n', ctx=Load()),
                        ops=[
                            Lt()],
                        bộ so sánh=[
                            Hằng số(giá trị=10)])],
                is_async=0)]))

>>> print(ast.dump(ast.parse('[i async for i in soc]', mode='eval'),
... thụt lề=4)) # Async hiểu
Biểu thức(
    body=ListComp(
        elt=Name(id='i', ctx=Load()),
        máy phát điện=[
            sự hiểu biết(
                target=Name(id='i', ctx=Store()),
                iter=Name(id='soc', ctx=Load()),
                is_async=1)]))

Báo cáo

class ast.Assign(targets, value, type_comment)

Một nhiệm vụ. targets là danh sách các nút và value là một nút duy nhất.

Nhiều nút trong targets thể hiện việc gán cùng một giá trị cho mỗi nút. Việc giải nén được thể hiện bằng cách đặt Tuple hoặc List trong targets.

type_comment

type_comment là một chuỗi tùy chọn có chú thích loại dưới dạng nhận xét.

>>> print(ast.dump(ast.parse('a = b = 1'), indent=4)) phép gán # Multiple
mô-đun(
    cơ thể=[
        Chỉ định(
            mục tiêu=[
                Tên(id='a', ctx=Store()),
                Tên(id='b', ctx=Store())],
            value=Hằng số(giá trị=1))])

>>> print(ast.dump(ast.parse('a,b = c'), indent=4)) # Unpacking
mô-đun(
    cơ thể=[
        Chỉ định(
            mục tiêu=[
                Bộ dữ liệu(
                    elts=[
                        Tên(id='a', ctx=Store()),
                        Tên(id='b', ctx=Store())],
                    ctx=Cửa hàng())],
            value=Name(id='c', ctx=Load()))])

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

Một bài tập có chú thích kiểu. target là một nút duy nhất và có thể là Name, Attribute hoặc Subscript. annotation là chú thích, chẳng hạn như nút Constant hoặc Name. value là một nút tùy chọn duy nhất.

simple luôn là 0 (biểu thị mục tiêu "phức tạp") hoặc 1 (biểu thị mục tiêu "đơn giản"). Mục tiêu "đơn giản" chỉ bao gồm nút Name không xuất hiện giữa các dấu ngoặc đơn; tất cả các mục tiêu khác được coi là phức tạp. Chỉ các mục tiêu đơn giản mới xuất hiện trong từ điển mô-đun và lớp __annotations__.

>>> print(ast.dump(ast.parse('c: int'), indent=4))
mô-đun(
    cơ thể=[
        AnnAssign(
            target=Name(id='c', ctx=Store()),
            chú thích=Tên(id='int', ctx=Load()),
            đơn giản=1)])

>>> print(ast.dump(ast.parse('(a): int = 1'), indent=4)) # Annotation với dấu ngoặc đơn
mô-đun(
    cơ thể=[
        AnnAssign(
            target=Name(id='a', ctx=Store()),
            chú thích=Tên(id='int', ctx=Load()),
            giá trị=Hằng số(giá trị=1),
            đơn giản=0)])

>>> print(ast.dump(ast.parse('a.b: int'), indent=4)) chú thích # Attribute
mô-đun(
    cơ thể=[
        AnnAssign(
            target=Thuộc tính(
                value=Name(id='a', ctx=Load()),
                attr='b',
                ctx=Cửa hàng()),
            chú thích=Tên(id='int', ctx=Load()),
            đơn giản=0)])

>>> print(ast.dump(ast.parse('a[1]: int'), indent=4)) chú thích # Subscript
mô-đun(
    cơ thể=[
        AnnAssign(
            mục tiêu=Chỉ số dưới(
                value=Name(id='a', ctx=Load()),
                lát=Hằng số(giá trị=1),
                ctx=Cửa hàng()),
            chú thích=Tên(id='int', ctx=Load()),
            đơn giản=0)])

class ast.AugAssign(target, op, value)

Bài tập mở rộng, chẳng hạn như a += 1. Trong ví dụ sau, target là nút Name cho x (với ngữ cảnh Store), op là Add và value là Constant có giá trị là 1.

Thuộc tính target không thể thuộc lớp Tuple hoặc List, không giống như các mục tiêu của Assign.

>>> print(ast.dump(ast.parse('x += 2'), indent=4))
mô-đun(
    cơ thể=[
        AugAssign(
            target=Name(id='x', ctx=Store()),
            op=Thêm(),
            value=Hằng số(giá trị=2))])

class ast.Raise(exc, cause)

Một tuyên bố raise. exc là đối tượng ngoại lệ được nâng lên, thường là Call hoặc Name hoặc None cho raise độc lập. cause là phần tùy chọn cho y trong raise x from y.

>>> print(ast.dump(ast.parse('raise x from y'), thụt lề=4))
mô-đun(
    cơ thể=[
        Tăng(
            exc=Name(id='x', ctx=Load()),
            nguyên nhân=Tên(id='y', ctx=Load()))])

class ast.Assert(test, msg)

Một lời khẳng định. test giữ điều kiện, chẳng hạn như nút Compare. msg giữ thông báo lỗi.

>>> print(ast.dump(ast.parse('assert x,y'), indent=4))
mô-đun(
    cơ thể=[
        Khẳng định(
            test=Name(id='x', ctx=Load()),
            msg=Tên(id='y', ctx=Load()))])

class ast.Delete(targets)

Đại diện cho một câu lệnh del. targets là danh sách các nút, chẳng hạn như các nút Name, Attribute hoặc Subscript.

>>> print(ast.dump(ast.parse('del x,y,z'), indent=4))
mô-đun(
    cơ thể=[
        Xóa(
            mục tiêu=[
                Tên(id='x', ctx=Del()),
                Tên(id='y', ctx=Del()),
                Tên(id='z', ctx=Del())])])

class ast.Pass

Một tuyên bố pass.

>>> print(ast.dump(ast.parse('pass'), indent=4))
mô-đun(
    cơ thể=[
        Đạt()])

class ast.TypeAlias(name, type_params, value)

Một type alias được tạo thông qua câu lệnh type. name là tên của bí danh, type_params là danh sách type parameters và value là giá trị của bí danh loại.

>>> print(ast.dump(ast.parse('type Alias = int'), indent=4))
mô-đun(
    cơ thể=[
        LoạiBí danh(
            name=Name(id='Bí danh', ctx=Store()),
            value=Name(id='int', ctx=Load()))])

Added in version 3.12.

Các câu lệnh khác chỉ áp dụng được bên trong các hàm hoặc vòng lặp sẽ được mô tả trong các phần khác.

Nhập khẩu

class ast.Import(names)

Một tuyên bố nhập khẩu. names là danh sách các nút alias.

>>> print(ast.dump(ast.parse('import x,y,z'), indent=4))
mô-đun(
    cơ thể=[
        Nhập khẩu(
            tên=[
                bí danh(tên='x'),
                bí danh(tên='y'),
                bí danh(name='z')])])

class ast.ImportFrom(module, names, level)

Đại diện cho from x import y. module là một chuỗi thô của tên 'từ', không có bất kỳ dấu chấm nào ở đầu hoặc None cho các câu lệnh như from . import foo. level là một số nguyên chứa mức nhập tương đối (0 có nghĩa là nhập tuyệt đối).

>>> print(ast.dump(ast.parse('from y import x,y,z'), indent=4))
mô-đun(
    cơ thể=[
        NhậpTừ(
            mô-đun='y',
            tên=[
                bí danh(tên='x'),
                bí danh(tên='y'),
                bí danh(name='z')],
            cấp độ=0)])

class ast.alias(name, asname)

Cả hai tham số đều là chuỗi tên thô. asname có thể là None nếu sử dụng tên thông thường.

>>> print(ast.dump(ast.parse('from ..foo.bar import a as b, c'), indent=4))
mô-đun(
    cơ thể=[
        NhậpTừ(
            mô-đun='foo.bar',
            tên=[
                bí danh(name='a', asname='b'),
                bí danh(name='c')],
            cấp độ=2)])

Kiểm soát luồng

Ghi chú

Các mệnh đề tùy chọn như else được lưu trữ dưới dạng danh sách trống nếu chúng không có.

class ast.If(test, body, orelse)

Một tuyên bố if. test giữ một nút duy nhất, chẳng hạn như nút Compare. body và orelse mỗi cái chứa một danh sách các nút.

Các mệnh đề elif không có biểu diễn đặc biệt trong AST mà xuất hiện dưới dạng các nút If bổ sung trong phần orelse của phần trước.

>>> print(ast.dump(ast.parse("""
... nếu x:
... ...
... Elif y:
... ...
... khác:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Nếu (
            test=Name(id='x', ctx=Load()),
            cơ thể=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))],
            orelse=[
                Nếu (
                    test=Name(id='y', ctx=Load()),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))],
                    orelse=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

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

Một vòng lặp for. target giữ (các) biến mà vòng lặp gán cho, dưới dạng một nút Name, Tuple, List, Attribute hoặc Subscript. iter giữ mục được lặp lại dưới dạng một nút duy nhất. body và orelse chứa danh sách các nút cần thực thi. Những lệnh trong orelse được thực thi nếu vòng lặp kết thúc bình thường, thay vì thông qua câu lệnh break.

type_comment

type_comment là một chuỗi tùy chọn có chú thích loại dưới dạng nhận xét.

>>> print(ast.dump(ast.parse("""
... cho x trong y:
... ...
... khác:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Vì (
            target=Name(id='x', ctx=Store()),
            iter=Name(id='y', ctx=Load()),
            cơ thể=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))],
            orelse=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))])])

class ast.While(test, body, orelse)

Một vòng lặp while. test giữ điều kiện, chẳng hạn như nút Compare.

>>> print(ast.dump(ast.parse("""
... trong khi x:
... ...
... khác:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trong khi(
            test=Name(id='x', ctx=Load()),
            cơ thể=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))],
            orelse=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))])])

class ast.Break

class ast.Continue

Câu lệnh break và continue.

>>> print(ast.dump(ast.parse("""\
... cho a trong b:
... nếu a > 5:
... nghỉ
... khác:
... tiếp tục
...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Vì (
            target=Name(id='a', ctx=Store()),
            iter=Name(id='b', ctx=Load()),
            cơ thể=[
                Nếu (
                    kiểm tra=So sánh(
                        left=Name(id='a', ctx=Load()),
                        ops=[
                            Gt()],
                        bộ so sánh=[
                            Hằng số(giá trị=5)]),
                    cơ thể=[
                        Phá vỡ()],
                    orelse=[
                        Tiếp tục()])])])

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

khối try. Tất cả các thuộc tính là danh sách các nút sẽ thực thi, ngoại trừ handlers, là danh sách các nút ExceptHandler.

>>> print(ast.dump(ast.parse("""
... thử:
... ...
... ngoại trừ Ngoại lệ:
... ...
... ngoại trừ Ngoại lệ khác là e:
... ...
... khác:
... ...
... cuối cùng:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Hãy thử(
            cơ thể=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))],
            trình xử lý=[
                Ngoại trừHandler(
                    type=Name(id='Ngoại lệ', ctx=Load()),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))]),
                Ngoại trừHandler(
                    type=Name(id='OtherException', ctx=Load()),
                    tên='e',
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])],
            orelse=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))],
            người cuối cùng=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))])])

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

Các khối try được theo sau bởi các mệnh đề except*. Các thuộc tính giống như đối với Try nhưng các nút ExceptHandler trong handlers được hiểu là các khối except* thay vì except.

>>> print(ast.dump(ast.parse("""
... thử:
... ...
... ngoại trừ* Ngoại lệ:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        TryStar(
            cơ thể=[
                Expr(
                    value=Hằng số(giá trị=Dấu chấm lửng))],
            trình xử lý=[
                Ngoại trừHandler(
                    type=Name(id='Ngoại lệ', ctx=Load()),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.11.

class ast.ExceptHandler(type, name, body)

Một mệnh đề except duy nhất. type là loại ngoại lệ mà nó sẽ khớp, thường là nút Name (hoặc None cho mệnh đề except: tổng hợp). name là một chuỗi thô để tên giữ ngoại lệ hoặc None nếu mệnh đề không có as foo. body là danh sách các nút.

>>> print(ast.dump(ast.parse("""\
... thử:
... một + 1
... ngoại trừ TypeError:
... vượt qua
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Hãy thử(
            cơ thể=[
                Expr(
                    giá trị=BinOp(
                        left=Name(id='a', ctx=Load()),
                        op=Thêm(),
                        right=Hằng số(giá trị=1)))],
            trình xử lý=[
                Ngoại trừHandler(
                    type=Name(id='TypeError', ctx=Load()),
                    cơ thể=[
                        Đạt()])])])

class ast.With(items, body, type_comment)

Một khối with. items là danh sách các nút withitem đại diện cho trình quản lý bối cảnh và body là khối thụt lề bên trong ngữ cảnh.

type_comment

type_comment là một chuỗi tùy chọn có chú thích loại dưới dạng nhận xét.

class ast.withitem(context_expr, optional_vars)

Một trình quản lý bối cảnh duy nhất trong khối with. context_expr là trình quản lý bối cảnh, thường là nút Call. optional_vars là Name, Tuple hoặc List cho phần as foo hoặc None nếu phần đó không được sử dụng.

>>> print(ast.dump(ast.parse("""\
... với a là b, c là d:
... cái gì đó(b, d)
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Với (
            mục=[
                withitem(
                    context_expr=Name(id='a', ctx=Load()),
                    tùy chọn_vars=Tên(id='b', ctx=Store())),
                withitem(
                    context_expr=Name(id='c', ctx=Load()),
                    tùy chọn_vars=Tên(id='d', ctx=Store()))],
            cơ thể=[
                Expr(
                    value=Gọi(
                        func=Name(id='thứ gì đó', ctx=Load()),
                        args=[
                            Tên(id='b', ctx=Load()),
                            Tên(id='d', ctx=Load())]))])])

Khớp mẫu

class ast.Match(subject, cases)

Một tuyên bố match. subject giữ chủ đề của trận đấu (đối tượng được so khớp với các trường hợp) và cases chứa các nút match_case có thể lặp lại với các trường hợp khác nhau.

Added in version 3.10.

class ast.match_case(pattern, guard, body)

Một mẫu trường hợp duy nhất trong câu lệnh match. pattern chứa mẫu so khớp mà đối tượng sẽ được so khớp. Lưu ý rằng các nút AST được tạo cho các mẫu khác với các nút được tạo cho biểu thức, ngay cả khi chúng có cùng cú pháp.

Thuộc tính guard chứa một biểu thức sẽ được đánh giá nếu mẫu phù hợp với chủ đề.

body chứa danh sách các nút sẽ thực thi nếu mẫu khớp và kết quả đánh giá biểu thức bảo vệ là đúng.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp [x] nếu x>0:
... ...
... trường hợp tuple():
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchSequence(
                        mẫu=[
                            MatchAs(name='x')]),
                    bảo vệ=So sánh(
                        left=Name(id='x', ctx=Load()),
                        ops=[
                            Gt()],
                        bộ so sánh=[
                            Hằng số(giá trị=0)]),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))]),
                match_case(
                    mẫu=MatchClass(
                        cls=Name(id='tuple', ctx=Load())),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

class ast.MatchValue(value)

Mẫu chữ hoặc giá trị khớp để so sánh theo đẳng thức. value là một nút biểu thức. Các nút giá trị được phép bị hạn chế như được mô tả trong tài liệu câu lệnh so khớp. Mẫu này thành công nếu đối tượng khớp bằng giá trị được đánh giá.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp "Có liên quan":
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchValue(
                        value=Hằng số(giá trị='Có liên quan')),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

class ast.MatchSingleton(value)

Một mẫu chữ phù hợp để so sánh theo danh tính. value là đơn vị được so sánh với: None, True hoặc False. Mẫu này thành công nếu chủ đề phù hợp là hằng số đã cho.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp Không có:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchSingleton(giá trị=Không),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

class ast.MatchSequence(patterns)

Một mẫu trình tự khớp. patterns chứa các mẫu được so khớp với các thành phần chủ đề nếu chủ đề là một chuỗi. Khớp với một chuỗi có độ dài thay đổi nếu một trong các mẫu con là nút MatchStar, nếu không thì khớp với một chuỗi có độ dài cố định.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp [1, 2]:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchSequence(
                        mẫu=[
                            MatchValue(
                                giá trị=Hằng số(giá trị=1)),
                            MatchValue(
                                value=Hằng số(giá trị=2))]),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

class ast.MatchStar(name)

Khớp phần còn lại của chuỗi theo mẫu chuỗi khớp có độ dài thay đổi. Nếu name không phải là None, một danh sách chứa các thành phần chuỗi còn lại sẽ được liên kết với tên đó nếu mẫu chuỗi tổng thể thành công.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp [1, 2, *còn lại]:
... ...
... trường hợp [*_]:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchSequence(
                        mẫu=[
                            MatchValue(
                                giá trị=Hằng số(giá trị=1)),
                            MatchValue(
                                giá trị=Hằng số(giá trị=2)),
                            MatchStar(name='rest')]),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))]),
                match_case(
                    mẫu=MatchSequence(
                        mẫu=[
                            MatchStar()]),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

class ast.MatchMapping(keys, patterns, rest)

Một mẫu ánh xạ phù hợp. keys là một chuỗi các nút biểu thức. patterns là một chuỗi các nút mẫu tương ứng. rest là tên tùy chọn có thể được chỉ định để nắm bắt các phần tử ánh xạ còn lại. Các biểu thức khóa được phép bị hạn chế như được mô tả trong tài liệu câu lệnh so khớp.

Mẫu này thành công nếu chủ đề là một ánh xạ, tất cả các biểu thức khóa được đánh giá đều có trong ánh xạ và giá trị tương ứng với mỗi khóa khớp với mẫu con tương ứng. Nếu rest không phải là None, một lệnh chứa các thành phần ánh xạ còn lại sẽ được liên kết với tên đó nếu mẫu ánh xạ tổng thể thành công.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp {1: _, 2: _}:
... ...
... trường hợp {** phần còn lại}:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchMapping(
                        phím=[
                            Hằng số(giá trị=1),
                            Hằng số(giá trị=2)],
                        mẫu=[
                            MatchAs(),
                            MatchAs()]),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))]),
                match_case(
                    mẫu=MatchMapping(rest='rest'),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

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

Một mô hình lớp phù hợp. cls là một biểu thức cho biết lớp danh nghĩa được khớp. patterns là một chuỗi các nút mẫu được so khớp với chuỗi các thuộc tính khớp mẫu được xác định theo lớp. kwd_attrs là một chuỗi các thuộc tính bổ sung cần khớp (được chỉ định làm đối số từ khóa trong mẫu lớp), kwd_patterns là các mẫu tương ứng (được chỉ định làm giá trị từ khóa trong mẫu lớp).

Mẫu này thành công nếu chủ thể là một thể hiện của lớp được chỉ định, tất cả các mẫu vị trí khớp với các thuộc tính do lớp xác định tương ứng và mọi thuộc tính từ khóa được chỉ định đều khớp với mẫu tương ứng của chúng.

Lưu ý: các lớp có thể xác định một thuộc tính trả về self để khớp một nút mẫu với thể hiện được khớp. Một số loại dựng sẵn cũng được so khớp theo cách đó, như được mô tả trong tài liệu câu lệnh so khớp.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp Point2D(0, 0):
... ...
... trường hợp Point3D(x=0, y=0, z=0):
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchClass(
                        cls=Name(id='Point2D', ctx=Load()),
                        mẫu=[
                            MatchValue(
                                giá trị=Hằng số(giá trị=0)),
                            MatchValue(
                                value=Hằng số(giá trị=0))]),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))]),
                match_case(
                    mẫu=MatchClass(
                        cls=Name(id='Point3D', ctx=Load()),
                        kwd_attrs=[
                            'x',
                            'y',
                            'z'],
                        kwd_patterns=[
                            MatchValue(
                                giá trị=Hằng số(giá trị=0)),
                            MatchValue(
                                giá trị=Hằng số(giá trị=0)),
                            MatchValue(
                                value=Hằng số(giá trị=0))]),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

class ast.MatchAs(pattern, name)

Đối sánh "as-pattern", mẫu chụp hoặc mẫu ký tự đại diện. pattern chứa mẫu so khớp mà đối tượng sẽ được so khớp. Nếu mẫu là None, nút đại diện cho mẫu chụp (tức là tên trống) và sẽ luôn thành công.

Thuộc tính name chứa tên sẽ bị ràng buộc nếu mẫu thành công. Nếu name là None thì pattern cũng phải là None và nút đại diện cho mẫu ký tự đại diện.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp [x] là y:
... ...
... trường hợp _:
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchAs(
                        mẫu=MatchSequence(
                            mẫu=[
                                MatchAs(name='x')]),
                        tên='y'),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))]),
                match_case(
                    mẫu=MatchAs(),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

class ast.MatchOr(patterns)

Một "hoặc-mẫu" khớp. Một mẫu hoặc khớp lần lượt từng mẫu con của nó với chủ đề cho đến khi thành công. Mẫu or sau đó được coi là thành công. Nếu không có mẫu con nào thành công thì mẫu or thất bại. Thuộc tính patterns chứa danh sách các nút mẫu khớp sẽ khớp với chủ đề.

>>> print(ast.dump(ast.parse("""
... khớp x:
... trường hợp [x] | (y):
... ...
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        Trận đấu(
            chủ đề=Tên(id='x', ctx=Load()),
            trường hợp=[
                match_case(
                    mẫu=MatchOr(
                        mẫu=[
                            Chuỗi trận đấu(
                                mẫu=[
                                    MatchAs(name='x')]),
                            MatchAs(name='y')]),
                    cơ thể=[
                        Expr(
                            value=Hằng số(giá trị=Dấu chấm lửng))])])])

Added in version 3.10.

Nhập chú thích

class ast.TypeIgnore(lineno, tag)

Một bình luận # type: ignore có tại lineno. tag là thẻ tùy chọn được chỉ định theo mẫu # type: ignore <tag>.

>>> print(ast.dump(ast.parse('x = 1 # type: bypass', type_comments=True), thụt lề=4))
mô-đun(
    cơ thể=[
        Chỉ định(
            mục tiêu=[
                Tên(id='x', ctx=Store())],
            giá trị=Hằng số(giá trị=1))],
    type_ignores=[
        TypeIgnore(lineno=1, tag='')])
>>> print(ast.dump(ast.parse('x: bool = 1 # type: bỏ qua[phân công]', type_comments=True), thụt lề=4))
mô-đun(
    cơ thể=[
        AnnAssign(
            target=Name(id='x', ctx=Store()),
            chú thích=Tên(id='bool', ctx=Load()),
            giá trị=Hằng số(giá trị=1),
            đơn giản=1)],
    type_ignores=[
        TypeIgnore(lineno=1, tag='[bài tập]')])

Ghi chú

Các nút TypeIgnore không được tạo khi tham số type_comments được đặt thành False (mặc định). Xem ast.parse() để biết thêm chi tiết.

Added in version 3.8.

Loại tham số

Type parameters có thể tồn tại trên các lớp, hàm và bí danh kiểu.

class ast.TypeVar(name, bound, default_value)

Một typing.TypeVar. name là tên của biến loại. bound là giới hạn hoặc ràng buộc, nếu có. Nếu bound là Tuple, nó đại diện cho các ràng buộc; nếu không thì nó đại diện cho giới hạn. default_value là giá trị mặc định; nếu TypeVar không có mặc định, thuộc tính này sẽ được đặt thành None.

>>> print(ast.dump(ast.parse("type Alias[T: int = bool] = list[T]"), indent=4))
mô-đun(
    cơ thể=[
        LoạiBí danh(
            name=Name(id='Bí danh', ctx=Store()),
            type_params=[
                LoạiVar(
                    tên='T',
                    ràng buộc=Tên(id='int', ctx=Load()),
                    default_value=Name(id='bool', ctx=Load()))],
            giá trị=Chỉ số dưới(
                value=Name(id='list', ctx=Load()),
                slice=Name(id='T', ctx=Load()),
                ctx=Tải()))])

Added in version 3.12.

Thay đổi trong phiên bản 3.13: Đã thêm tham số default_value.

class ast.ParamSpec(name, default_value)

Một typing.ParamSpec. name là tên của thông số kỹ thuật. default_value là giá trị mặc định; nếu ParamSpec không có mặc định thì thuộc tính này sẽ được đặt thành None.

>>> print(ast.dump(ast.parse("type Alias[**P = [int, str]] = Callable[P, int]"), indent=4))
mô-đun(
    cơ thể=[
        LoạiBí danh(
            name=Name(id='Bí danh', ctx=Store()),
            type_params=[
                Thông số(
                    tên='P',
                    default_value=Danh sách(
                        elts=[
                            Tên(id='int', ctx=Load()),
                            Tên(id='str', ctx=Load())],
                        ctx=Tải()))],
            giá trị=Chỉ số dưới(
                value=Name(id='Có thể gọi được', ctx=Load()),
                lát=Tuple(
                    elts=[
                        Tên(id='P', ctx=Load()),
                        Tên(id='int', ctx=Load())],
                    ctx=Tải()),
                ctx=Tải()))])

Added in version 3.12.

Thay đổi trong phiên bản 3.13: Đã thêm tham số default_value.

class ast.TypeVarTuple(name, default_value)

Một typing.TypeVarTuple. name là tên của bộ biến kiểu. default_value là giá trị mặc định; nếu TypeVarTuple không có mặc định thì thuộc tính này sẽ được đặt thành None.

>>> print(ast.dump(ast.parse("type Alias[*Ts = ()] = tuple[*Ts]"), indent=4))
mô-đun(
    cơ thể=[
        LoạiBí danh(
            name=Name(id='Bí danh', ctx=Store()),
            type_params=[
                LoạiVarTuple(
                    name='Ts',
                    default_value=Tuple(ctx=Load()))],
            giá trị=Chỉ số dưới(
                value=Name(id='tuple', ctx=Load()),
                lát=Tuple(
                    elts=[
                        Được gắn dấu sao(
                            value=Name(id='Ts', ctx=Load()),
                            ctx=Tải())],
                    ctx=Tải()),
                ctx=Tải()))])

Added in version 3.12.

Thay đổi trong phiên bản 3.13: Đã thêm tham số default_value.

Định nghĩa hàm và lớp

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

Một định nghĩa hàm

• name là chuỗi thô của tên hàm.

• args là nút arguments.

• body là danh sách các nút bên trong hàm.

• decorator_list là danh sách các trình trang trí sẽ được áp dụng, được lưu ở ngoài cùng đầu tiên (tức là phần đầu tiên trong danh sách sẽ được áp dụng sau cùng).

• returns là chú thích trả về.

• type_params là danh sách type parameters.

type_comment

type_comment là một chuỗi tùy chọn có chú thích loại dưới dạng nhận xét.

Thay đổi trong phiên bản 3.12: Đã thêm type_params.

class ast.Lambda(args, body)

lambda là định nghĩa hàm tối thiểu có thể được sử dụng bên trong một biểu thức. Không giống như FunctionDef, body giữ một nút duy nhất.

>>> print(ast.dump(ast.parse('lambda x,y: ...'), indent=4))
mô-đun(
    cơ thể=[
        Expr(
            giá trị=Lambda(
                args=đối số(
                    args=[
                        arg(arg='x'),
                        arg(arg='y')]),
                body=Hằng số(giá trị=Dấu chấm lửng)))])

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

Các đối số cho một hàm.

• posonlyargs, args và kwonlyargs là danh sách các nút arg.

• vararg và kwarg là các nút arg đơn, đề cập đến các tham số *args, **kwargs.

• kw_defaults là danh sách các giá trị mặc định cho các đối số chỉ có từ khóa. Nếu một là None thì bắt buộc phải có đối số tương ứng.

• defaults là danh sách các giá trị mặc định cho các đối số có thể được truyền theo vị trí. Nếu có ít giá trị mặc định hơn thì chúng tương ứng với n đối số cuối cùng.

class ast.arg(arg, annotation, type_comment)

Một đối số duy nhất trong một danh sách. arg là chuỗi thô của tên đối số; annotation là chú thích của nó, chẳng hạn như nút Name.

type_comment

type_comment là một chuỗi tùy chọn có chú thích loại dưới dạng nhận xét

>>> print(ast.dump(ast.parse("""\
... @ trang trí1
... @ trang trí2
... def f(a: 'chú thích', b=1, c=2, *d, e, f=3, **g) -> 'trả lại chú thích':
... vượt qua
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        HàmDef(
            tên='f',
            args=đối số(
                args=[
                    tranh cãi(
                        arg='a',
                        chú thích=Hằng số(giá trị='chú thích')),
                    arg(arg='b'),
                    arg(arg='c')],
                vararg=arg(arg='d'),
                kwonlyargs=[
                    arg(arg='e'),
                    arg(arg='f')],
                kw_defaults=[
                    không,
                    Hằng số(giá trị=3)],
                kwarg=arg(arg='g'),
                mặc định=[
                    Hằng số(giá trị=1),
                    Hằng số(giá trị=2)]),
            cơ thể=[
                Vượt qua()],
            trang trí_list=[
                Tên(id='trang trí1', ctx=Load()),
                Tên(id='trang trí2', ctx=Load())],
            return=Constant(value='return chú thích'))])

class ast.Return(value)

Một tuyên bố return.

>>> print(ast.dump(ast.parse('return 4'), thụt lề=4))
mô-đun(
    cơ thể=[
        Trở lại(
            value=Hằng số(giá trị=4))])

class ast.Yield(value)

class ast.YieldFrom(value)

Biểu thức yield hoặc yield from. Vì đây là các biểu thức nên chúng phải được gói trong nút Expr nếu giá trị gửi lại không được sử dụng.

>>> print(ast.dump(ast.parse('yield x'), indent=4))
mô-đun(
    cơ thể=[
        Expr(
            giá trị=Sản lượng(
                value=Name(id='x', ctx=Load())))])

>>> print(ast.dump(ast.parse('yield from x'), indent=4))
mô-đun(
    cơ thể=[
        Expr(
            value=YieldFrom(
                value=Name(id='x', ctx=Load())))])

class ast.Global(names)

class ast.Nonlocal(names)

câu lệnh global và nonlocal. names là danh sách các chuỗi thô.

>>> print(ast.dump(ast.parse('global x,y,z'), indent=4))
mô-đun(
    cơ thể=[
        Toàn cầu(
            tên=[
                'x',
                'y',
                'z'])])

>>> print(ast.dump(ast.parse('nonlocal x,y,z'), indent=4))
mô-đun(
    cơ thể=[
        Không cục bộ(
            tên=[
                'x',
                'y',
                'z'])])

class ast.ClassDef(name, bases, keywords, body, decorator_list, type_params)

Một định nghĩa lớp.

• name là chuỗi thô cho tên lớp

• bases là danh sách các nút dành cho các lớp cơ sở được chỉ định rõ ràng.

• keywords là danh sách các nút keyword, chủ yếu dành cho 'siêu lớp'. Các từ khóa khác sẽ được chuyển đến siêu dữ liệu, theo PEP 3115.

• body là danh sách các nút biểu thị mã trong định nghĩa lớp.

• decorator_list là danh sách các nút, như trong FunctionDef.

• type_params là danh sách type parameters.

>>> print(ast.dump(ast.parse("""\
... @ trang trí1
... @ trang trí2
... lớp Foo(base1, base2, metaclass=meta):
... vượt qua
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        ClassDef(
            name='Foo',
            căn cứ=[
                Tên(id='base1', ctx=Load()),
                Tên(id='base2', ctx=Load())],
            từ khóa=[
                từ khóa(
                    arg='siêu lớp',
                    value=Name(id='meta', ctx=Load()))],
            cơ thể=[
                Vượt qua()],
            trang trí_list=[
                Tên(id='trang trí1', ctx=Load()),
                Tên(id='trang trí2', ctx=Load())])])

Thay đổi trong phiên bản 3.12: Đã thêm type_params.

Không đồng bộ và chờ đợi

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

Định nghĩa hàm async def. Có cùng trường với FunctionDef.

Thay đổi trong phiên bản 3.12: Đã thêm type_params.

class ast.Await(value)

Một biểu thức await. value là thứ nó đang chờ đợi. Chỉ hợp lệ trong phần thân của AsyncFunctionDef.

>>> print(ast.dump(ast.parse("""\
... không đồng bộ def f():
... đang chờ other_func()
... """), thụt lề=4))
mô-đun(
    cơ thể=[
        AsyncFunctionDef(
            tên='f',
            args=đối số(),
            cơ thể=[
                Expr(
                    giá trị=Đang chờ(
                        value=Gọi(
                            func=Name(id='other_func', ctx=Load()))))])])

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

class ast.AsyncWith(items, body, type_comment)

vòng lặp async for và trình quản lý bối cảnh async with. Chúng có các trường tương tự như For và With. Chỉ hợp lệ trong phần thân của AsyncFunctionDef.

Ghi chú

Khi một chuỗi được phân tích cú pháp bởi ast.parse(), các nút toán tử (các lớp con của ast.operator, ast.unaryop, ast.cmpop, ast.boolop và ast.expr_context) trên cây được trả về sẽ là các nút đơn. Các thay đổi đối với một sẽ được phản ánh trong tất cả các lần xuất hiện khác có cùng giá trị (ví dụ: ast.Add).

người trợ giúp ast

Ngoài các lớp nút, mô-đun ast còn xác định các hàm và lớp tiện ích này để duyệt qua các cây cú pháp trừu tượng:

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

Phân tích nguồn thành nút AST. Tương đương với compile(source, filename, mode, flags=FLAGS_VALUE, optimize=optimize), trong đó FLAGS_VALUE là ast.PyCF_ONLY_AST nếu optimize <= 0 và ast.PyCF_OPTIMIZED_AST nếu ngược lại.

Nếu type_comments=True được cung cấp, trình phân tích cú pháp sẽ được sửa đổi để kiểm tra và trả về các nhận xét kiểu như được chỉ định bởi PEP 484 và PEP 526. Điều này tương đương với việc thêm ast.PyCF_TYPE_COMMENTS vào các cờ được truyền cho compile(). Điều này sẽ báo cáo lỗi cú pháp cho các nhận xét loại bị đặt sai vị trí. Nếu không có cờ này, các nhận xét về loại sẽ bị bỏ qua và trường type_comment trên các nút AST đã chọn sẽ luôn là None. Ngoài ra, vị trí của các bình luận # type: ignore sẽ được trả về dưới dạng thuộc tính type_ignores của Module (nếu không thì nó luôn là một danh sách trống).

Ngoài ra, nếu mode là 'func_type', cú pháp đầu vào sẽ được sửa đổi để tương ứng với "nhận xét loại chữ ký" PEP 484, ví dụ: (str, int) -> List[str].

Việc đặt feature_version thành một bộ (major, minor) sẽ dẫn đến nỗ lực phân tích cú pháp "nỗ lực tốt nhất" bằng cách sử dụng ngữ pháp của phiên bản Python đó. Ví dụ: cài đặt feature_version=(3, 9) sẽ cố gắng không cho phép phân tích cú pháp các câu lệnh match. Hiện tại major phải bằng 3. Phiên bản được hỗ trợ thấp nhất là (3, 7) (và điều này có thể tăng lên trong các phiên bản Python trong tương lai); cao nhất là sys.version_info[0:2]. Nỗ lực "nỗ lực cao nhất" có nghĩa là không có gì đảm bảo rằng phân tích cú pháp (hoặc thành công của phân tích cú pháp) giống như khi chạy trên phiên bản Python tương ứng với feature_version.

Nếu nguồn chứa ký tự null (\0), ValueError sẽ được nâng lên.

Cảnh báo

Lưu ý rằng việc phân tích cú pháp thành công mã nguồn thành đối tượng AST không đảm bảo rằng mã nguồn được cung cấp là mã Python hợp lệ có thể được thực thi khi bước biên dịch có thể đưa ra thêm các ngoại lệ SyntaxError. Chẳng hạn, return 42 nguồn tạo ra một nút AST hợp lệ cho câu lệnh trả về, nhưng nó không thể được biên dịch một mình (nó cần phải nằm trong một nút hàm).

Đặc biệt, ast.parse() sẽ không thực hiện bất kỳ kiểm tra phạm vi nào như bước biên dịch sẽ thực hiện.

Cảnh báo

Có thể làm hỏng trình thông dịch Python với một chuỗi đủ lớn/phức tạp do giới hạn độ sâu ngăn xếp trong trình biên dịch AST của Python.

Thay đổi trong phiên bản 3.8: Đã thêm type_comments, mode='func_type' và feature_version.

Thay đổi trong phiên bản 3.13: Phiên bản được hỗ trợ tối thiểu cho feature_version hiện là (3, 7). Đối số optimize đã được thêm vào.

ast.unparse(ast_obj)

Giải nén đối tượng ast.AST và tạo một chuỗi có mã sẽ tạo ra đối tượng ast.AST tương đương nếu được phân tích cú pháp lại bằng ast.parse().

Cảnh báo

Chuỗi mã được tạo ra sẽ không nhất thiết phải bằng mã gốc đã tạo ra đối tượng ast.AST (không có bất kỳ tối ưu hóa trình biên dịch nào, chẳng hạn như bộ dữ liệu/tập hợp cố định).

Cảnh báo

Cố gắng giải nén một biểu thức cực kỳ phức tạp sẽ dẫn đến RecursionError.

Added in version 3.9.

ast.literal_eval(node_or_string)

Đánh giá một nút biểu thức hoặc một chuỗi chỉ chứa hiển thị chữ hoặc vùng chứa Python. Chuỗi hoặc nút được cung cấp chỉ có thể bao gồm các cấu trúc chữ Python sau: chuỗi, byte, số, bộ dữ liệu, danh sách, ký tự, bộ, boolean, None và Ellipsis.

Điều này có thể được sử dụng để đánh giá các chuỗi chứa các giá trị Python mà không cần phải tự phân tích các giá trị đó. Nó không có khả năng đánh giá các biểu thức phức tạp tùy ý, ví dụ như liên quan đến các toán tử hoặc lập chỉ mục.

Trước đây, chức năng này đã được ghi nhận là "an toàn" mà không xác định điều đó có nghĩa là gì. Điều đó thật sai lầm. Điều này được thiết kế đặc biệt để không thực thi mã Python, không giống như eval() tổng quát hơn. Không có không gian tên, không tra cứu tên hoặc khả năng gọi ra. Nhưng nó không tránh khỏi bị tấn công: Một đầu vào tương đối nhỏ có thể dẫn đến cạn kiệt bộ nhớ hoặc cạn kiệt ngăn xếp C, làm hỏng quá trình. Ngoài ra còn có khả năng từ chối dịch vụ sử dụng CPU quá mức trên một số đầu vào. Do đó, việc gọi nó trên dữ liệu không đáng tin cậy là không nên.

Cảnh báo

Có thể làm hỏng trình thông dịch Python do giới hạn độ sâu ngăn xếp trong trình biên dịch AST của Python.

Nó có thể tăng ValueError, TypeError, SyntaxError, MemoryError và RecursionError tùy thuộc vào đầu vào không đúng định dạng.

Thay đổi trong phiên bản 3.2: Bây giờ cho phép byte và đặt chữ.

Thay đổi trong phiên bản 3.9: Hiện hỗ trợ tạo bộ trống với 'set()'.

Thay đổi trong phiên bản 3.10: Đối với đầu vào chuỗi, khoảng trắng và tab ở đầu hiện đã bị loại bỏ.

ast.get_docstring(node, clean=True)

Trả về chuỗi tài liệu của node đã cho (phải là nút FunctionDef, AsyncFunctionDef, ClassDef hoặc Module) hoặc None nếu nó không có chuỗi tài liệu. Nếu clean là đúng, hãy xóa vết lõm của chuỗi tài liệu bằng inspect.cleandoc().

Thay đổi trong phiên bản 3.5: AsyncFunctionDef hiện đã được hỗ trợ.

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

Lấy đoạn mã nguồn của source đã tạo ra node. Nếu thiếu một số thông tin vị trí (lineno, end_lineno, col_offset hoặc end_col_offset), hãy trả về None.

Nếu padded là True, dòng đầu tiên của câu lệnh nhiều dòng sẽ được đệm bằng dấu cách để khớp với vị trí ban đầu của nó.

Added in version 3.8.

ast.fix_missing_locations(node)

Khi bạn biên dịch cây nút bằng compile(), trình biên dịch sẽ yêu cầu các thuộc tính lineno và col_offset cho mọi nút hỗ trợ chúng. Việc điền vào các nút được tạo khá tẻ nhạt, vì vậy trình trợ giúp này thêm các thuộc tính này theo cách đệ quy ở những nơi chưa được đặt, bằng cách đặt chúng thành giá trị của nút cha. Nó hoạt động đệ quy bắt đầu từ node.

ast.increment_lineno(node, n=1)

Tăng số dòng và số dòng cuối của mỗi nút trong cây bắt đầu từ node lên n. Điều này rất hữu ích khi "di chuyển mã" đến một vị trí khác trong tệp.

ast.copy_location(new_node, old_node)

Sao chép vị trí nguồn (lineno, col_offset, end_lineno và end_col_offset) từ old_node sang new_node nếu có thể và trả về new_node.

ast.iter_fields(node)

Mang lại một bộ (fieldname, value) cho mỗi trường trong node._fields hiện có trên node.

ast.iter_child_nodes(node)

Mang lại tất cả các nút con trực tiếp của node, nghĩa là tất cả các trường là nút và tất cả các mục của trường là danh sách các nút.

ast.walk(node)

Đệ quy sinh ra tất cả các nút con trong cây bắt đầu từ node (bao gồm cả node), không theo thứ tự cụ thể nào. Điều này hữu ích nếu bạn chỉ muốn sửa đổi các nút tại chỗ và không quan tâm đến ngữ cảnh.

class ast.NodeVisitor

Lớp cơ sở khách truy cập nút đi theo cây cú pháp trừu tượng và gọi hàm khách truy cập cho mọi nút được tìm thấy. Hàm này có thể trả về một giá trị được chuyển tiếp bằng phương thức visit().

Lớp này có nghĩa là được phân lớp, với lớp con thêm các phương thức khách truy cập.

visit(node)

Ghé thăm một nút. Việc triển khai mặc định gọi phương thức có tên self.visit_classname trong đó classname là tên của lớp nút hoặc generic_visit() nếu phương thức đó không tồn tại.

generic_visit(node)

Khách truy cập này gọi visit() trên tất cả nút con của nút.

Lưu ý rằng các nút con của các nút có phương thức khách truy cập tùy chỉnh sẽ không được truy cập trừ khi khách truy cập gọi generic_visit() hoặc truy cập chính chúng.

visit_Constant(node)

Xử lý tất cả các nút không đổi.

Không sử dụng NodeVisitor nếu bạn muốn áp dụng các thay đổi cho các nút trong quá trình truyền tải. Đối với điều này, tồn tại một khách truy cập đặc biệt (NodeTransformer) cho phép sửa đổi.

Không được dùng nữa kể từ phiên bản 3.8, đã bị xóa trong phiên bản 3.14: Các phương thức visit_Num(), visit_Str(), visit_Bytes(), visit_NameConstant() và visit_Ellipsis() sẽ không được gọi trong Python 3.14+. Thay vào đó, hãy thêm phương thức visit_Constant() để xử lý tất cả các nút không đổi.

class ast.NodeTransformer

Lớp con NodeVisitor đi theo cây cú pháp trừu tượng và cho phép sửa đổi các nút.

Zz000zz sẽ hướng dẫn AST và sử dụng giá trị trả về của các phương thức khách truy cập để thay thế hoặc xóa nút cũ. Nếu giá trị trả về của phương thức khách truy cập là None, nút sẽ bị xóa khỏi vị trí của nó, nếu không nó sẽ được thay thế bằng giá trị trả về. Giá trị trả về có thể là nút gốc trong trường hợp đó không có sự thay thế nào diễn ra.

Dưới đây là một ví dụ về biến áp ghi lại tất cả các lần tra cứu tên (foo) thành data['foo']:

lớp RewriteName(NodeTransformer):

    def Visit_Name(self, node):
        trả về chỉ số dưới(
            value=Name(id='data', ctx=Load()),
            lát=Hằng số(giá trị=node.id),
            ctx=node.ctx
        )

Hãy nhớ rằng nếu nút bạn đang vận hành có các nút con thì trước tiên bạn phải tự chuyển đổi các nút con đó hoặc gọi phương thức generic_visit() cho nút đó.

Đối với các nút là một phần của tập hợp các câu lệnh (áp dụng cho tất cả các nút câu lệnh), khách truy cập cũng có thể trả về danh sách các nút thay vì chỉ một nút duy nhất.

Nếu NodeTransformer giới thiệu các nút mới (không phải là một phần của cây ban đầu) mà không cung cấp cho chúng thông tin vị trí (chẳng hạn như lineno), thì fix_missing_locations() sẽ được gọi với cây con mới để tính toán lại thông tin vị trí:

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

Thông thường bạn sử dụng máy biến áp như thế này:

nút = YourTransformer().visit(node)

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

Trả về kết xuất được định dạng của cây trong node. Điều này chủ yếu hữu ích cho mục đích gỡ lỗi. Nếu annotate_fields là true (theo mặc định), chuỗi trả về sẽ hiển thị tên và giá trị cho các trường. Nếu annotate_fields sai, chuỗi kết quả sẽ gọn hơn bằng cách bỏ qua các tên trường rõ ràng. Các thuộc tính như số dòng và độ lệch cột không được kết xuất theo mặc định. Nếu muốn, include_attributes có thể được đặt thành true.

Nếu indent là một số nguyên hoặc chuỗi không âm thì cây sẽ được in đẹp với mức thụt lề đó. Mức thụt lề bằng 0, âm hoặc "" sẽ chỉ chèn dòng mới. None (mặc định) chọn cách trình bày một dòng. Sử dụng số nguyên dương thụt lề để thụt nhiều khoảng trắng cho mỗi cấp độ. Nếu indent là một chuỗi (chẳng hạn như "\t"), chuỗi đó được dùng để thụt lề từng cấp độ.

Nếu show_empty sai (mặc định), danh sách trống tùy chọn sẽ bị bỏ qua khỏi đầu ra. Các giá trị None tùy chọn luôn bị bỏ qua.

Thay đổi trong phiên bản 3.9: Đã thêm tùy chọn indent.

Thay đổi trong phiên bản 3.13: Đã thêm tùy chọn show_empty.

>>> print(ast.dump(ast.parse("""\
... không đồng bộ def f():
... đang chờ other_func()
... """), thụt lề=4, show_empty=True))
mô-đun(
    cơ thể=[
        AsyncFunctionDef(
            tên='f',
            args=đối số(
                posonargs=[],
                đối số=[],
                kwonlyargs=[],
                kw_defaults=[],
                mặc định=[]),
            cơ thể=[
                Expr(
                    giá trị=Đang chờ(
                        value=Gọi(
                            func=Name(id='other_func', ctx=Load()),
                            đối số=[],
                            từ khóa=[])))],
            trang trí_list=[],
            type_params=[])],
    type_ignores=[])

Cờ trình biên dịch

Các cờ sau có thể được chuyển tới compile() để thay đổi hiệu ứng khi biên dịch chương trình:

ast.PyCF_ALLOW_TOP_LEVEL_AWAIT

Cho phép hỗ trợ khả năng hiểu await, async for, async with và async cấp cao nhất.

Added in version 3.8.

ast.PyCF_ONLY_AST

Tạo và trả về một cây cú pháp trừu tượng thay vì trả về một đối tượng mã đã biên dịch.

ast.PyCF_OPTIMIZED_AST

AST được trả về được tối ưu hóa theo đối số optimize trong compile() hoặc ast.parse().

Added in version 3.13.

ast.PyCF_TYPE_COMMENTS

Cho phép hỗ trợ nhận xét loại kiểu PEP 484 và PEP 526 (# type: <type>, # type: ignore <stuff>).

Added in version 3.8.

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

So sánh đệ quy hai AST.

compare_attributes ảnh hưởng đến việc các thuộc tính AST có được xem xét trong so sánh hay không. Nếu compare_attributes là False (mặc định) thì các thuộc tính sẽ bị bỏ qua. Nếu không thì tất cả chúng phải bằng nhau. Tùy chọn này rất hữu ích để kiểm tra xem các AST có cấu trúc giống nhau nhưng khác nhau về khoảng trắng hoặc các chi tiết tương tự hay không. Các thuộc tính bao gồm số dòng và độ lệch cột.

Added in version 3.14.

Sử dụng dòng lệnh

Added in version 3.9.

Mô-đun ast có thể được thực thi dưới dạng tập lệnh từ dòng lệnh. Nó đơn giản như:

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

Các tùy chọn sau được chấp nhận:

-h, --help

Hiển thị thông báo trợ giúp và thoát.

-m <mode>

--mode <mode>

Chỉ định loại mã nào phải được biên dịch, như đối số mode trong parse().

--no-type-comments

Đừng phân tích các nhận xét kiểu.

-a, --include-attributes

Bao gồm các thuộc tính như số dòng và độ lệch cột.

-i <indent>

--indent <indent>

Thụt lề các nút trong AST (số lượng khoảng trắng).

--feature-version <version>

Phiên bản Python ở định dạng 3.x (ví dụ: 3.10). Mặc định là phiên bản hiện tại của trình thông dịch.

Added in version 3.14.

-O <level>

--optimize <level>

Mức độ tối ưu hóa cho trình phân tích cú pháp. Mặc định là không tối ưu hóa.

Added in version 3.14.

--show-empty

Hiển thị danh sách và trường trống None. Mặc định là không hiển thị các đối tượng trống.

Added in version 3.14.

Nếu infile được chỉ định, nội dung của nó sẽ được phân tích cú pháp thành AST và chuyển sang thiết bị xuất chuẩn. Nếu không, nội dung sẽ được đọc từ stdin.

Xem thêm

Green Tree Snakes, một nguồn tài liệu bên ngoài, có thông tin chi tiết hữu ích về cách làm việc với Python AST.

ASTTokens chú thích AST Python bằng vị trí của mã thông báo và văn bản trong mã nguồn đã tạo ra chúng. Điều này hữu ích cho các công cụ thực hiện chuyển đổi mã nguồn.

leoAst.py hợp nhất các chế độ xem dựa trên mã thông báo và dựa trên cây phân tích cú pháp của các chương trình python bằng cách chèn liên kết hai chiều giữa mã thông báo và nút ast.

LibCST phân tích mã dưới dạng Cây cú pháp cụ thể trông giống như cây ast và giữ tất cả chi tiết định dạng. Nó rất hữu ích cho việc xây dựng các ứng dụng và linters tái cấu trúc tự động (codemod).

Parso là trình phân tích cú pháp Python hỗ trợ phục hồi lỗi và phân tích cú pháp khứ hồi cho các phiên bản Python khác nhau (trong nhiều phiên bản Python). Parso cũng có thể liệt kê nhiều lỗi cú pháp trong tệp Python của bạn.