# 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:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-01-03 16:35+0000\n"

"PO-Revision-Date: 2025-09-22 17:54+0000\n"

"Last-Translator: python-doc bot, 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/dis.rst:2

msgid ":mod:`dis` --- Disassembler for Python bytecode"

msgstr ":mod:`dis` --- Python 字节码反汇编器"

#: ../../library/dis.rst:7

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

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

#: ../../library/dis.rst:11

msgid ""

"The :mod:`dis` module supports the analysis of CPython :term:`bytecode` by "

"disassembling it. The CPython bytecode which this module takes as an input "

"is defined in the file :file:`Include/opcode.h` and used by the compiler and"

" the interpreter."

msgstr ""

":mod:`dis` 模块通过反汇编支持CPython的 :term:`bytecode` 分析。该模块作为输入的 CPython 字节码在文件 "

":file:`Include/opcode.h` 中定义，并由编译器和解释器使用。"

#: ../../library/dis.rst:18

msgid ""

"Bytecode is an implementation detail of the CPython interpreter. No "

"guarantees are made that bytecode will not be added, removed, or changed "

"between versions of Python. Use of this module should not be considered to "

"work across Python VMs or Python releases."

msgstr ""

"字节码是 CPython 解释器的实现细节。不保证不会在Python版本之间添加、删除或更改字节码。不应考虑将此模块的跨 Python VM 或 "

"Python 版本的使用。"

#: ../../library/dis.rst:23

msgid ""

"Use 2 bytes for each instruction. Previously the number of bytes varied by "

"instruction."

msgstr "每条指令使用2个字节。以前字节数因指令而异。"

#: ../../library/dis.rst:28

msgid "Example: Given the function :func:`myfunc`::"

msgstr "示例：给出函数 :func:`myfunc`::"

#: ../../library/dis.rst:33

msgid ""

"the following command can be used to display the disassembly of "

":func:`myfunc`::"

msgstr "可以使用以下命令显示 :func:`myfunc` 的反汇编 ::"

#: ../../library/dis.rst:42

msgid "(The \"2\" is a line number)."

msgstr "(\"2\" 是行号)。"

#: ../../library/dis.rst:45

msgid "Bytecode analysis"

msgstr "字节码分析"

#: ../../library/dis.rst:49

msgid ""

"The bytecode analysis API allows pieces of Python code to be wrapped in a "

":class:`Bytecode` object that provides easy access to details of the "

"compiled code."

msgstr "字节码分析 API 允许将 Python 代码片段包装在 :class:`Bytecode` 对象中，以便轻松访问已编译代码的详细信息。"

#: ../../library/dis.rst:56

msgid ""

"Analyse the bytecode corresponding to a function, generator, asynchronous "

"generator, coroutine, method, string of source code, or a code object (as "

"returned by :func:`compile`)."

msgstr "分析的字节码对应于函数、生成器、异步生成器、协程、方法、源代码字符串或代码对象（由 :func:`compile` 返回）。"

#: ../../library/dis.rst:60

msgid ""

"This is a convenience wrapper around many of the functions listed below, "

"most notably :func:`get_instructions`, as iterating over a :class:`Bytecode`"

" instance yields the bytecode operations as :class:`Instruction` instances."

msgstr ""

"这是下面列出的许多函数的便利包装，最值得注意的是 :func:`get_instructions` ，迭代于 :class:`Bytecode` "

"的实例产生字节码操作 :class:`Instruction` 的实例。"

#: ../../library/dis.rst:64 ../../library/dis.rst:225

msgid ""

"If *first_line* is not ``None``, it indicates the line number that should be"

" reported for the first source line in the disassembled code. Otherwise, "

"the source line information (if any) is taken directly from the disassembled"

" code object."

msgstr ""

"如果 *first_line* 不是 ``None`` "

"，则表示应该为反汇编代码中的第一个源代码行报告的行号。否则，源行信息（如果有的话）直接来自反汇编的代码对象。"

#: ../../library/dis.rst:69

msgid ""

"If *current_offset* is not ``None``, it refers to an instruction offset in "

"the disassembled code. Setting this means :meth:`.dis` will display a "

"\"current instruction\" marker against the specified opcode."

msgstr ""

"如果 *current_offset* 不是 ``None`` ，它指的就是汇编代码中的指令偏移量。设置它意味着 :meth:`.dis` "

"将针对指定的操作码显示“当前指令”标记。"

#: ../../library/dis.rst:75

msgid ""

"Construct a :class:`Bytecode` instance from the given traceback, setting "

"*current_offset* to the instruction responsible for the exception."

msgstr "从给定回溯构造一个 :class:`Bytecode` 实例，将设置 *current_offset* 为异常负责的指令。"

#: ../../library/dis.rst:80

msgid "The compiled code object."

msgstr "已编译的代码对象。"

#: ../../library/dis.rst:84

msgid "The first source line of the code object (if available)"

msgstr "代码对象的第一个源代码行（如果可用）"

#: ../../library/dis.rst:88

msgid ""

"Return a formatted view of the bytecode operations (the same as printed by "

":func:`dis.dis`, but returned as a multi-line string)."

msgstr "返回字节码操作的格式化视图（与 :func:`dis.dis` 打印相同，但作为多行字符串返回）。"

#: ../../library/dis.rst:93

msgid ""

"Return a formatted multi-line string with detailed information about the "

"code object, like :func:`code_info`."

msgstr "返回带有关于代码对象的详细信息的格式化多行字符串，如 :func:`code_info` 。"

#: ../../library/dis.rst:96 ../../library/dis.rst:130

#: ../../library/dis.rst:176

msgid "This can now handle coroutine and asynchronous generator objects."

msgstr "现在可以处理协程和异步生成器对象。"

#: ../../library/dis.rst:99

msgid "Example::"

msgstr "示例::"

#: ../../library/dis.rst:112

