# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Rafael Fontenelle <[email protected]>, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-07-25 16:03+0000\n"

"PO-Revision-Date: 2025-07-18 19:57+0000\n"

"Last-Translator: Rafael Fontenelle <[email protected]>, 2025\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/ast.rst:2

msgid ":mod:`!ast` --- Abstract Syntax Trees"

msgstr ":mod:`!ast` --- 抽象语法树"

#: ../../library/ast.rst:14

msgid "**Source code:** :source:`Lib/ast.py`"

msgstr "**源代码：** :source:`Lib/ast.py`"

#: ../../library/ast.rst:18

msgid ""

"The :mod:`ast` module helps Python applications to process trees of the "

"Python abstract syntax grammar. The abstract syntax itself might change "

"with each Python release; this module helps to find out programmatically "

"what the current grammar looks like."

msgstr ""

":mod:`ast` 模块帮助 Python 程序处理 Python 语法的抽象语法树。抽象语法或许会随着 Python "

"的更新版发行而改变；该模块能够帮助理解当前语法在编程层面的样貌。"

#: ../../library/ast.rst:23

msgid ""

"An abstract syntax tree can be generated by passing "

":data:`ast.PyCF_ONLY_AST` as a flag to the :func:`compile` built-in "

"function, or using the :func:`parse` helper provided in this module. The "

"result will be a tree of objects whose classes all inherit from "

":class:`ast.AST`. An abstract syntax tree can be compiled into a Python "

"code object using the built-in :func:`compile` function."

msgstr ""

"抽象语法树可通过将 :data:`ast.PyCF_ONLY_AST` 作为旗标传递给 :func:`compile` "

"内置函数来生成，或是使用此模块中提供的 :func:`parse` 辅助函数。返回结果将是一个由许多对象构成的树，这些对象所属的类都继承自 "

":class:`ast.AST`。抽象语法树可被内置的 :func:`compile` 函数编译为一个 Python 代码对象。"

#: ../../library/ast.rst:33

msgid "Abstract Grammar"

msgstr "抽象文法"

#: ../../library/ast.rst:35

msgid "The abstract grammar is currently defined as follows:"

msgstr "抽象文法目前定义如下"

#: ../../library/ast.rst:37

msgid ""

"-- ASDL's 4 builtin types are:\n"

"-- identifier, int, string, constant\n"

"\n"

"module Python\n"

"{\n"

" mod = Module(stmt* body, type_ignore* type_ignores)\n"

" | Interactive(stmt* body)\n"

" | Expression(expr body)\n"

" | FunctionType(expr* argtypes, expr returns)\n"

"\n"

" stmt = FunctionDef(identifier name, arguments args,\n"

" stmt* body, expr* decorator_list, expr? returns,\n"

" string? type_comment, type_param* type_params)\n"

" | AsyncFunctionDef(identifier name, arguments args,\n"

" stmt* body, expr* decorator_list, expr? returns,\n"

" string? type_comment, type_param* type_params)\n"

"\n"

" | ClassDef(identifier name,\n"

" expr* bases,\n"

" keyword* keywords,\n"

" stmt* body,\n"

" expr* decorator_list,\n"

" type_param* type_params)\n"

" | Return(expr? value)\n"

"\n"

" | Delete(expr* targets)\n"

" | Assign(expr* targets, expr value, string? type_comment)\n"

" | TypeAlias(expr name, type_param* type_params, expr value)\n"

" | AugAssign(expr target, operator op, expr value)\n"

" -- 'simple' indicates that we annotate simple name without parens\n"

" | AnnAssign(expr target, expr annotation, expr? value, int simple)\n"

"\n"

" -- use 'orelse' because else is a keyword in target languages\n"

" | For(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"

" | AsyncFor(expr target, expr iter, stmt* body, stmt* orelse, string? type_comment)\n"

" | While(expr test, stmt* body, stmt* orelse)\n"

" | If(expr test, stmt* body, stmt* orelse)\n"

" | With(withitem* items, stmt* body, string? type_comment)\n"

" | AsyncWith(withitem* items, stmt* body, string? type_comment)\n"

"\n"

" | Match(expr subject, match_case* cases)\n"

"\n"

" | Raise(expr? exc, expr? cause)\n"

" | Try(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"

" | TryStar(stmt* body, excepthandler* handlers, stmt* orelse, stmt* finalbody)\n"

" | Assert(expr test, expr? msg)\n"

"\n"

" | Import(alias* names)\n"

" | ImportFrom(identifier? module, alias* names, int? level)\n"

"\n"

" | Global(identifier* names)\n"

" | Nonlocal(identifier* names)\n"

" | Expr(expr value)\n"

" | Pass | Break | Continue\n"

"\n"

" -- col_offset is the byte offset in the utf8 string the parser uses\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)\n"

"\n"