msgid "Analysis functions"

msgstr "分析函数"

#: ../../library/dis.rst:114

msgid ""

"The :mod:`dis` module also defines the following analysis functions that "

"convert the input directly to the desired output. They can be useful if only"

" a single operation is being performed, so the intermediate analysis object "

"isn't useful:"

msgstr ":mod:`dis` 模块还定义了以下分析函数，它们将输入直接转换为所需的输出。如果只执行单个操作，它们可能很有用，因此中间分析对象没用："

#: ../../library/dis.rst:120

msgid ""

"Return a formatted multi-line string with detailed code object information "

"for the supplied function, generator, asynchronous generator, coroutine, "

"method, source code string or code object."

msgstr "返回格式化的多行字符串，其包含详细代码对象信息的用于被提供的函数、生成器、异步生成器、协程、方法、源代码字符串或代码对象。"

#: ../../library/dis.rst:124

msgid ""

"Note that the exact contents of code info strings are highly implementation "

"dependent and they may change arbitrarily across Python VMs or Python "

"releases."

msgstr "请注意，代码信息字符串的确切内容是高度依赖于实现的，它们可能会在Python VM或Python版本中任意更改。"

#: ../../library/dis.rst:136

msgid ""

"Print detailed code object information for the supplied function, method, "

"source code string or code object to *file* (or ``sys.stdout`` if *file* is "

"not specified)."

msgstr ""

"将提供的函数、方法。源代码字符串或代码对象的详细代码对象信息打印到 *file* （如果未指定 *file* ，则为 ``sys.stdout`` ）。"

#: ../../library/dis.rst:140

msgid ""

"This is a convenient shorthand for ``print(code_info(x), file=file)``, "

"intended for interactive exploration at the interpreter prompt."

msgstr "这是 ``print(code_info(x), file=file)`` 的便捷简写，用于在解释器提示符下进行交互式探索。"

#: ../../library/dis.rst:145 ../../library/dis.rst:170

#: ../../library/dis.rst:189 ../../library/dis.rst:213

msgid "Added *file* parameter."

msgstr "添加 *file* 形参。"

#: ../../library/dis.rst:151

msgid ""

"Disassemble the *x* object. *x* can denote either a module, a class, a "

"method, a function, a generator, an asynchronous generator, a coroutine, a "

"code object, a string of source code or a byte sequence of raw bytecode. For"

" a module, it disassembles all functions. For a class, it disassembles all "

"methods (including class and static methods). For a code object or sequence "

"of raw bytecode, it prints one line per bytecode instruction. It also "

"recursively disassembles nested code objects (the code of comprehensions, "

"generator expressions and nested functions, and the code used for building "

"nested classes). Strings are first compiled to code objects with the "

":func:`compile` built-in function before being disassembled. If no object "

"is provided, this function disassembles the last traceback."

msgstr ""

"反汇编 *x* 对象。 *x* "

"可以表示模块、类、方法、函数、生成器、异步生成器、协程、代码对象、源代码字符串或原始字节码的字节序列。对于模块，它会反汇编所有功能。对于一个类，它反汇编所有方法（包括类和静态方法）。对于代码对象或原始字节码序列，它每字节码指令打印一行。它还递归地反汇编嵌套代码对象（推导式代码，生成器表达式和嵌套函数，以及用于构建嵌套类的代码）。在被反汇编之前，首先使用"

" :func:`compile` 内置函数将字符串编译为代码对象。如果未提供任何对象，则此函数会反汇编最后一次回溯。"

#: ../../library/dis.rst:164 ../../library/dis.rst:186

#: ../../library/dis.rst:210

msgid ""

"The disassembly is written as text to the supplied *file* argument if "

"provided and to ``sys.stdout`` otherwise."

msgstr "如果提供的话，反汇编将作为文本写入提供的 *file* 参数，否则写入 ``sys.stdout`` 。"

#: ../../library/dis.rst:167

msgid ""

"The maximal depth of recursion is limited by *depth* unless it is ``None``. "

"``depth=0`` means no recursion."

msgstr "递归的最大深度受 *depth* 限制，除非它是 ``None`` 。 ``depth=0`` 表示没有递归。"

#: ../../library/dis.rst:173

msgid "Implemented recursive disassembling and added *depth* parameter."

msgstr "实现了递归反汇编并添加了 *depth* 参数。"

#: ../../library/dis.rst:182

msgid ""

"Disassemble the top-of-stack function of a traceback, using the last "

"traceback if none was passed. The instruction causing the exception is "

"indicated."

msgstr "如果没有传递，则使用最后一个回溯来反汇编回溯的堆栈顶部函数。 指示了导致异常的指令。"

#: ../../library/dis.rst:196

msgid ""

"Disassemble a code object, indicating the last instruction if *lasti* was "

"provided. The output is divided in the following columns:"

msgstr "反汇编代码对象，如果提供了 *lasti* ，则指示最后一条指令。输出分为以下几列："

#: ../../library/dis.rst:199

msgid "the line number, for the first instruction of each line"

msgstr "行号，用于每行的第一条指令"

#: ../../library/dis.rst:200

msgid "the current instruction, indicated as ``-->``,"

msgstr "当前指令，表示为 ``-->`` ，"

#: ../../library/dis.rst:201

msgid "a labelled instruction, indicated with ``>>``,"

msgstr "一个标记的指令，用 ``>>`` 表示，"

#: ../../library/dis.rst:202

msgid "the address of the instruction,"

msgstr "指令的地址，"

#: ../../library/dis.rst:203

msgid "the operation code name,"

msgstr "操作码名称，"

#: ../../library/dis.rst:204

msgid "operation parameters, and"

msgstr "操作参数，和"

#: ../../library/dis.rst:205

msgid "interpretation of the parameters in parentheses."

msgstr "括号中参数的解释。"