" -- BoolOp() can use left & right?\n"

" expr = BoolOp(boolop op, expr* values)\n"

" | NamedExpr(expr target, expr value)\n"

" | BinOp(expr left, operator op, expr right)\n"

" | UnaryOp(unaryop op, expr operand)\n"

" | Lambda(arguments args, expr body)\n"

" | IfExp(expr test, expr body, expr orelse)\n"

" | Dict(expr* keys, expr* values)\n"

" | Set(expr* elts)\n"

" | ListComp(expr elt, comprehension* generators)\n"

" | SetComp(expr elt, comprehension* generators)\n"

" | DictComp(expr key, expr value, comprehension* generators)\n"

" | GeneratorExp(expr elt, comprehension* generators)\n"

" -- the grammar constrains where yield expressions can occur\n"

" | Await(expr value)\n"

" | Yield(expr? value)\n"

" | YieldFrom(expr value)\n"

" -- need sequences for compare to distinguish between\n"

" -- x < 4 < 3 and (x < 4) < 3\n"

" | Compare(expr left, cmpop* ops, expr* comparators)\n"

" | Call(expr func, expr* args, keyword* keywords)\n"

" | FormattedValue(expr value, int conversion, expr? format_spec)\n"

" | JoinedStr(expr* values)\n"

" | Constant(constant value, string? kind)\n"

"\n"

" -- the following expression can appear in assignment context\n"

" | Attribute(expr value, identifier attr, expr_context ctx)\n"

" | Subscript(expr value, expr slice, expr_context ctx)\n"

" | Starred(expr value, expr_context ctx)\n"

" | Name(identifier id, expr_context ctx)\n"

" | List(expr* elts, expr_context ctx)\n"

" | Tuple(expr* elts, expr_context ctx)\n"

"\n"

" -- can appear only in Subscript\n"

" | Slice(expr? lower, expr? upper, expr? step)\n"

"\n"

" -- col_offset is the byte offset in the utf8 string the parser uses\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)\n"

"\n"

" expr_context = Load | Store | Del\n"

"\n"

" boolop = And | Or\n"

"\n"

" operator = Add | Sub | Mult | MatMult | Div | Mod | Pow | LShift\n"

" | RShift | BitOr | BitXor | BitAnd | FloorDiv\n"

"\n"

" unaryop = Invert | Not | UAdd | USub\n"

"\n"

" cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn\n"

"\n"

" comprehension = (expr target, expr iter, expr* ifs, int is_async)\n"

"\n"

" excepthandler = ExceptHandler(expr? type, identifier? name, stmt* body)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)\n"

"\n"

" arguments = (arg* posonlyargs, arg* args, arg? vararg, arg* kwonlyargs,\n"

" expr* kw_defaults, arg? kwarg, expr* defaults)\n"

"\n"

" arg = (identifier arg, expr? annotation, string? type_comment)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)\n"

"\n"

" -- keyword arguments supplied to call (NULL identifier for **kwargs)\n"

" keyword = (identifier? arg, expr value)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)\n"

"\n"

" -- import name with optional 'as' alias.\n"

" alias = (identifier name, identifier? asname)\n"

" attributes (int lineno, int col_offset, int? end_lineno, int? end_col_offset)\n"

"\n"

" withitem = (expr context_expr, expr? optional_vars)\n"

"\n"

" match_case = (pattern pattern, expr? guard, stmt* body)\n"

"\n"

" pattern = MatchValue(expr value)\n"

" | MatchSingleton(constant value)\n"

" | MatchSequence(pattern* patterns)\n"

" | MatchMapping(expr* keys, pattern* patterns, identifier? rest)\n"

" | MatchClass(expr cls, pattern* patterns, identifier* kwd_attrs, pattern* kwd_patterns)\n"

"\n"

" | MatchStar(identifier? name)\n"

" -- The optional \"rest\" MatchMapping parameter handles capturing extra mapping keys\n"

"\n"

" | MatchAs(pattern? pattern, identifier? name)\n"

" | MatchOr(pattern* patterns)\n"

"\n"

" attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)\n"

"\n"

" type_ignore = TypeIgnore(int lineno, string tag)\n"

"\n"

" type_param = TypeVar(identifier name, expr? bound)\n"

" | ParamSpec(identifier name)\n"

" | TypeVarTuple(identifier name)\n"

" attributes (int lineno, int col_offset, int end_lineno, int end_col_offset)\n"

"}\n"

msgstr ""

#: ../../library/ast.rst:42

msgid "Node classes"

msgstr "节点类"

#: ../../library/ast.rst:46

msgid ""

"This is the base of all AST node classes. The actual node classes are "

"derived from the :file:`Parser/Python.asdl` file, which is reproduced "

":ref:`above <abstract-grammar>`. They are defined in the :mod:`!_ast` C "

"module and re-exported in :mod:`ast`."