#: ../../library/dis.rst:207

msgid ""

"The parameter interpretation recognizes local and global variable names, "

"constant values, branch targets, and compare operators."

msgstr "参数解释识别本地和全局变量名称、常量值、分支目标和比较运算符。"

#: ../../library/dis.rst:219

msgid ""

"Return an iterator over the instructions in the supplied function, method, "

"source code string or code object."

msgstr "在所提供的函数、方法、源代码字符串或代码对象中的指令上返回一个迭代器。"

#: ../../library/dis.rst:222

msgid ""

"The iterator generates a series of :class:`Instruction` named tuples giving "

"the details of each operation in the supplied code."

msgstr "迭代器生成一系列 :class:`Instruction` ，命名为元组，提供所提供代码中每个操作的详细信息。"

#: ../../library/dis.rst:235

msgid ""

"This generator function uses the ``co_firstlineno`` and ``co_lnotab`` "

"attributes of the code object *code* to find the offsets which are starts of"

" lines in the source code. They are generated as ``(offset, lineno)`` "

"pairs. See :source:`Objects/lnotab_notes.txt` for the ``co_lnotab`` format "

"and how to decode it."

msgstr ""

"此生成器函数使用代码对象 *code* 的 ``co_firstlineno`` 和 ``co_lnotab`` "

"属性来查找源代码中行开头的偏移量。它们生成为 ``(offset, lineno)`` 对。请参阅 "

":source:`objects/lnotab_notes.txt` ，了解 ``co_lnotab`` 格式以及如何解码它。"

#: ../../library/dis.rst:241

msgid "Line numbers can be decreasing. Before, they were always increasing."

msgstr "行号可能会减少。 以前，他们总是在增加。"

#: ../../library/dis.rst:247

msgid ""

"Detect all offsets in the raw compiled bytecode string *code* which are jump"

" targets, and return a list of these offsets."

msgstr "检测作为跳转目标的原始编译后字节码字符串 *code* 中的所有偏移量，并返回这些偏移量的列表。"

#: ../../library/dis.rst:253

msgid "Compute the stack effect of *opcode* with argument *oparg*."

msgstr "使用参数 *oparg* 计算 *opcode* 的堆栈效果。"

#: ../../library/dis.rst:255

msgid ""

"If the code has a jump target and *jump* is ``True``, :func:`~stack_effect` "

"will return the stack effect of jumping. If *jump* is ``False``, it will "

"return the stack effect of not jumping. And if *jump* is ``None`` (default),"

" it will return the maximal stack effect of both cases."

msgstr ""

"如果代码有一个跳转目标并且 *jump* 是 ``True`` ，则 :func:`~drag_effect` 将返回跳转的堆栈效果。如果 *jump*"

" 是 ``False`` ，它将返回不跳跃的堆栈效果。如果 *jump* 是 ``None`` （默认值），它将返回两种情况的最大堆栈效果。"

#: ../../library/dis.rst:262

msgid "Added *jump* parameter."

msgstr "添加 *jump* 参数。"

#: ../../library/dis.rst:269

msgid "Python Bytecode Instructions"

msgstr "Python字节码说明"

#: ../../library/dis.rst:271

msgid ""

"The :func:`get_instructions` function and :class:`Bytecode` class provide "

"details of bytecode instructions as :class:`Instruction` instances:"

msgstr ""

":func:`get_instructions` 函数和 :class:`Bytecode` 类提供字节码指令的详细信息的 "

":class:`Instruction` 实例："

#: ../../library/dis.rst:276

msgid "Details for a bytecode operation"

msgstr "字节码操作的详细信息"

#: ../../library/dis.rst:280

msgid ""

"numeric code for operation, corresponding to the opcode values listed below "

"and the bytecode values in the :ref:`opcode_collections`."

msgstr "操作的数字代码，对应于下面列出的操作码值和 :ref:`opcode_collections` 中的字节码值。"

#: ../../library/dis.rst:286

msgid "human readable name for operation"

msgstr "人类可读的操作名称"

#: ../../library/dis.rst:291

msgid "numeric argument to operation (if any), otherwise ``None``"

msgstr "操作的数字参数（如果有的话），否则为 ``None``"

#: ../../library/dis.rst:296

msgid "resolved arg value (if known), otherwise same as arg"

msgstr "已解析的 arg 值（如果已知），否则与 arg 相同"

#: ../../library/dis.rst:301

msgid "human readable description of operation argument"

msgstr "人类可读的操作参数描述"

#: ../../library/dis.rst:306

msgid "start index of operation within bytecode sequence"

msgstr "在字节码序列中的起始操作索引"

#: ../../library/dis.rst:311

msgid "line started by this opcode (if any), otherwise ``None``"

msgstr "行由此操作码（如果有）启动，否则为 ``None``"

#: ../../library/dis.rst:316

msgid "``True`` if other code jumps to here, otherwise ``False``"

msgstr "如果其他代码跳到这里，则为 ``True`` ，否则为 ``False``"

#: ../../library/dis.rst:321

msgid ""

"The Python compiler currently generates the following bytecode instructions."

msgstr "Python编译器当前生成以下字节码指令。"

#: ../../library/dis.rst:324

msgid "**General instructions**"

msgstr "**一般指令**"

#: ../../library/dis.rst:328

msgid "Do nothing code. Used as a placeholder by the bytecode optimizer."

msgstr "什么都不做。 用作字节码优化器的占位符。"

#: ../../library/dis.rst:333

msgid "Removes the top-of-stack (TOS) item."

msgstr "删除堆栈顶部（TOS）项。"

#: ../../library/dis.rst:338

msgid "Swaps the two top-most stack items."

msgstr "交换两个最顶层的堆栈项。"

#: ../../library/dis.rst:343

msgid ""

"Lifts second and third stack item one position up, moves top down to "

"position three."