msgstr ""

"这是所有 AST 节点类的基类。 实际的节点类都派生自 :file:`Parser/Python.asdl` 文件，其完整内容 :ref:`如上所示 "

"<abstract-grammar>`。 它们 :mod:`!_ast` C 模块中定义并在 :mod:`ast` 中重新导出。"

#: ../../library/ast.rst:51

msgid ""

"There is one class defined for each left-hand side symbol in the abstract "

"grammar (for example, :class:`ast.stmt` or :class:`ast.expr`). In addition,"

" there is one class defined for each constructor on the right-hand side; "

"these classes inherit from the classes for the left-hand side trees. For "

"example, :class:`ast.BinOp` inherits from :class:`ast.expr`. For production"

" rules with alternatives (aka \"sums\"), the left-hand side class is "

"abstract: only instances of specific constructor nodes are ever created."

msgstr ""

"抽象文法中的每个等号左边的符号（比方说， :class:`ast.stmt` 或者 "

":class:`ast.expr`）定义了一个类。另外，在等号右边，对每一个构造器也定义了一个类；这些类继承自等号左边的类。比如，:class:`ast.BinOp`"

" 继承自 :class:`ast.expr`。对于多分支产生式（也就是含有“ | ”的产生式），左边的类是抽象的；只有具体构造器类的实例能够被 "

"compile 函数构造。"

#: ../../library/ast.rst:64

msgid ""

"Each concrete class has an attribute :attr:`_fields` which gives the names "

"of all child nodes."

msgstr "每个具体类都有属性 :attr:`_fields`，用来给出所有子节点的名字。"

#: ../../library/ast.rst:67

msgid ""

"Each instance of a concrete class has one attribute for each child node, of "

"the type as defined in the grammar. For example, :class:`ast.BinOp` "

"instances have an attribute :attr:`left` of type :class:`ast.expr`."

msgstr ""

"每个具体类的实例为自己的每个子节点都准备了一个属性来引用该子节点，属性的类型就是文法中所定义的。比如，:class:`ast.BinOp` "

"的实例有个属性 :attr:`left`，类型是 :class:`ast.expr`。"

#: ../../library/ast.rst:71

msgid ""

"If these attributes are marked as optional in the grammar (using a question "

"mark), the value might be ``None``. If the attributes can have zero-or-more"

" values (marked with an asterisk), the values are represented as Python "

"lists. All possible attributes must be present and have valid values when "

"compiling an AST with :func:`compile`."

msgstr ""

"如果这些属性在文法中标记为可选（用问号标记），对应值可能会是 "

"``None``。如果这些属性可有零或多个值（用星号标记），对应值会用Python的列表来表示。在用 :func:`compile` "

"将AST编译为可执行代码时，所有的属性必须已经被赋值为有效的值。"

#: ../../library/ast.rst:82

msgid ""

"Instances of :class:`ast.expr` and :class:`ast.stmt` subclasses have "

":attr:`lineno`, :attr:`col_offset`, :attr:`end_lineno`, and "

":attr:`end_col_offset` attributes. The :attr:`lineno` and "

":attr:`end_lineno` are the first and last line numbers of source text span "

"(1-indexed so the first line is line 1) and the :attr:`col_offset` and "

":attr:`end_col_offset` are the corresponding UTF-8 byte offsets of the first"

" and last tokens that generated the node. The UTF-8 offset is recorded "

"because the parser uses UTF-8 internally."

msgstr ""

":class:`ast.expr` 和 :class:`ast.stmt` 的子类的实例的属性包括 "

":attr:`lineno`、:attr:`col_offset`、:attr:`end_lineno` 和 "

":attr:`end_col_offset`。:attr:`lineno` 和 :attr:`end_lineno` "

"是源码中属于该节点的部分从哪一行开始，到哪一行结束（数字 1 指第一行，以此类推）；:attr:`col_offset` 和 "

":attr:`end_col_offset` 是第一个和最后一个属于该节点的 token 的 UTF-8 字节偏移量。记录 UTF-8 "

"偏移量的原因是解析器内部使用 UTF-8。"

#: ../../library/ast.rst:91

msgid ""

"Note that the end positions are not required by the compiler and are "

"therefore optional. The end offset is *after* the last symbol, for example "

"one can get the source segment of a one-line expression node using "

"``source_line[node.col_offset : node.end_col_offset]``."

msgstr ""

"注意编译器不需要结束位置，所以结束位置是可选的。结束偏移在最后一个符号 *之后* ，例如你可以通过 "

"``source_line[node.col_offset : node.end_col_offset]`` 获得一个单行表达式节点的源码片段。"

#: ../../library/ast.rst:96

msgid ""

"The constructor of a class :class:`ast.T` parses its arguments as follows:"

msgstr ":class:`ast.T` 类的构造器像下面这样解析它的参数："