msgstr "将第二个和第三个堆栈项向上提升一个位置，顶项移动到位置三。"

#: ../../library/dis.rst:349

msgid ""

"Lifts second, third and fourth stack items one position up, moves top down "

"to position four."

msgstr "将第二个、第三个和第四个堆栈项向上提升一个位置，将顶项移动到第四个位置。"

#: ../../library/dis.rst:357

msgid "Duplicates the reference on top of the stack."

msgstr "复制堆栈顶部的引用。"

#: ../../library/dis.rst:364

msgid ""

"Duplicates the two references on top of the stack, leaving them in the same "

"order."

msgstr "复制堆栈顶部的两个引用，使它们保持相同的顺序。"

#: ../../library/dis.rst:370

msgid "**Unary operations**"

msgstr "**一元操作**"

#: ../../library/dis.rst:372

msgid ""

"Unary operations take the top of the stack, apply the operation, and push "

"the result back on the stack."

msgstr "一元操作获取堆栈顶部元素，应用操作，并将结果推回堆栈。"

#: ../../library/dis.rst:377

msgid "Implements ``TOS = +TOS``."

msgstr "实现 ``TOS = +TOS``。"

#: ../../library/dis.rst:382

msgid "Implements ``TOS = -TOS``."

msgstr "实现 ``TOS = -TOS``。"

#: ../../library/dis.rst:387

msgid "Implements ``TOS = not TOS``."

msgstr "实现 ``TOS = not TOS``。"

#: ../../library/dis.rst:392

msgid "Implements ``TOS = ~TOS``."

msgstr "实现 ``TOS = ~TOS``。"

#: ../../library/dis.rst:397

msgid "Implements ``TOS = iter(TOS)``."

msgstr "实现 ``TOS = iter(TOS)``。"

#: ../../library/dis.rst:402

msgid ""

"If ``TOS`` is a :term:`generator iterator` or :term:`coroutine` object it is"

" left as is. Otherwise, implements ``TOS = iter(TOS)``."

msgstr ""

"如果 ``TOS`` 是一个 :term:`generator iterator` 或 :term:`coroutine` 对象则保持原样。否则实现 "

"``TOS = iter(TOS)`` 。"

#: ../../library/dis.rst:408

msgid "**Binary operations**"

msgstr "**二元操作**"

#: ../../library/dis.rst:410

msgid ""

"Binary operations remove the top of the stack (TOS) and the second top-most "

"stack item (TOS1) from the stack. They perform the operation, and put the "

"result back on the stack."

msgstr "二元操作从堆栈中删除堆栈顶部（TOS）和第二个最顶层堆栈项（TOS1）。 它们执行操作，并将结果放回堆栈。"

#: ../../library/dis.rst:416

msgid "Implements ``TOS = TOS1 ** TOS``."

msgstr "实现 ``TOS = TOS1 ** TOS`` 。"

#: ../../library/dis.rst:421

msgid "Implements ``TOS = TOS1 * TOS``."

msgstr "实现 ``TOS = TOS1 * TOS`` 。"

#: ../../library/dis.rst:426

msgid "Implements ``TOS = TOS1 @ TOS``."

msgstr "实现 ``TOS = TOS1 @ TOS`` 。"

#: ../../library/dis.rst:433

msgid "Implements ``TOS = TOS1 // TOS``."

msgstr "实现 ``TOS = TOS1 // TOS``。"

#: ../../library/dis.rst:438

msgid "Implements ``TOS = TOS1 / TOS``."

msgstr "实现 ``TOS = TOS1 / TOS`` 。"

#: ../../library/dis.rst:443

msgid "Implements ``TOS = TOS1 % TOS``."

msgstr "实现 ``TOS = TOS1 % TOS`` 。"

#: ../../library/dis.rst:448

msgid "Implements ``TOS = TOS1 + TOS``."

msgstr "实现 ``TOS = TOS1 + TOS`` 。"

#: ../../library/dis.rst:453

msgid "Implements ``TOS = TOS1 - TOS``."

msgstr "实现 ``TOS = TOS1 - TOS`` 。"

#: ../../library/dis.rst:458

msgid "Implements ``TOS = TOS1[TOS]``."

msgstr "实现 ``TOS = TOS1[TOS]``。"

#: ../../library/dis.rst:463

msgid "Implements ``TOS = TOS1 << TOS``."

msgstr "实现 ``TOS = TOS1 << TOS`` 。"

#: ../../library/dis.rst:468

msgid "Implements ``TOS = TOS1 >> TOS``."

msgstr "实现 ``TOS = TOS1 >> TOS`` 。"

#: ../../library/dis.rst:473

msgid "Implements ``TOS = TOS1 & TOS``."

msgstr "实现 ``TOS = TOS1 & TOS`` 。"

#: ../../library/dis.rst:478

msgid "Implements ``TOS = TOS1 ^ TOS``."

msgstr "实现 ``TOS = TOS1 ^ TOS`` 。"

#: ../../library/dis.rst:483

msgid "Implements ``TOS = TOS1 | TOS``."

msgstr "实现 ``TOS = TOS1 | TOS`` 。"

#: ../../library/dis.rst:486

msgid "**In-place operations**"

msgstr "**就地操作**"

#: ../../library/dis.rst:488

msgid ""

"In-place operations are like binary operations, in that they remove TOS and "

"TOS1, and push the result back on the stack, but the operation is done in-"

"place when TOS1 supports it, and the resulting TOS may be (but does not have"

" to be) the original TOS1."

msgstr ""

"就地操作就像二元操作，因为它们删除了TOS和TOS1，并将结果推回到堆栈上，但是当TOS1支持它时，操作就地完成，并且产生的TOS可能是（但不一定） "

"原来的TOS1。"

#: ../../library/dis.rst:495

msgid "Implements in-place ``TOS = TOS1 ** TOS``."