#: ../../library/ast.rst:98

msgid ""

"If there are positional arguments, there must be as many as there are items "

"in :attr:`T._fields`; they will be assigned as attributes of these names."

msgstr "如果只用位置参数，参数的数量必须和 :attr:`T._fields` 中的项一样多；它们会按顺序赋值到这些属性上。"

#: ../../library/ast.rst:100

msgid ""

"If there are keyword arguments, they will set the attributes of the same "

"names to the given values."

msgstr "如果有关键字参数，它们会为与其关键字同名的属性赋值。"

#: ../../library/ast.rst:103

msgid ""

"For example, to create and populate an :class:`ast.UnaryOp` node, you could "

"use ::"

msgstr "比方说，要创建和填充节点 :class:`ast.UnaryOp`，你得用 ::"

#: ../../library/ast.rst:106

msgid ""

"node = ast.UnaryOp()\n"

"node.op = ast.USub()\n"

"node.operand = ast.Constant()\n"

"node.operand.value = 5\n"

"node.operand.lineno = 0\n"

"node.operand.col_offset = 0\n"

"node.lineno = 0\n"

"node.col_offset = 0"

msgstr ""

#: ../../library/ast.rst:115

msgid "or the more compact ::"

msgstr "或者更紧凑点 ::"

#: ../../library/ast.rst:117

msgid ""

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

" lineno=0, col_offset=0)"

msgstr ""

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

" lineno=0, col_offset=0)"

#: ../../library/ast.rst:122

msgid "Class :class:`ast.Constant` is now used for all constants."

msgstr ":class:`ast.Constant` 类现在用于所有常量。"

#: ../../library/ast.rst:126

msgid ""

"Simple indices are represented by their value, extended slices are "

"represented as tuples."

msgstr "简单索引由它们的值表示，扩展切片表示为元组。"

#: ../../library/ast.rst:131

msgid ""

"Old classes :class:`!ast.Num`, :class:`!ast.Str`, :class:`!ast.Bytes`, "

":class:`!ast.NameConstant` and :class:`!ast.Ellipsis` are still available, "

"but they will be removed in future Python releases. In the meantime, "

"instantiating them will return an instance of a different class."

msgstr ""

"原有的类 :class:`!ast.Num`, :class:`!ast.Str`, :class:`!ast.Bytes`, "

":class:`!ast.NameConstant` 和 :class:`!ast.Ellipsis` 仍然可用，但它们将在未来的 Python "

"发布版中被移除。 同时，实例化它们将返回其他某个类的实例。"

#: ../../library/ast.rst:138

msgid ""

"Old classes :class:`!ast.Index` and :class:`!ast.ExtSlice` are still "

"available, but they will be removed in future Python releases. In the "

"meantime, instantiating them will return an instance of a different class."

msgstr ""

"原有的类 :class:`!ast.Index` and :class:`!ast.ExtSlice` 仍然可用，但它们将在未来的 Python "

"发布版中被移除。 同时，实例化它们将返回其他某个类的实例。"

#: ../../library/ast.rst:144

msgid ""

"The descriptions of the specific node classes displayed here were initially "

"adapted from the fantastic `Green Tree Snakes "

"<https://greentreesnakes.readthedocs.io/en/latest/>`__ project and all its "

"contributors."

msgstr ""

"在此显示的特定节点类的描述最初是改编自杰出的 `Green Tree Snakes "

"<https://greentreesnakes.readthedocs.io/en/latest/>`__ 项目及其所有贡献者。"

#: ../../library/ast.rst:153

msgid "Root nodes"

msgstr "根节点"

#: ../../library/ast.rst:157

msgid ""

"A Python module, as with :ref:`file input <file-input>`. Node type generated"

" by :func:`ast.parse` in the default ``\"exec\"`` *mode*."

msgstr ""

"一个 Python 模块，用于 :ref:`文件输入 <file-input>`。 由 :func:`ast.parse` 以默认 "

"``\"exec\"`` *mode* 生成的节点类型。"

#: ../../library/ast.rst:160

msgid "``body`` is a :class:`list` of the module's :ref:`ast-statements`."

msgstr "``body`` 是由该模块的 :ref:`ast-statements` 组成的 :class:`list`。"

#: ../../library/ast.rst:162

msgid ""

"``type_ignores`` is a :class:`list` of the module's type ignore comments; "

"see :func:`ast.parse` for more details."

msgstr ""

"``type_ignores`` 是由该模块的类型忽略注释组成的 :class:`list`；请参阅 :func:`ast.parse` 了解详情。"

#: ../../library/ast.rst:165

msgid ""

">>> print(ast.dump(ast.parse('x = 1'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='x', ctx=Store())],\n"

" value=Constant(value=1))],\n"

" type_ignores=[])"

msgstr ""