msgstr "就地实现 ``TOS = TOS1 ** TOS`` 。"

#: ../../library/dis.rst:500

msgid "Implements in-place ``TOS = TOS1 * TOS``."

msgstr "就地实现 ``TOS = TOS1 * TOS`` 。"

#: ../../library/dis.rst:505

msgid "Implements in-place ``TOS = TOS1 @ TOS``."

msgstr "就地实现 ``TOS = TOS1 @ TOS`` 。"

#: ../../library/dis.rst:512

msgid "Implements in-place ``TOS = TOS1 // TOS``."

msgstr "就地实现 ``TOS = TOS1 // TOS`` 。"

#: ../../library/dis.rst:517

msgid "Implements in-place ``TOS = TOS1 / TOS``."

msgstr "就地实现 ``TOS = TOS1 / TOS`` 。"

#: ../../library/dis.rst:522

msgid "Implements in-place ``TOS = TOS1 % TOS``."

msgstr "就地实现 ``TOS = TOS1 % TOS`` 。"

#: ../../library/dis.rst:527

msgid "Implements in-place ``TOS = TOS1 + TOS``."

msgstr "就地实现 ``TOS = TOS1 + TOS`` 。"

#: ../../library/dis.rst:532

msgid "Implements in-place ``TOS = TOS1 - TOS``."

msgstr "就地实现 ``TOS = TOS1 - TOS`` 。"

#: ../../library/dis.rst:537

msgid "Implements in-place ``TOS = TOS1 << TOS``."

msgstr "就地实现 ``TOS = TOS1 << TOS`` 。"

#: ../../library/dis.rst:542

msgid "Implements in-place ``TOS = TOS1 >> TOS``."

msgstr "就地实现 ``TOS = TOS1 >> TOS`` 。"

#: ../../library/dis.rst:547

msgid "Implements in-place ``TOS = TOS1 & TOS``."

msgstr "就地实现 ``TOS = TOS1 & TOS`` 。"

#: ../../library/dis.rst:552

msgid "Implements in-place ``TOS = TOS1 ^ TOS``."

msgstr "就地实现 ``TOS = TOS1 ^ TOS`` 。"

#: ../../library/dis.rst:557

msgid "Implements in-place ``TOS = TOS1 | TOS``."

msgstr "就地实现 ``TOS = TOS1 | TOS`` 。"

#: ../../library/dis.rst:562

msgid "Implements ``TOS1[TOS] = TOS2``."

msgstr "实现 ``TOS1[TOS] = TOS2`` 。"

#: ../../library/dis.rst:567

msgid "Implements ``del TOS1[TOS]``."

msgstr "实现 ``del TOS1[TOS]`` 。"

#: ../../library/dis.rst:570

msgid "**Coroutine opcodes**"

msgstr "**协程操作码**"

#: ../../library/dis.rst:574

msgid ""

"Implements ``TOS = get_awaitable(TOS)``, where ``get_awaitable(o)`` returns "

"``o`` if ``o`` is a coroutine object or a generator object with the "

"CO_ITERABLE_COROUTINE flag, or resolves ``o.__await__``."

msgstr ""

"实现 ``TOS = get_awaitable(TOS)`` ，其中 ``get_awaitable(o)`` 返回 ``o`` 如果 ``o`` "

"是一个有 CO_ITERABLE_COROUTINE 标志的协程对象或生成器对象，否则解析 ``o.__await__`` 。"

#: ../../library/dis.rst:584

msgid "Implements ``TOS = TOS.__aiter__()``."

msgstr "实现 ``TOS = TOS.__aiter__()`` 。"

#: ../../library/dis.rst:587

msgid "Returning awaitable objects from ``__aiter__`` is no longer supported."

msgstr "已经不再支持从 ``__aiter__`` 返回可等待对象。"

#: ../../library/dis.rst:594

msgid ""

"Implements ``PUSH(get_awaitable(TOS.__anext__()))``. See ``GET_AWAITABLE`` "

"for details about ``get_awaitable``"

msgstr ""

"实现 ``PUSH(get_awaitable(TOS.__anext__()))`` 。参见 ``GET_AWAITABLE`` 获取更多 "

"``get_awaitable`` 的细节"

#: ../../library/dis.rst:602

msgid ""

"Terminates an :keyword:`async for` loop. Handles an exception raised when "

"awaiting a next item. If TOS is :exc:`StopAsyncIteration` pop 7 values from"

" the stack and restore the exception state using the second three of them. "

"Otherwise re-raise the exception using the three values from the stack. An "

"exception handler block is removed from the block stack."

msgstr ""

"终止一个 :keyword:`async for` 循环。处理等待下一个项目时引发的异常。如果 TOS 是 "

":exc:`StopAsyncIteration`， "

"从堆栈弹出7个值，并使用后三个恢复异常状态。否则，使用堆栈中的三个值重新引发异常。从块堆栈中删除异常处理程序块。"

#: ../../library/dis.rst:613

msgid ""

"Resolves ``__aenter__`` and ``__aexit__`` from the object on top of the "

"stack. Pushes ``__aexit__`` and result of ``__aenter__()`` to the stack."

msgstr ""

"从栈顶对象解析 ``__aenter__`` 和 ``__aexit__`` 。将 ``__aexit__`` 和 ``__aenter__()`` "

"的结果推入堆栈。"

#: ../../library/dis.rst:621

msgid "Creates a new frame object."

msgstr "创建一个新的帧对象。"

#: ../../library/dis.rst:627

msgid "**Miscellaneous opcodes**"

msgstr "**其他操作码**"

#: ../../library/dis.rst:631

msgid ""

"Implements the expression statement for the interactive mode. TOS is "

"removed from the stack and printed. In non-interactive mode, an expression "

"statement is terminated with :opcode:`POP_TOP`."

msgstr "实现交互模式的表达式语句。TOS从堆栈中被移除并打印。在非交互模式下，表达式语句以 :opcode:`POP_TOP` 终止。"

#: ../../library/dis.rst:638

msgid ""

"Calls ``set.add(TOS1[-i], TOS)``. Used to implement set comprehensions."

msgstr "调用 ``set.add(TOS1[-i], TOS)`` 。 用于实现集合推导。"

#: ../../library/dis.rst:643

msgid ""

"Calls ``list.append(TOS1[-i], TOS)``. Used to implement list "

"comprehensions."

msgstr "调用 ``list.append(TOS1[-i], TOS)``。 用于实现列表推导式。"

#: ../../library/dis.rst:648

msgid ""

"Calls ``dict.__setitem__(TOS1[-i], TOS1, TOS)``. Used to implement dict "

"comprehensions."

msgstr "调用 ``dict.__setitem__(TOS1[-i], TOS1, TOS)`` 。 用于实现字典推导。"

#: ../../library/dis.rst:652

msgid "Map value is TOS and map key is TOS1. Before, those were reversed."

msgstr "映射值为 TOS ，映射键为 TOS1 。之前，它们被颠倒了。"

#: ../../library/dis.rst:655

msgid ""

"For all of the :opcode:`SET_ADD`, :opcode:`LIST_APPEND` and "

":opcode:`MAP_ADD` instructions, while the added value or key/value pair is "

"popped off, the container object remains on the stack so that it is "

"available for further iterations of the loop."

msgstr ""

"对于所有 :opcode:`SET_ADD` 、 :opcode:`LIST_APPEND` 和 :opcode:`MAP_ADD` "

"指令，当弹出添加的值或键值对时，容器对象保留在堆栈上，以便它可用于循环的进一步迭代。"

#: ../../library/dis.rst:663

msgid "Returns with TOS to the caller of the function."

msgstr "返回 TOS 到函数的调用者。"

#: ../../library/dis.rst:668

msgid "Pops TOS and yields it from a :term:`generator`."

msgstr "弹出 TOS 并从一个 :term:`generator` 生成它。"

#: ../../library/dis.rst:673

msgid ""

"Pops TOS and delegates to it as a subiterator from a :term:`generator`."

msgstr "弹出 TOS 并将其委托给它作为 :term:`generator` 的子迭代器。"

#: ../../library/dis.rst:680

msgid ""

"Checks whether ``__annotations__`` is defined in ``locals()``, if not it is "

"set up to an empty ``dict``. This opcode is only emitted if a class or "

"module body contains :term:`variable annotations <variable annotation>` "

"statically."

msgstr ""

"检查 ``__annotations__`` 是否在 ``locals()`` 中定义，如果没有，它被设置为空 ``dict`` "

"。只有在类或模块体静态地包含 :term:`variable annotations <variable annotation>` 时才会发出此操作码。"

#: ../../library/dis.rst:690

msgid ""

"Loads all symbols not starting with ``'_'`` directly from the module TOS to "

"the local namespace. The module is popped after loading all names. This "

"opcode implements ``from module import *``."

msgstr ""

"将所有不以 ``'_'`` 开头的符号直接从模块 TOS 加载到局部命名空间。加载所有名称后弹出该模块。这个操作码实现了 ``from module "

"import *`` 。"

#: ../../library/dis.rst:697

msgid ""

"Removes one block from the block stack. Per frame, there is a stack of "

"blocks, denoting :keyword:`try` statements, and such."

msgstr "从块堆栈中删除一个块。有一块堆栈，每帧用于表示 :keyword:`try` 语句等。"

#: ../../library/dis.rst:703

msgid ""

"Removes one block from the block stack. The popped block must be an "

"exception handler block, as implicitly created when entering an except "

"handler. In addition to popping extraneous values from the frame stack, the"

" last three popped values are used to restore the exception state."

msgstr ""

"从块堆栈中删除一个块。 弹出的块必须是异常处理程序块，在进入 except "

"处理程序时隐式创建。除了从帧堆栈弹出无关值之外，最后三个弹出值还用于恢复异常状态。"

#: ../../library/dis.rst:711

msgid "Re-raises the exception currently on top of the stack."

msgstr "重新引发当前位于栈顶的异常。"

#: ../../library/dis.rst:718

msgid ""

"Calls the function in position 7 on the stack with the top three items on "

"the stack as arguments. Used to implement the call "

"``context_manager.__exit__(*exc_info())`` when an exception has occurred in "

"a :keyword:`with` statement."

msgstr ""

"调用堆栈中 7 号位置上的函数并附带栈顶位置的三项作为参数。 用来在 :keyword:`with` 语句内发生异常时实现调用 "

"``context_manager.__exit__(*exc_info())``。"

#: ../../library/dis.rst:728

msgid ""

"Pushes :exc:`AssertionError` onto the stack. Used by the :keyword:`assert` "

"statement."

msgstr "将 :exc:`AssertionError` 推入栈顶。 由 :keyword:`assert` 语句使用。"

#: ../../library/dis.rst:736

msgid ""

"Pushes :func:`builtins.__build_class__` onto the stack. It is later called "

"by :opcode:`CALL_FUNCTION` to construct a class."

msgstr ""

"将 :func:`builtins .__ build_class__` 推到堆栈上。它之后被 :opcode:`CALL_FUNCTION` "

"调用来构造一个类。"

#: ../../library/dis.rst:742

msgid ""

"This opcode performs several operations before a with block starts. First, "

"it loads :meth:`~object.__exit__` from the context manager and pushes it "

"onto the stack for later use by :opcode:`WITH_EXCEPT_START`. Then, "

":meth:`~object.__enter__` is called, and a finally block pointing to *delta*"

" is pushed. Finally, the result of calling the ``__enter__()`` method is "

"pushed onto the stack. The next opcode will either ignore it "