#: ../../library/ast.rst:179

msgid ""

"A single Python :ref:`expression input <expression-input>`. Node type "

"generated by :func:`ast.parse` when *mode* is ``\"eval\"``."

msgstr ""

"单个 Python :ref:`表达式输入 <expression-input>`。 当 *mode* 为 ``\"eval\"`` 时由 "

":func:`ast.parse` 所生成的节点类型。"

#: ../../library/ast.rst:182

msgid ""

"``body`` is a single node, one of the :ref:`expression types <ast-"

"expressions>`."

msgstr "``body`` 为单独节点，是某一个 :ref:`表达式类型 <ast-expressions>`。"

#: ../../library/ast.rst:185 ../../library/ast.rst:255

msgid ""

">>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Constant(value=123))"

msgstr ""

">>> print(ast.dump(ast.parse('123', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Constant(value=123))"

#: ../../library/ast.rst:194

msgid ""

"A single :ref:`interactive input <interactive>`, like in :ref:`tut-interac`."

" Node type generated by :func:`ast.parse` when *mode* is ``\"single\"``."

msgstr ""

"单个 :ref:`交互式输入 <interactive>`，就像在 :ref:`tut-interac` 中一样。 当 *mode* 为 "

"``\"single\"`` 时由 :func:`ast.parse` 所生成的节点类型。"

#: ../../library/ast.rst:197

msgid ""

"``body`` is a :class:`list` of :ref:`statement nodes <ast-statements>`."

msgstr "``body`` 是由 :ref:`语句节点 <ast-statements>` 组成的 :class:`list`。"

#: ../../library/ast.rst:199

msgid ""

">>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))\n"

"Interactive(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='x', ctx=Store())],\n"

" value=Constant(value=1)),\n"

" Assign(\n"

" targets=[\n"

" Name(id='y', ctx=Store())],\n"

" value=Constant(value=2))])"

msgstr ""

">>> print(ast.dump(ast.parse('x = 1; y = 2', mode='single'), indent=4))\n"

"Interactive(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='x', ctx=Store())],\n"

" value=Constant(value=1)),\n"

" Assign(\n"

" targets=[\n"

" Name(id='y', ctx=Store())],\n"

" value=Constant(value=2))])"

#: ../../library/ast.rst:216

msgid ""

"A representation of an old-style type comments for functions, as Python "

"versions prior to 3.5 didn't support :pep:`484` annotations. Node type "

"generated by :func:`ast.parse` when *mode* is ``\"func_type\"``."

msgstr ""

"函数的旧风格类型注释表示形式，因为 Python 3.5 之前的版本不支持 :pep:`484` 标注。 当 *mode* 为 "

"``\"func_type\"`` 时由 :func:`ast.parse` 所生成的节点类型。"

#: ../../library/ast.rst:220

msgid "Such type comments would look like this::"

msgstr "此种类型注释的形式是这样的::"

#: ../../library/ast.rst:222

msgid ""

"def sum_two_number(a, b):\n"

" # type: (int, int) -> int\n"

" return a + b"

msgstr ""

"def sum_two_number(a, b):\n"

" # type: (int, int) -> int\n"

" return a + b"

#: ../../library/ast.rst:226

msgid ""

"``argtypes`` is a :class:`list` of :ref:`expression nodes <ast-"

"expressions>`."

msgstr "``argtypes`` 是由 :ref:`表达式节点 <ast-expressions>` 组成的 :class:`list`。"

#: ../../library/ast.rst:228

msgid "``returns`` is a single :ref:`expression node <ast-expressions>`."

msgstr "``returns`` 是单独的 :ref:`表达式节点 <ast-expressions>`。"

#: ../../library/ast.rst:230

msgid ""

">>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))\n"

"FunctionType(\n"

" argtypes=[\n"

" Name(id='int', ctx=Load()),\n"

" Name(id='str', ctx=Load())],\n"

" returns=Subscript(\n"

" value=Name(id='List', ctx=Load()),\n"

" slice=Name(id='int', ctx=Load()),\n"

" ctx=Load()))"

msgstr ""

">>> print(ast.dump(ast.parse('(int, str) -> List[int]', mode='func_type'), indent=4))\n"

"FunctionType(\n"

" argtypes=[\n"

" Name(id='int', ctx=Load()),\n"

" Name(id='str', ctx=Load())],\n"

" returns=Subscript(\n"

" value=Name(id='List', ctx=Load()),\n"

" slice=Name(id='int', ctx=Load()),\n"

" ctx=Load()))"

#: ../../library/ast.rst:246

msgid "Literals"

msgstr "字面值"

#: ../../library/ast.rst:250

msgid ""

"A constant value. The ``value`` attribute of the ``Constant`` literal "

"contains the Python object it represents. The values represented can be "

"simple types such as a number, string or ``None``, but also immutable "

"container types (tuples and frozensets) if all of their elements are "

"constant."

msgstr ""

"一个常量。 ``Constant`` 字面值的 ``value`` 属性即为其代表的 Python 对象。它可以代表简单的数字，字符串或者 "

"``None`` 对象，但是也可以代表所有元素都是常量的不可变容器（例如元组或冻结集合）。"

#: ../../library/ast.rst:264

msgid ""

"Node representing a single formatting field in an f-string. If the string "

"contains a single formatting field and nothing else the node can be isolated"

" otherwise it appears in :class:`JoinedStr`."

msgstr ""

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

":class:`JoinedStr` 中出现。"

#: ../../library/ast.rst:268

msgid ""

"``value`` is any expression node (such as a literal, a variable, or a "

"function call)."

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

#: ../../library/ast.rst:270

msgid "``conversion`` is an integer:"

msgstr "``conversion`` 是一个整数:"

#: ../../library/ast.rst:272

msgid "-1: no formatting"

msgstr "-1: 无格式化"

#: ../../library/ast.rst:273

msgid "115: ``!s`` string formatting"

msgstr "115: ``!s`` 字符串格式化"

#: ../../library/ast.rst:274

msgid "114: ``!r`` repr formatting"

msgstr "114: ``!r`` repr 格式化"

#: ../../library/ast.rst:275

msgid "97: ``!a`` ascii formatting"

msgstr "97: ``!a`` ascii 格式化"

#: ../../library/ast.rst:277

msgid ""

"``format_spec`` is a :class:`JoinedStr` node representing the formatting of "

"the value, or ``None`` if no format was specified. Both ``conversion`` and "

"``format_spec`` can be set at the same time."

msgstr ""

"``format_spec`` 是一个代表值的格式化的 :class:`JoinedStr` 节点，或者如果未指定格式则为 ``None``。 "

"``conversion`` 和 ``format_spec`` 可以被同时设置。"

#: ../../library/ast.rst:284

msgid ""

"An f-string, comprising a series of :class:`FormattedValue` and "

":class:`Constant` nodes."

msgstr "一个 f-字符串，由一系列 :class:`FormattedValue` 和 :class:`Constant` 节点组成。"

#: ../../library/ast.rst:287

msgid ""

">>> print(ast.dump(ast.parse('f\"sin({a}) is {sin(a):.3}\"', mode='eval'), indent=4))\n"

"Expression(\n"

" body=JoinedStr(\n"

" values=[\n"

" Constant(value='sin('),\n"

" FormattedValue(\n"

" value=Name(id='a', ctx=Load()),\n"

" conversion=-1),\n"

" Constant(value=') is '),\n"

" FormattedValue(\n"

" value=Call(\n"

" func=Name(id='sin', ctx=Load()),\n"

" args=[\n"

" Name(id='a', ctx=Load())],\n"

" keywords=[]),\n"

" conversion=-1,\n"

" format_spec=JoinedStr(\n"

" values=[\n"

" Constant(value='.3')]))]))"

msgstr ""

#: ../../library/ast.rst:313

msgid ""

"A list or tuple. ``elts`` holds a list of nodes representing the elements. "

"``ctx`` is :class:`Store` if the container is an assignment target (i.e. "

"``(x,y)=something``), and :class:`Load` otherwise."

msgstr ""

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

" 是 :class:`Store`，否则是 :class:`Load`。"

#: ../../library/ast.rst:317

msgid ""

">>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))\n"

"Expression(\n"

" body=List(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)],\n"

" ctx=Load()))\n"

">>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Tuple(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)],\n"

" ctx=Load()))"

msgstr ""

">>> print(ast.dump(ast.parse('[1, 2, 3]', mode='eval'), indent=4))\n"

"Expression(\n"

" body=List(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)],\n"

" ctx=Load()))\n"

">>> print(ast.dump(ast.parse('(1, 2, 3)', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Tuple(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)],\n"

" ctx=Load()))"

#: ../../library/ast.rst:339

msgid "A set. ``elts`` holds a list of nodes representing the set's elements."

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

#: ../../library/ast.rst:341

msgid ""

">>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Set(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)]))"

msgstr ""

">>> print(ast.dump(ast.parse('{1, 2, 3}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Set(\n"

" elts=[\n"

" Constant(value=1),\n"

" Constant(value=2),\n"

" Constant(value=3)]))"

#: ../../library/ast.rst:354

msgid ""

"A dictionary. ``keys`` and ``values`` hold lists of nodes representing the "

"keys and the values respectively, in matching order (what would be returned "

"when calling :code:`dictionary.keys()` and :code:`dictionary.values()`)."

msgstr ""

"一个字典。 ``keys`` 和 ``values`` 保存分别代表键和值的节点的列表，按照匹配的顺序（即当调用 "