"(:opcode:`POP_TOP`), or store it in (a) variable(s) (:opcode:`STORE_FAST`, "

":opcode:`STORE_NAME`, or :opcode:`UNPACK_SEQUENCE`)."

msgstr ""

"此操作码会在 with 代码块开始之前执行多个操作。 首先，它从上下文管理器加载 :meth:`~object.__exit__` 并将其推入栈顶以供 "

":opcode:`WITH_EXCEPT_START` 后续使用。 然后，调用 :meth:`~object.__enter__`，并推入一个指向 "

"*delta* 的 finally 代码块。 最后，将调用 ``__enter__()`` 方法的结果推入栈顶。 下一个操作码将忽略它 "

"(:opcode:`POP_TOP`)，或将其存储在一个或多个变量 (:opcode:`STORE_FAST`, "

":opcode:`STORE_NAME` 或 :opcode:`UNPACK_SEQUENCE`) 中。"

#: ../../library/dis.rst:754

msgid "All of the following opcodes use their arguments."

msgstr "以下所有操作码均使用其参数。"

#: ../../library/dis.rst:758

msgid ""

"Implements ``name = TOS``. *namei* is the index of *name* in the attribute "

":attr:`co_names` of the code object. The compiler tries to use "

":opcode:`STORE_FAST` or :opcode:`STORE_GLOBAL` if possible."

msgstr ""

"实现 ``name = TOS``。 *namei* 是 *name* 在代码对象的 :attr:`co_names` 属性中的索引。 "

"在可能的情况下，编译器会尝试使用 :opcode:`STORE_FAST` 或 :opcode:`STORE_GLOBAL`。"

#: ../../library/dis.rst:765

msgid ""

"Implements ``del name``, where *namei* is the index into :attr:`co_names` "

"attribute of the code object."

msgstr "实现 ``del name`` ，其中 *namei* 是代码对象的 :attr:`co_names` 属性的索引。"

#: ../../library/dis.rst:771

msgid ""

"Unpacks TOS into *count* individual values, which are put onto the stack "

"right-to-left."

msgstr "将 TOS 解包为 *count* 个单独的值，它们将按从右至左的顺序被放入堆栈。"

#: ../../library/dis.rst:777

msgid ""

"Implements assignment with a starred target: Unpacks an iterable in TOS into"

" individual values, where the total number of values can be smaller than the"

" number of items in the iterable: one of the new values will be a list of "

"all leftover items."

msgstr ""

"实现使用带星号的目标进行赋值：将 TOS 中的可迭代对象解包为单独的值，其中值的总数可以小于可迭代对象中的项数：新值之一将是由所有剩余项构成的列表。"

#: ../../library/dis.rst:782

msgid ""

"The low byte of *counts* is the number of values before the list value, the "

"high byte of *counts* the number of values after it. The resulting values "

"are put onto the stack right-to-left."

msgstr "*counts* 的低字节是列表值之前的值的数量，*counts* 中的高字节则是之后的值的数量。 结果值会按从右至左的顺序入栈。"

#: ../../library/dis.rst:789

msgid ""

"Implements ``TOS.name = TOS1``, where *namei* is the index of name in "

":attr:`co_names`."

msgstr "实现 ``TOS.name = TOS1``，其中 *namei* 是 name 在 :attr:`co_names` 中的索引号。"

#: ../../library/dis.rst:795

msgid ""

"Implements ``del TOS.name``, using *namei* as index into :attr:`co_names`."

msgstr "实现 ``del TOS.name``，使用 *namei* 作为 :attr:`co_names` 中的索引号。"

#: ../../library/dis.rst:800

msgid "Works as :opcode:`STORE_NAME`, but stores the name as a global."

msgstr "类似于 :opcode:`STORE_NAME` 但会将 name 存储为全局变量。"

#: ../../library/dis.rst:805

msgid "Works as :opcode:`DELETE_NAME`, but deletes a global name."

msgstr "类似于 :opcode:`DELETE_NAME` 但会删除一个全局变量。"

#: ../../library/dis.rst:810

msgid "Pushes ``co_consts[consti]`` onto the stack."

msgstr "将 ``co_consts[consti]`` 推入栈顶。"

#: ../../library/dis.rst:815

msgid "Pushes the value associated with ``co_names[namei]`` onto the stack."

msgstr "将与 ``co_names[namei]`` 相关联的值推入栈顶。"

#: ../../library/dis.rst:820

msgid ""

"Creates a tuple consuming *count* items from the stack, and pushes the "

"resulting tuple onto the stack."

msgstr "创建一个使用了来自栈的 *count* 个项的元组，并将结果元组推入栈顶。"

#: ../../library/dis.rst:826

msgid "Works as :opcode:`BUILD_TUPLE`, but creates a list."

msgstr "类似于 :opcode:`BUILD_TUPLE` 但会创建一个列表。"

#: ../../library/dis.rst:831

msgid "Works as :opcode:`BUILD_TUPLE`, but creates a set."

msgstr "类似于 :opcode:`BUILD_TUPLE` 但会创建一个集合。"

#: ../../library/dis.rst:836

msgid ""

"Pushes a new dictionary object onto the stack. Pops ``2 * count`` items so "

"that the dictionary holds *count* entries: ``{..., TOS3: TOS2, TOS1: TOS}``."

msgstr ""

"将一个新字典对象推入栈顶。 弹出 ``2 * count`` 项使得字典包含 *count* 个条目: ``{..., TOS3: TOS2, "

"TOS1: TOS}``。"

#: ../../library/dis.rst:840

msgid ""

"The dictionary is created from stack items instead of creating an empty "

"dictionary pre-sized to hold *count* items."

msgstr "字典是根据栈中的项创建而不是创建一个预设大小包含 *count* 项的空字典。"

#: ../../library/dis.rst:847

msgid ""

"The version of :opcode:`BUILD_MAP` specialized for constant keys. Pops the "