":code:`dictionary.keys()` 和 :code:`dictionary.values()` 时将返回的结果）。"

#: ../../library/ast.rst:358

msgid ""

"When doing dictionary unpacking using dictionary literals the expression to "

"be expanded goes in the ``values`` list, with a ``None`` at the "

"corresponding position in ``keys``."

msgstr ""

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

#: ../../library/ast.rst:362

msgid ""

">>> print(ast.dump(ast.parse('{\"a\":1, **d}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Dict(\n"

" keys=[\n"

" Constant(value='a'),\n"

" None],\n"

" values=[\n"

" Constant(value=1),\n"

" Name(id='d', ctx=Load())]))"

msgstr ""

">>> print(ast.dump(ast.parse('{\"a\":1, **d}', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Dict(\n"

" keys=[\n"

" Constant(value='a'),\n"

" None],\n"

" values=[\n"

" Constant(value=1),\n"

" Name(id='d', ctx=Load())]))"

#: ../../library/ast.rst:376

msgid "Variables"

msgstr "变量"

#: ../../library/ast.rst:380

msgid ""

"A variable name. ``id`` holds the name as a string, and ``ctx`` is one of "

"the following types."

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

#: ../../library/ast.rst:388

msgid ""

"Variable references can be used to load the value of a variable, to assign a"

" new value to it, or to delete it. Variable references are given a context "

"to distinguish these cases."

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

#: ../../library/ast.rst:392

msgid ""

">>> print(ast.dump(ast.parse('a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Expr(\n"

" value=Name(id='a', ctx=Load()))],\n"

" type_ignores=[])\n"

"\n"

">>> print(ast.dump(ast.parse('a = 1'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Name(id='a', ctx=Store())],\n"

" value=Constant(value=1))],\n"

" type_ignores=[])\n"

"\n"

">>> print(ast.dump(ast.parse('del a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Delete(\n"

" targets=[\n"

" Name(id='a', ctx=Del())])],\n"

" type_ignores=[])"

msgstr ""

#: ../../library/ast.rst:421

msgid ""

"A ``*var`` variable reference. ``value`` holds the variable, typically a "

":class:`Name` node. This type must be used when building a :class:`Call` "

"node with ``*args``."

msgstr ""

"一个 ``*var`` 变量引用。 ``value`` 保存变量，通常为一个 :class:`Name` 节点。 此类型必须在构建 "

":class:`Call` 节点并传入 ``*args`` 时被使用。"

#: ../../library/ast.rst:425

msgid ""

">>> print(ast.dump(ast.parse('a, *b = it'), indent=4))\n"

"Module(\n"

" body=[\n"

" Assign(\n"

" targets=[\n"

" Tuple(\n"

" elts=[\n"

" Name(id='a', ctx=Store()),\n"

" Starred(\n"

" value=Name(id='b', ctx=Store()),\n"

" ctx=Store())],\n"

" ctx=Store())],\n"

" value=Name(id='it', ctx=Load()))],\n"

" type_ignores=[])"

msgstr ""

#: ../../library/ast.rst:446

msgid "Expressions"

msgstr "表达式"

#: ../../library/ast.rst:450

msgid ""

"When an expression, such as a function call, appears as a statement by "

"itself with its return value not used or stored, it is wrapped in this "

"container. ``value`` holds one of the other nodes in this section, a "

":class:`Constant`, a :class:`Name`, a :class:`Lambda`, a :class:`Yield` or "

":class:`YieldFrom` node."

msgstr ""

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

" :class:`Constant`, :class:`Name`, :class:`Lambda`, :class:`Yield` 或者 "

":class:`YieldFrom` 节点。"

#: ../../library/ast.rst:455

msgid ""

">>> print(ast.dump(ast.parse('-a'), indent=4))\n"

"Module(\n"

" body=[\n"

" Expr(\n"

" value=UnaryOp(\n"

" op=USub(),\n"

" operand=Name(id='a', ctx=Load())))],\n"

" type_ignores=[])"

msgstr ""

#: ../../library/ast.rst:469

msgid ""

"A unary operation. ``op`` is the operator, and ``operand`` any expression "

"node."

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

#: ../../library/ast.rst:478

msgid ""

"Unary operator tokens. :class:`Not` is the ``not`` keyword, :class:`Invert` "

"is the ``~`` operator."

msgstr "单目运算符对应的形符。 :class:`Not` 是 ``not`` 关键字，:class:`Invert` 是 ``~`` 运算符。"

#: ../../library/ast.rst:481

msgid ""

">>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))\n"

"Expression(\n"

" body=UnaryOp(\n"

" op=Not(),\n"

" operand=Name(id='x', ctx=Load())))"

msgstr ""

">>> print(ast.dump(ast.parse('not x', mode='eval'), indent=4))\n"

"Expression(\n"

" body=UnaryOp(\n"

" op=Not(),\n"

" operand=Name(id='x', ctx=Load())))"

#: ../../library/ast.rst:492

msgid ""

"A binary operation (like addition or division). ``op`` is the operator, and "

"``left`` and ``right`` are any expression nodes."

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

#: ../../library/ast.rst:495

msgid ""

">>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BinOp(\n"

" left=Name(id='x', ctx=Load()),\n"

" op=Add(),\n"

" right=Name(id='y', ctx=Load())))"

msgstr ""

">>> print(ast.dump(ast.parse('x + y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BinOp(\n"

" left=Name(id='x', ctx=Load()),\n"

" op=Add(),\n"

" right=Name(id='y', ctx=Load())))"

#: ../../library/ast.rst:519

msgid "Binary operator tokens."

msgstr "双目运算符对应的形符。"

#: ../../library/ast.rst:524

msgid ""

"A boolean operation, 'or' or 'and'. ``op`` is :class:`Or` or :class:`And`. "

"``values`` are the values involved. Consecutive operations with the same "

"operator, such as ``a or b or c``, are collapsed into one node with several "

"values."

msgstr ""

"一个布尔运算，'or' 或者 'and'。 ``op`` 是 :class:`Or` 或者 :class:`And`。 ``values`` "

"是参与运算的值。 具有相同运算符的连续运算，如 ``a or b or c``，会被折叠为具有多个值的单个节点。"

#: ../../library/ast.rst:529

msgid "This doesn't include ``not``, which is a :class:`UnaryOp`."

msgstr "这不包括 ``not``，它属于 :class:`UnaryOp`。"

#: ../../library/ast.rst:531

msgid ""

">>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BoolOp(\n"

" op=Or(),\n"

" values=[\n"

" Name(id='x', ctx=Load()),\n"

" Name(id='y', ctx=Load())]))"

msgstr ""

">>> print(ast.dump(ast.parse('x or y', mode='eval'), indent=4))\n"

"Expression(\n"

" body=BoolOp(\n"

" op=Or(),\n"

" values=[\n"

" Name(id='x', ctx=Load()),\n"

" Name(id='y', ctx=Load())]))"

#: ../../library/ast.rst:545

msgid "Boolean operator tokens."

msgstr "布尔运算符对应的形符。"

#: ../../library/ast.rst:550

msgid ""

"A comparison of two or more values. ``left`` is the first value in the "

"comparison, ``ops`` the list of operators, and ``comparators`` the list of "

"values after the first element in the comparison."

msgstr ""

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

"是由参加比较的第一个元素之后的值组成的列表。"

#: ../../library/ast.rst:554

msgid ""

">>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Compare(\n"

" left=Constant(value=1),\n"

" ops=[\n"

" LtE(),\n"

" Lt()],\n"

" comparators=[\n"

" Name(id='a', ctx=Load()),\n"

" Constant(value=10)]))"

msgstr ""

">>> print(ast.dump(ast.parse('1 <= a < 10', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Compare(\n"

" left=Constant(value=1),\n"

" ops=[\n"

" LtE(),\n"

" Lt()],\n"

" comparators=[\n"

" Name(id='a', ctx=Load()),\n"

" Constant(value=10)]))"

#: ../../library/ast.rst:579

msgid "Comparison operator tokens."

msgstr "比较运算符对应的形符。"

#: ../../library/ast.rst:584

msgid ""

"A function call. ``func`` is the function, which will often be a "

":class:`Name` or :class:`Attribute` object. Of the arguments:"

msgstr ""

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

#: ../../library/ast.rst:587

msgid "``args`` holds a list of the arguments passed by position."

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

#: ../../library/ast.rst:588

msgid ""

"``keywords`` holds a list of :class:`.keyword` objects representing "

"arguments passed by keyword."

msgstr "``keywords`` 保存了一个代表以关键字传入的参数的 :class:`.keyword` 对象的列表。"

#: ../../library/ast.rst:591

msgid ""

"When creating a ``Call`` node, ``args`` and ``keywords`` are required, but "

"they can be empty lists."

msgstr "当创建 ``Call`` 节点时，需要有 ``args`` 和 ``keywords``，但它们可以为空列表。"

#: ../../library/ast.rst:594

msgid ""

">>> print(ast.dump(ast.parse('func(a, b=c, *d, **e)', mode='eval'), indent=4))\n"

"Expression(\n"

" body=Call(\n"

" func=Name(id='func', ctx=Load()),\n"

" args=[\n"

" Name(id='a', ctx=Load()),\n"

" Starred(\n"

" value=Name(id='d', ctx=Load()),\n"

" ctx=Load())],\n"

" keywords=[\n"

" keyword(\n"

" arg='b',\n"

" value=Name(id='c', ctx=Load())),\n"

" keyword(\n"

" value=Name(id='e', ctx=Load()))]))"