"top element on the stack which contains a tuple of keys, then starting from "

"``TOS1``, pops *count* values to form values in the built dictionary."

msgstr ""

":opcode:`BUILD_MAP` 版本专用于常量键。 弹出的栈顶元素包含一个由键构成的元组，然后从 ``TOS1`` 开始从构建字典的值中弹出 "

"*count* 个值。"

#: ../../library/dis.rst:856

msgid ""

"Concatenates *count* strings from the stack and pushes the resulting string "

"onto the stack."

msgstr "拼接 *count* 个来自栈的字符串并将结果字符串推入栈顶。"

#: ../../library/dis.rst:864

msgid ""

"Pops a list from the stack and pushes a tuple containing the same values."

msgstr "从堆栈中弹出一个列表并推入一个包含相同值的元组。"

#: ../../library/dis.rst:871

msgid "Calls ``list.extend(TOS1[-i], TOS)``. Used to build lists."

msgstr "调用 ``list.extend(TOS1[-i], TOS)``。 用于构建列表。"

#: ../../library/dis.rst:878

msgid "Calls ``set.update(TOS1[-i], TOS)``. Used to build sets."

msgstr "调用 ``set.update(TOS1[-i], TOS)``。 用于构建集合。"

#: ../../library/dis.rst:885

msgid "Calls ``dict.update(TOS1[-i], TOS)``. Used to build dicts."

msgstr "调用 ``dict.update(TOS1[-i], TOS)``。 用于构建字典。"

#: ../../library/dis.rst:892

msgid "Like :opcode:`DICT_UPDATE` but raises an exception for duplicate keys."

msgstr "类似于 :opcode:`DICT_UPDATE` 但对于重复的键会引发异常。"

#: ../../library/dis.rst:899

msgid "Replaces TOS with ``getattr(TOS, co_names[namei])``."

msgstr "将 TOS 替换为 ``getattr(TOS, co_names[namei])``。"

#: ../../library/dis.rst:904

msgid ""

"Performs a Boolean operation. The operation name can be found in "

"``cmp_op[opname]``."

msgstr "执行布尔运算操作。 操作名称可在 ``cmp_op[opname]`` 中找到。"

#: ../../library/dis.rst:910

msgid "Performs ``is`` comparison, or ``is not`` if ``invert`` is 1."

msgstr "执行 ``is`` 比较，或者如果 ``invert`` 为 1 则执行 ``is not``。"

#: ../../library/dis.rst:917

msgid "Performs ``in`` comparison, or ``not in`` if ``invert`` is 1."

msgstr "执行 ``in`` 比较，或者如果 ``invert`` 为 1 则执行 ``not in``。"

#: ../../library/dis.rst:924

msgid ""

"Imports the module ``co_names[namei]``. TOS and TOS1 are popped and provide"

" the *fromlist* and *level* arguments of :func:`__import__`. The module "

"object is pushed onto the stack. The current namespace is not affected: for"

" a proper import statement, a subsequent :opcode:`STORE_FAST` instruction "

"modifies the namespace."

msgstr ""

"导入模块 ``co_names[namei]``。 会弹出 TOS 和 TOS1 以提供 *fromlist* 和 *level* 参数给 "

":func:`__import__`。 模块对象会被推入栈顶。 当前命名空间不受影响：对于一条标准 import 语句，会执行后续的 "

":opcode:`STORE_FAST` 指令来修改命名空间。"

#: ../../library/dis.rst:933

msgid ""

"Loads the attribute ``co_names[namei]`` from the module found in TOS. The "

"resulting object is pushed onto the stack, to be subsequently stored by a "

":opcode:`STORE_FAST` instruction."

msgstr ""

"从在 TOS 内找到的模块中加载属性 ``co_names[namei]``。 结果对象会被推入栈顶，以便由后续的 "

":opcode:`STORE_FAST` 指令来保存。"

#: ../../library/dis.rst:940

msgid "Increments bytecode counter by *delta*."

msgstr "将字节码计数器的值增加 *delta*。"

#: ../../library/dis.rst:945

msgid "If TOS is true, sets the bytecode counter to *target*. TOS is popped."

msgstr "如果 TOS 为真值，则将字节码计数器的值设为 *target*。 TOS 会被弹出。"

#: ../../library/dis.rst:952

msgid ""

"If TOS is false, sets the bytecode counter to *target*. TOS is popped."

msgstr "如果 TOS 为假值，则将字节码计数器的值设为 *target*。 TOS 会被弹出。"

#: ../../library/dis.rst:958

msgid ""

"Tests whether the second value on the stack is an exception matching TOS, "

"and jumps if it is not. Pops two values from the stack."

msgstr "检测堆栈中的第二个值是否为匹配 TOS 的异常，如果不是则会跳转。 从堆栈中弹出两个值。"

#: ../../library/dis.rst:966

msgid ""

"If TOS is true, sets the bytecode counter to *target* and leaves TOS on the "

"stack. Otherwise (TOS is false), TOS is popped."

msgstr "如果 TOS 为真值，则将字节码计数器的值设为 *target* 并将 TOS 留在栈顶。 否则（如 TOS 为假值），TOS 会被弹出。"

#: ../../library/dis.rst:974

msgid ""

"If TOS is false, sets the bytecode counter to *target* and leaves TOS on the"

" stack. Otherwise (TOS is true), TOS is popped."

msgstr "如果 TOS 为假值，则将字节码计数器的值设为 *target* 并将 TOS 留在栈顶。 否则（如 TOS 为真值），TOS 会被弹出。"

#: ../../library/dis.rst:982

msgid "Set bytecode counter to *target*."

msgstr "将字节码计数器的值设为 *target*。"

#: ../../library/dis.rst:987

msgid ""

"TOS is an :term:`iterator`. Call its :meth:`~iterator.__next__` method. If"