# 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-09-22 21:56+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"

#: ../../glossary.rst:5

msgid "Glossary"

msgstr "术语对照表"

#: ../../glossary.rst:10

msgid "``>>>``"

msgstr "``>>>``"

#: ../../glossary.rst:12

msgid ""

"The default Python prompt of the interactive shell. Often seen for code "

"examples which can be executed interactively in the interpreter."

msgstr "Python 交互模式下的默认提示符。通常可以在能在解释器中交互执行的代码示例中看到。"

#: ../../glossary.rst:14

msgid "``...``"

msgstr "``...``"

#: ../../glossary.rst:16

msgid "Can refer to:"

msgstr "具有以下含义："

#: ../../glossary.rst:18

msgid ""

"The default Python prompt of the interactive shell when entering the code "

"for an indented code block, when within a pair of matching left and right "

"delimiters (parentheses, square brackets, curly braces or triple quotes), or"

" after specifying a decorator."

msgstr ""

"当输入带缩进的代码块时，以及在一对匹配的左右分隔符（括号、方括号、大括号或三引号）内，或在指定装饰器之后，交互式 Python 的默认提示符。"

#: ../../glossary.rst:23

msgid "The :const:`Ellipsis` built-in constant."

msgstr ":const:`Ellipsis` 内置常量。"

#: ../../glossary.rst:24

msgid "2to3"

msgstr "2to3"

#: ../../glossary.rst:26

msgid ""

"A tool that tries to convert Python 2.x code to Python 3.x code by handling "

"most of the incompatibilities which can be detected by parsing the source "

"and traversing the parse tree."

msgstr "这是一个尝试将 Python 2.x 代码转换为 Python 3.x 代码的工具，通过解析源代码和遍历解析树来处理大部分不兼容问题。"

#: ../../glossary.rst:30

msgid ""

"2to3 is available in the standard library as :mod:`lib2to3`; a standalone "

"entry point is provided as :file:`Tools/scripts/2to3`. See "

":ref:`2to3-reference`."

msgstr ""

"2to3 的标准库为 :mod:`lib2to3`；独立入口点为 :file:`Tools/scripts/2to3`。 参见 "

":ref:`2to3-reference`。"

#: ../../glossary.rst:33

msgid "abstract base class"

msgstr "abstract base class -- 抽象基类"

#: ../../glossary.rst:35

msgid ""

"Abstract base classes complement :term:`duck-typing` by providing a way to "

"define interfaces when other techniques like :func:`hasattr` would be clumsy"

" or subtly wrong (for example with :ref:`magic methods <special-lookup>`). "

"ABCs introduce virtual subclasses, which are classes that don't inherit from"

" a class but are still recognized by :func:`isinstance` and "

":func:`issubclass`; see the :mod:`abc` module documentation. Python comes "

"with many built-in ABCs for data structures (in the :mod:`collections.abc` "

"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` "

"module), import finders and loaders (in the :mod:`importlib.abc` module). "

"You can create your own ABCs with the :mod:`abc` module."

msgstr ""

"抽象基类简称 ABC，是对 :term:`duck-typing` 的补充，它提供了一种定义接口的新方式，相比之下其他技巧例如 "

":func:`hasattr` 显得过于笨拙或有微妙错误（例如使用 :ref:`魔术方法 <special-lookup>`）。ABC "

"引入了虚拟子类，这种类并非继承自其他类，但却仍能被 :func:`isinstance` 和 :func:`issubclass` 所认可；详见 "

":mod:`abc` 模块文档。Python 自带许多内置的 ABC 用于实现数据结构（在 :mod:`collections.abc` "

"模块中）、数字（在 :mod:`numbers` 模块中）、流（在 :mod:`io` 模块中）、导入查找器和加载器（在 "

":mod:`importlib.abc` 模块中）。你可以使用 :mod:`abc` 模块来创建自己的 ABC。"

#: ../../glossary.rst:46

msgid "annotation"

msgstr "annotation -- 标注"

#: ../../glossary.rst:48

msgid ""

"A label associated with a variable, a class attribute or a function "

"parameter or return value, used by convention as a :term:`type hint`."

msgstr "关联到某个变量、类属性、函数形参或返回值的标签，被约定作为 :term:`类型注解 <type hint>` 来使用。"

#: ../../glossary.rst:52

msgid ""

"Annotations of local variables cannot be accessed at runtime, but "

"annotations of global variables, class attributes, and functions are stored "

"in the :attr:`__annotations__` special attribute of modules, classes, and "

"functions, respectively."

msgstr ""

"局部变量的标注在运行时不可访问，但全局变量、类属性和函数的标注会分别存放模块、类和函数的 :attr:`__annotations__` 特殊属性中。"

#: ../../glossary.rst:58

msgid ""

"See :term:`variable annotation`, :term:`function annotation`, :pep:`484` and"

" :pep:`526`, which describe this functionality."

msgstr ""

#: ../../glossary.rst:60

msgid "argument"

msgstr "argument -- 参数"

#: ../../glossary.rst:62

msgid ""

"A value passed to a :term:`function` (or :term:`method`) when calling the "

"function. There are two kinds of argument:"

msgstr "在调用函数时传给 :term:`function` （或 :term:`method` ）的值。参数分为两种："

#: ../../glossary.rst:65

msgid ""

":dfn:`keyword argument`: an argument preceded by an identifier (e.g. "

"``name=``) in a function call or passed as a value in a dictionary preceded "

"by ``**``. For example, ``3`` and ``5`` are both keyword arguments in the "

"following calls to :func:`complex`::"

msgstr ""

":dfn:`关键字参数`: 在函数调用中前面带有标识符（例如 ``name=``）或者作为包含在前面带有 ``**`` "

"的字典里的值传入。举例来说，``3`` 和 ``5`` 在以下对 :func:`complex` 的调用中均属于关键字参数::"

#: ../../glossary.rst:73

msgid ""

":dfn:`positional argument`: an argument that is not a keyword argument. "

"Positional arguments can appear at the beginning of an argument list and/or "

"be passed as elements of an :term:`iterable` preceded by ``*``. For example,"

" ``3`` and ``5`` are both positional arguments in the following calls::"

msgstr ""

":dfn:`位置参数`: 不属于关键字参数的参数。位置参数可出现于参数列表的开头以及/或者作为前面带有 ``*`` 的 :term:`iterable`"

" 里的元素被传入。举例来说，``3`` 和 ``5`` 在以下调用中均属于位置参数::"

#: ../../glossary.rst:82

msgid ""

"Arguments are assigned to the named local variables in a function body. See "

"the :ref:`calls` section for the rules governing this assignment. "

"Syntactically, any expression can be used to represent an argument; the "

"evaluated value is assigned to the local variable."

msgstr ""

"参数会被赋值给函数体中对应的局部变量。有关赋值规则参见 :ref:`calls` "

"一节。根据语法，任何表达式都可用来表示一个参数；最终算出的值会被赋给对应的局部变量。"

#: ../../glossary.rst:87

msgid ""

"See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the"

" difference between arguments and parameters <faq-argument-vs-parameter>`, "

"and :pep:`362`."

msgstr ""

"另参见 :term:`parameter` 术语表条目，常见问题中 :ref:`参数与形参的区别 <faq-argument-vs-"

"parameter>` 以及 :pep:`362`。"

#: ../../glossary.rst:90

msgid "asynchronous context manager"

msgstr "asynchronous context manager -- 异步上下文管理器"

#: ../../glossary.rst:92

msgid ""

"An object which controls the environment seen in an :keyword:`async with` "

"statement by defining :meth:`__aenter__` and :meth:`__aexit__` methods. "

"Introduced by :pep:`492`."

msgstr ""

"此种对象通过定义 :meth:`__aenter__` 和 :meth:`__aexit__` 方法来对 :keyword:`async with` "

"语句中的环境进行控制。由 :pep:`492` 引入。"

#: ../../glossary.rst:95

msgid "asynchronous generator"

msgstr "asynchronous generator -- 异步生成器"

#: ../../glossary.rst:97

msgid ""

"A function which returns an :term:`asynchronous generator iterator`. It "

"looks like a coroutine function defined with :keyword:`async def` except "

"that it contains :keyword:`yield` expressions for producing a series of "

"values usable in an :keyword:`async for` loop."

msgstr ""

"返回值为 :term:`asynchronous generator iterator` 的函数。它与使用 :keyword:`async def` "

"定义的协程函数很相似，不同之处在于它包含 :keyword:`yield` 表达式以产生一系列可在 :keyword:`async for` "

"循环中使用的值。"

#: ../../glossary.rst:102

msgid ""

"Usually refers to an asynchronous generator function, but may refer to an "

"*asynchronous generator iterator* in some contexts. In cases where the "

"intended meaning isn't clear, using the full terms avoids ambiguity."

msgstr "此术语通常是指异步生成器函数，但在某些情况下则可能是指 *异步生成器迭代器*。如果需要清楚表达具体含义，请使用全称以避免歧义。"

#: ../../glossary.rst:106

msgid ""

"An asynchronous generator function may contain :keyword:`await` expressions "

"as well as :keyword:`async for`, and :keyword:`async with` statements."

msgstr ""

"一个异步生成器函数可能包含 :keyword:`await` 表达式或者 :keyword:`async for` 以及 :keyword:`async"

" with` 语句。"

#: ../../glossary.rst:109

msgid "asynchronous generator iterator"

msgstr "asynchronous generator iterator -- 异步生成器迭代器"

#: ../../glossary.rst:111

msgid "An object created by a :term:`asynchronous generator` function."

msgstr ":term:`asynchronous generator` 函数所创建的对象。"

#: ../../glossary.rst:113

msgid ""

"This is an :term:`asynchronous iterator` which when called using the "

":meth:`__anext__` method returns an awaitable object which will execute the "

"body of the asynchronous generator function until the next :keyword:`yield` "

"expression."

msgstr ""

"此对象属于 :term:`asynchronous iterator`，当使用 :meth:`__anext__` "

"方法调用时会返回一个可等待对象来执行异步生成器函数的代码直到下一个 :keyword:`yield` 表达式。"

#: ../../glossary.rst:118

msgid ""

"Each :keyword:`yield` temporarily suspends processing, remembering the "

"location execution state (including local variables and pending try-"

"statements). When the *asynchronous generator iterator* effectively resumes"

" with another awaitable returned by :meth:`__anext__`, it picks up where it "

"left off. See :pep:`492` and :pep:`525`."

msgstr ""

"每个 :keyword:`yield` 会临时暂停处理，记住当前位置执行状态 (包括局部变量和挂起的 try 语句)。当该 *异步生成器迭代器* 与其他"

" :meth:`__anext__` 返回的可等待对象有效恢复时，它会从离开位置继续执行。参见 :pep:`492` 和 :pep:`525`。"

#: ../../glossary.rst:123

msgid "asynchronous iterable"

msgstr "asynchronous iterable -- 异步可迭代对象"

#: ../../glossary.rst:125

msgid ""

"An object, that can be used in an :keyword:`async for` statement. Must "

"return an :term:`asynchronous iterator` from its :meth:`__aiter__` method. "

"Introduced by :pep:`492`."

msgstr ""

"可在 :keyword:`async for` 语句中被使用的对象。必须通过它的 :meth:`__aiter__` 方法返回一个 "

":term:`asynchronous iterator`。由 :pep:`492` 引入。"

#: ../../glossary.rst:128

msgid "asynchronous iterator"

msgstr "asynchronous iterator -- 异步迭代器"

#: ../../glossary.rst:130

msgid ""

"An object that implements the :meth:`__aiter__` and :meth:`__anext__` "

"methods. ``__anext__`` must return an :term:`awaitable` object. "

":keyword:`async for` resolves the awaitables returned by an asynchronous "

"iterator's :meth:`__anext__` method until it raises a "

":exc:`StopAsyncIteration` exception. Introduced by :pep:`492`."

msgstr ""

"实现了 :meth:`__aiter__` 和 :meth:`__anext__` 方法的对象。``__anext__`` 必须返回一个 "

":term:`awaitable` 对象。:keyword:`async for` 会处理异步迭代器的 :meth:`__anext__` "

"方法所返回的可等待对象，直到其引发一个 :exc:`StopAsyncIteration` 异常。由 :pep:`492` 引入。"

#: ../../glossary.rst:135

msgid "attribute"

msgstr "attribute -- 属性"

#: ../../glossary.rst:137

msgid ""

"A value associated with an object which is referenced by name using dotted "

"expressions. For example, if an object *o* has an attribute *a* it would be"

" referenced as *o.a*."

msgstr ""

#: ../../glossary.rst:140

msgid "awaitable"

msgstr "awaitable -- 可等待对象"

#: ../../glossary.rst:142

msgid ""

"An object that can be used in an :keyword:`await` expression. Can be a "

":term:`coroutine` or an object with an :meth:`__await__` method. See also "

":pep:`492`."

msgstr ""

"能在 :keyword:`await` 表达式中使用的对象。可以是 :term:`coroutine` 或是具有 :meth:`__await__` "

"方法的对象。参见 :pep:`492`。"

#: ../../glossary.rst:145

msgid "BDFL"

msgstr "BDFL"

#: ../../glossary.rst:147

msgid ""

"Benevolent Dictator For Life, a.k.a. `Guido van Rossum "

"<https://gvanrossum.github.io/>`_, Python's creator."

msgstr ""

"“终身仁慈独裁者”的英文缩写，即 `Guido van Rossum <https://gvanrossum.github.io/>`_，Python "

"的创造者。"

#: ../../glossary.rst:149

msgid "binary file"

msgstr "binary file -- 二进制文件"

#: ../../glossary.rst:151

msgid ""

"A :term:`file object` able to read and write :term:`bytes-like objects "

"<bytes-like object>`. Examples of binary files are files opened in binary "

"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer`, "

":data:`sys.stdout.buffer`, and instances of :class:`io.BytesIO` and "

":class:`gzip.GzipFile`."

msgstr ""

":term:`file object` 能够读写 :term:`字节类对象 <bytes-like "

"object>`。二进制文件的例子包括以二进制模式（``'rb'``, ``'wb'`` or "

"``'rb+'``）打开的文件、:data:`sys.stdin.buffer`、:data:`sys.stdout.buffer` 以及 "

":class:`io.BytesIO` 和 :class:`gzip.GzipFile` 的实例。"

#: ../../glossary.rst:158

msgid ""

"See also :term:`text file` for a file object able to read and write "

":class:`str` objects."

msgstr "另请参见 :term:`text file` 了解能够读写 :class:`str` 对象的文件对象。"

#: ../../glossary.rst:160

msgid "bytes-like object"

msgstr "bytes-like object -- 字节型对象"

#: ../../glossary.rst:162

msgid ""

"An object that supports the :ref:`bufferobjects` and can export a "

"C-:term:`contiguous` buffer. This includes all :class:`bytes`, "

":class:`bytearray`, and :class:`array.array` objects, as well as many common"

" :class:`memoryview` objects. Bytes-like objects can be used for various "

"operations that work with binary data; these include compression, saving to "

"a binary file, and sending over a socket."

msgstr ""

"支持 :ref:`bufferobjects` 并且能导出 C-:term:`contiguous` 缓冲的对象。这包括所有 "

":class:`bytes`、:class:`bytearray` 和 :class:`array.array` 对象，以及许多普通 "

":class:`memoryview` 对象。 字节型对象可在多种二进制数据操作中使用；这些操作包括压缩、保存为二进制文件以及通过套接字发送等。"

#: ../../glossary.rst:169

msgid ""

"Some operations need the binary data to be mutable. The documentation often"

" refers to these as \"read-write bytes-like objects\". Example mutable "

"buffer objects include :class:`bytearray` and a :class:`memoryview` of a "

":class:`bytearray`. Other operations require the binary data to be stored in"

" immutable objects (\"read-only bytes-like objects\"); examples of these "

"include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object."

msgstr ""

"某些操作需要可变的二进制数据。这种对象在文档中常被称为“可读写字节类对象”。可变缓冲对象的例子包括 :class:`bytearray` 以及 "

":class:`bytearray` 的 :class:`memoryview`。其他操作要求二进制数据存放于不可变对象 "

"(\"只读字节类对象\")；这种对象的例子包括 :class:`bytes` 以及 :class:`bytes` 对象的 "

":class:`memoryview`。"

#: ../../glossary.rst:177

msgid "bytecode"

msgstr "bytecode -- 字节码"

#: ../../glossary.rst:179

msgid ""

"Python source code is compiled into bytecode, the internal representation of"

" a Python program in the CPython interpreter. The bytecode is also cached "

"in ``.pyc`` files so that executing the same file is faster the second time "

"(recompilation from source to bytecode can be avoided). This \"intermediate"

" language\" is said to run on a :term:`virtual machine` that executes the "

"machine code corresponding to each bytecode. Do note that bytecodes are not "

"expected to work between different Python virtual machines, nor to be stable"

" between Python releases."

msgstr ""

"Python 源代码会被编译为字节码，即 CPython 解释器中表示 Python 程序的内部代码。字节码还会缓存在 ``.pyc`` "

"文件中，这样第二次执行同一文件时速度更快（可以免去将源码重新编译为字节码）。这种 \"中间语言\" 运行在根据字节码执行相应机器码的 "

":term:`virtual machine` 之上。请注意不同 Python 虚拟机上的字节码不一定通用，也不一定能在不同 Python 版本上兼容。"

#: ../../glossary.rst:189

msgid ""

"A list of bytecode instructions can be found in the documentation for "

":ref:`the dis module <bytecodes>`."

msgstr "字节码指令列表可以在 :ref:`dis 模块 <bytecodes>` 的文档中查看。"

#: ../../glossary.rst:191

msgid "callback"

msgstr "callback -- 回调"

#: ../../glossary.rst:193

msgid ""

"A subroutine function which is passed as an argument to be executed at some "

"point in the future."

msgstr "一个作为参数被传入以用以在未来的某个时刻被调用的子例程函数。"

#: ../../glossary.rst:195

msgid "class"

msgstr "class"

#: ../../glossary.rst:197

msgid ""

"A template for creating user-defined objects. Class definitions normally "

"contain method definitions which operate on instances of the class."

msgstr "用来创建用户定义对象的模板。类定义通常包含对该类的实例进行操作的方法定义。"

#: ../../glossary.rst:200

msgid "class variable"

msgstr "class variable -- 类变量"

#: ../../glossary.rst:202

msgid ""

"A variable defined in a class and intended to be modified only at class "

"level (i.e., not in an instance of the class)."

msgstr "在类中定义的变量，并且仅限在类的层级上修改 (而不是在类的实例中修改)。"

#: ../../glossary.rst:204

msgid "coercion"

msgstr "coercion -- 强制类型转换"

#: ../../glossary.rst:206

msgid ""

"The implicit conversion of an instance of one type to another during an "

"operation which involves two arguments of the same type. For example, "

"``int(3.15)`` converts the floating point number to the integer ``3``, but "

"in ``3+4.5``, each argument is of a different type (one int, one float), and"

" both must be converted to the same type before they can be added or it will"

" raise a :exc:`TypeError`. Without coercion, all arguments of even "

"compatible types would have to be normalized to the same value by the "

"programmer, e.g., ``float(3)+4.5`` rather than just ``3+4.5``."

msgstr ""

"在包含两个相同类型参数的操作中，一种类型的实例隐式地转换为另一种类型。例如，``int(3.15)`` 是将原浮点数转换为整型数 ``3``，但在 "

"``3+4.5`` 中，参数的类型不一致（一个是 int, 一个是 float），两者必须转换为相同类型才能相加，否则将引发 "

":exc:`TypeError`。如果没有强制类型转换机制，程序员必须将所有可兼容参数归一化为相同类型，例如要写成 ``float(3)+4.5`` "

"而不是 ``3+4.5``。"

#: ../../glossary.rst:214

msgid "complex number"

msgstr "complex number -- 复数"

#: ../../glossary.rst:216

msgid ""

"An extension of the familiar real number system in which all numbers are "

"expressed as a sum of a real part and an imaginary part. Imaginary numbers "

"are real multiples of the imaginary unit (the square root of ``-1``), often "

"written ``i`` in mathematics or ``j`` in engineering. Python has built-in "

"support for complex numbers, which are written with this latter notation; "

"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``. To get "

"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`. "

"Use of complex numbers is a fairly advanced mathematical feature. If you're"

" not aware of a need for them, it's almost certain you can safely ignore "

"them."

msgstr ""

"对普通实数系统的扩展，其中所有数字都被表示为一个实部和一个虚部的和。虚数是虚数单位（``-1`` 的平方根）的实倍数，通常在数学中写为 "

"``i``，在工程学中写为 ``j``。Python 内置了对复数的支持，采用工程学标记方式；虚部带有一个 ``j`` 后缀，例如 "

"``3+1j``。如果需要 :mod:`math` 模块内对象的对应复数版本，请使用 "

":mod:`cmath`，复数的使用是一个比较高级的数学特性。如果你感觉没有必要，忽略它们也几乎不会有任何问题。"

#: ../../glossary.rst:226

msgid "context manager"

msgstr "context manager -- 上下文管理器"

#: ../../glossary.rst:228

msgid ""

"An object which controls the environment seen in a :keyword:`with` statement"

" by defining :meth:`__enter__` and :meth:`__exit__` methods. See :pep:`343`."

msgstr ""

"在 :keyword:`with` 语句中使用，通过定义 :meth:`__enter__` 和 :meth:`__exit__` "

"方法来控制环境状态的对象。参见 :pep:`343`。"

#: ../../glossary.rst:231

msgid "context variable"

msgstr "context variable -- 上下文变量"

#: ../../glossary.rst:233

msgid ""

"A variable which can have different values depending on its context. This is"

" similar to Thread-Local Storage in which each execution thread may have a "

"different value for a variable. However, with context variables, there may "

"be several contexts in one execution thread and the main usage for context "

"variables is to keep track of variables in concurrent asynchronous tasks. "

"See :mod:`contextvars`."

msgstr ""

"一种根据其所属的上下文可以具有不同的值的变量。 这类似于在线程局部存储中每个执行线程可以具有不同的变量值。 "

"不过，对于上下文变量来说，一个执行线程中可能会有多个上下文，而上下文变量的主要用途是对并发异步任务中变量进行追踪。 参见 "

":mod:`contextvars`。"

#: ../../glossary.rst:240

msgid "contiguous"

msgstr "contiguous -- 连续"

#: ../../glossary.rst:244

msgid ""

"A buffer is considered contiguous exactly if it is either *C-contiguous* or "

"*Fortran contiguous*. Zero-dimensional buffers are C and Fortran "

"contiguous. In one-dimensional arrays, the items must be laid out in memory"

" next to each other, in order of increasing indexes starting from zero. In "

"multidimensional C-contiguous arrays, the last index varies the fastest when"

" visiting items in order of memory address. However, in Fortran contiguous "

"arrays, the first index varies the fastest."

msgstr ""

"一个缓冲如果是 *C 连续* 或 *Fortran 连续* 就会被认为是连续的。零维缓冲是 C 和 Fortran "

"连续的。在一维数组中，所有条目必须在内存中彼此相邻地排列，采用从零开始的递增索引顺序。在多维 "

"C-连续数组中，当按内存地址排列时用最后一个索引访问条目时速度最快。但是在 Fortran 连续数组中则是用第一个索引最快。"

#: ../../glossary.rst:252

msgid "coroutine"

msgstr "coroutine -- 协程"

#: ../../glossary.rst:254

msgid ""

"Coroutines are a more generalized form of subroutines. Subroutines are "

"entered at one point and exited at another point. Coroutines can be "

"entered, exited, and resumed at many different points. They can be "

"implemented with the :keyword:`async def` statement. See also :pep:`492`."

msgstr ""

"协程是子例程的更一般形式。 子例程可以在某一点进入并在另一点退出。 协程则可以在许多不同的点上进入、退出和恢复。 它们可通过 "

":keyword:`async def` 语句来实现。 参见 :pep:`492`。"

#: ../../glossary.rst:259

msgid "coroutine function"

msgstr "coroutine function -- 协程函数"

#: ../../glossary.rst:261

msgid ""

"A function which returns a :term:`coroutine` object. A coroutine function "

"may be defined with the :keyword:`async def` statement, and may contain "

":keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords."

" These were introduced by :pep:`492`."

msgstr ""

"返回一个 :term:`coroutine` 对象的函数。协程函数可通过 :keyword:`async def` 语句来定义，并可能包含 "

":keyword:`await`、:keyword:`async for` 和 :keyword:`async with` 关键字。这些特性是由 "

":pep:`492` 引入的。"

#: ../../glossary.rst:266

msgid "CPython"

msgstr "CPython"

#: ../../glossary.rst:268

msgid ""

"The canonical implementation of the Python programming language, as "

"distributed on `python.org <https://www.python.org>`_. The term \"CPython\""

" is used when necessary to distinguish this implementation from others such "

"as Jython or IronPython."

msgstr ""

"Python 编程语言的规范实现，在 `python.org <https://www.python.org>`_ 上发布。\"CPython\" "

"一词用于在必要时将此实现与其他实现例如 Jython 或 IronPython 相区别。"

#: ../../glossary.rst:272

msgid "decorator"

msgstr "decorator -- 装饰器"

#: ../../glossary.rst:274

msgid ""

"A function returning another function, usually applied as a function "

"transformation using the ``@wrapper`` syntax. Common examples for "

"decorators are :func:`classmethod` and :func:`staticmethod`."

msgstr ""

"返回值为另一个函数的函数，通常使用 ``@wrapper`` 语法形式来进行函数变换。 装饰器的常见例子包括 :func:`classmethod` 和"

" :func:`staticmethod`。"

#: ../../glossary.rst:278

msgid ""

"The decorator syntax is merely syntactic sugar, the following two function "

"definitions are semantically equivalent::"

msgstr "装饰器语法只是一种语法糖，以下两个函数定义在语义上完全等价::"

#: ../../glossary.rst:289

msgid ""

"The same concept exists for classes, but is less commonly used there. See "

"the documentation for :ref:`function definitions <function>` and :ref:`class"

" definitions <class>` for more about decorators."

msgstr ""

"同样的概念也适用于类，但通常较少这样使用。有关装饰器的详情可参见 :ref:`函数定义 <function>` 和 :ref:`类定义 <class>`"

" 的文档。"

#: ../../glossary.rst:292

msgid "descriptor"

msgstr "descriptor -- 描述器"

#: ../../glossary.rst:294

msgid ""

"Any object which defines the methods :meth:`__get__`, :meth:`__set__`, or "

":meth:`__delete__`. When a class attribute is a descriptor, its special "

"binding behavior is triggered upon attribute lookup. Normally, using *a.b* "

"to get, set or delete an attribute looks up the object named *b* in the "

"class dictionary for *a*, but if *b* is a descriptor, the respective "

"descriptor method gets called. Understanding descriptors is a key to a deep"

" understanding of Python because they are the basis for many features "

"including functions, methods, properties, class methods, static methods, and"

" reference to super classes."

msgstr ""

"任何定义了 :meth:`__get__`, :meth:`__set__` 或 :meth:`__delete__` "

"方法的对象。当一个类属性为描述器时，它的特殊绑定行为就会在属性查找时被触发。通常情况下，使用 *a.b* 来获取、设置或删除一个属性时会在 *a* "

"的类字典中查找名称为 *b* 的对象，但如果 *b* 是一个描述器，则会调用对应的描述器方法。理解描述器的概念是更深层次理解 Python "

"的关键，因为这是许多重要特性的基础，包括函数、方法、属性、类方法、静态方法以及对超类的引用等等。"

#: ../../glossary.rst:304

msgid ""

"For more information about descriptors' methods, see :ref:`descriptors` or "

"the :ref:`Descriptor How To Guide <descriptorhowto>`."

msgstr ""

"有关描述器的方法的更多信息，请参阅 :ref:`descriptors` 或 :ref:`描述器使用指南 <descriptorhowto>`。"

#: ../../glossary.rst:306

msgid "dictionary"

msgstr "dictionary -- 字典"

#: ../../glossary.rst:308

msgid ""

"An associative array, where arbitrary keys are mapped to values. The keys "

"can be any object with :meth:`__hash__` and :meth:`__eq__` methods. Called a"

" hash in Perl."

msgstr ""

"一个关联数组，其中的任意键都映射到相应的值。键可以是任何具有 :meth:`__hash__` 和 :meth:`__eq__` 方法的对象。在 "

"Perl 语言中称为 hash。"

#: ../../glossary.rst:311

msgid "dictionary comprehension"

msgstr "dictionary comprehension -- 字典推导式"

#: ../../glossary.rst:313

msgid ""

"A compact way to process all or part of the elements in an iterable and "

"return a dictionary with the results. ``results = {n: n ** 2 for n in "

"range(10)}`` generates a dictionary containing key ``n`` mapped to value ``n"

" ** 2``. See :ref:`comprehensions`."

msgstr ""

"处理一个可迭代对象中的所有或部分元素并返回结果字典的一种紧凑写法。 ``results = {n: n ** 2 for n in "

"range(10)}`` 将生成一个由键 ``n`` 到值 ``n ** 2`` 的映射构成的字典。 参见 :ref:`comprehensions`。"

#: ../../glossary.rst:317

msgid "dictionary view"

msgstr "dictionary view -- 字典视图"

#: ../../glossary.rst:319

msgid ""

"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and "

":meth:`dict.items` are called dictionary views. They provide a dynamic view "

"on the dictionary’s entries, which means that when the dictionary changes, "

"the view reflects these changes. To force the dictionary view to become a "

"full list use ``list(dictview)``. See :ref:`dict-views`."

msgstr ""

"从 :meth:`dict.keys`, :meth:`dict.values` 和 :meth:`dict.items` "

"返回的对象被称为字典视图。它们提供了字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变。要将字典视图强制转换为真正的列表，可使用 "

"``list(dictview)``。参见 :ref:`dict-views`。"

#: ../../glossary.rst:325

msgid "docstring"

msgstr "docstring -- 文档字符串"

#: ../../glossary.rst:327

msgid ""

"A string literal which appears as the first expression in a class, function "

"or module. While ignored when the suite is executed, it is recognized by "

"the compiler and put into the :attr:`__doc__` attribute of the enclosing "

"class, function or module. Since it is available via introspection, it is "

"the canonical place for documentation of the object."

msgstr ""

"作为类、函数或模块之内的第一个表达式出现的字符串字面值。它在代码执行时会被忽略，但会被解释器识别并放入所在类、函数或模块的 "

":attr:`__doc__` 属性中。由于它可用于代码内省，因此是对象存放文档的规范位置。"

#: ../../glossary.rst:333

msgid "duck-typing"

msgstr "duck-typing -- 鸭子类型"

#: ../../glossary.rst:335

msgid ""

"A programming style which does not look at an object's type to determine if "

"it has the right interface; instead, the method or attribute is simply "

"called or used (\"If it looks like a duck and quacks like a duck, it must be"

" a duck.\") By emphasizing interfaces rather than specific types, well-"

"designed code improves its flexibility by allowing polymorphic substitution."

" Duck-typing avoids tests using :func:`type` or :func:`isinstance`. (Note,"

" however, that duck-typing can be complemented with :term:`abstract base "

"classes <abstract base class>`.) Instead, it typically employs "

":func:`hasattr` tests or :term:`EAFP` programming."

msgstr ""

"指一种编程风格，它并不依靠查找对象类型来确定其是否具有正确的接口，而是直接调用或使用其方法或属性（“看起来像鸭子，叫起来也像鸭子，那么肯定就是鸭子。”）由于强调接口而非特定类型，设计良好的代码可通过允许多态替代来提升灵活性。鸭子类型避免使用"

" :func:`type` 或 :func:`isinstance` 检测。(但要注意鸭子类型可以使用 :term:`抽象基类 <abstract "

"base class>` 作为补充。) 而往往会采用 :func:`hasattr` 检测或是 :term:`EAFP` 编程。"

#: ../../glossary.rst:344

msgid "EAFP"

msgstr "EAFP"

#: ../../glossary.rst:346

msgid ""

"Easier to ask for forgiveness than permission. This common Python coding "

"style assumes the existence of valid keys or attributes and catches "

"exceptions if the assumption proves false. This clean and fast style is "

"characterized by the presence of many :keyword:`try` and :keyword:`except` "

"statements. The technique contrasts with the :term:`LBYL` style common to "

"many other languages such as C."

msgstr ""

"“求原谅比求许可更容易”的英文缩写。这种 Python "

"常用代码编写风格会假定所需的键或属性存在，并在假定错误时捕获异常。这种简洁快速风格的特点就是大量运用 :keyword:`try` 和 "

":keyword:`except` 语句。于其相对的则是所谓 :term:`LBYL` 风格，常见于 C 等许多其他语言。"

#: ../../glossary.rst:352

msgid "expression"

msgstr "expression -- 表达式"

#: ../../glossary.rst:354

msgid ""

"A piece of syntax which can be evaluated to some value. In other words, an "

"expression is an accumulation of expression elements like literals, names, "

"attribute access, operators or function calls which all return a value. In "

"contrast to many other languages, not all language constructs are "

"expressions. There are also :term:`statement`\\s which cannot be used as "

"expressions, such as :keyword:`while`. Assignments are also statements, not"

" expressions."

msgstr ""

"可以求出某个值的语法单元。 换句话说，一个表达式就是表达元素例如字面值、名称、属性访问、运算符或函数调用的汇总，它们最终都会返回一个值。 "

"与许多其他语言不同，并非所有语言构件都是表达式。 还存在不能被用作表达式的 :term:`statement`，例如 :keyword:`while`。"

" 赋值也是属于语句而非表达式。"

#: ../../glossary.rst:361

msgid "extension module"

msgstr "extension module -- 扩展模块"

#: ../../glossary.rst:363

msgid ""

"A module written in C or C++, using Python's C API to interact with the core"

" and with user code."

msgstr "以 C 或 C++ 编写的模块，使用 Python 的 C API 来与语言核心以及用户代码进行交互。"

#: ../../glossary.rst:365

msgid "f-string"

msgstr "f-string -- f-字符串"

#: ../../glossary.rst:367

msgid ""

"String literals prefixed with ``'f'`` or ``'F'`` are commonly called "

"\"f-strings\" which is short for :ref:`formatted string literals "

"<f-strings>`. See also :pep:`498`."

msgstr ""

"带有 ``'f'`` 或 ``'F'`` 前缀的字符串字面值通常被称为“f-字符串”即 :ref:`格式化字符串字面值 <f-strings>` "

"的简写。参见 :pep:`498`。"

#: ../../glossary.rst:370

msgid "file object"

msgstr "file object -- 文件对象"

#: ../../glossary.rst:372

msgid ""

"An object exposing a file-oriented API (with methods such as :meth:`read()` "

"or :meth:`write()`) to an underlying resource. Depending on the way it was "

"created, a file object can mediate access to a real on-disk file or to "

"another type of storage or communication device (for example standard "

"input/output, in-memory buffers, sockets, pipes, etc.). File objects are "

"also called :dfn:`file-like objects` or :dfn:`streams`."

msgstr ""

"对外提供面向文件 API 以使用下层资源的对象（带有 :meth:`read()` 或 :meth:`write()` "

"这样的方法）。根据其创建方式的不同，文件对象可以处理对真实磁盘文件，对其他类型存储，或是对通讯设备的访问（例如标准输入/输出、内存缓冲区、套接字、管道等等）。文件对象也被称为"

" :dfn:`文件类对象` 或 :dfn:`流`。"

#: ../../glossary.rst:380

msgid ""

"There are actually three categories of file objects: raw :term:`binary files"

" <binary file>`, buffered :term:`binary files <binary file>` and :term:`text"

" files <text file>`. Their interfaces are defined in the :mod:`io` module. "

"The canonical way to create a file object is by using the :func:`open` "

"function."

msgstr ""

"实际上共有三种类别的文件对象: 原始 :term:`二进制文件 <binary file>`, 缓冲 :term:`二进制文件 <binary "

"file>` 以及 :term:`文本文件 <text file>`。它们的接口定义均在 :mod:`io` 模块中。 创建文件对象的规范方式是使用 "

":func:`open` 函数。"

#: ../../glossary.rst:385

msgid "file-like object"

msgstr "file-like object -- 文件型对象"

#: ../../glossary.rst:387

msgid "A synonym for :term:`file object`."

msgstr ":term:`file object` 的同义词。"

#: ../../glossary.rst:388

msgid "finder"

msgstr "finder -- 查找器"

#: ../../glossary.rst:390

msgid ""

"An object that tries to find the :term:`loader` for a module that is being "

"imported."

msgstr "一种会尝试查找被导入模块的 :term:`loader` 的对象。"

#: ../../glossary.rst:393

msgid ""

"Since Python 3.3, there are two types of finder: :term:`meta path finders "

"<meta path finder>` for use with :data:`sys.meta_path`, and :term:`path "

"entry finders <path entry finder>` for use with :data:`sys.path_hooks`."

msgstr ""

"从 Python 3.3 起存在两种类型的查找器: :term:`元路径查找器 <meta path finder>` 配合 "

":data:`sys.meta_path` 使用，以及 :term:`path entry finders <path entry finder>` "

"配合 :data:`sys.path_hooks` 使用。"

#: ../../glossary.rst:397

msgid "See :pep:`302`, :pep:`420` and :pep:`451` for much more detail."

msgstr "更多详情可参见 :pep:`302`, :pep:`420` 和 :pep:`451`。"

#: ../../glossary.rst:398

msgid "floor division"

msgstr "floor division -- 向下取整除法"

#: ../../glossary.rst:400

msgid ""

"Mathematical division that rounds down to nearest integer. The floor "

"division operator is ``//``. For example, the expression ``11 // 4`` "

"evaluates to ``2`` in contrast to the ``2.75`` returned by float true "

"division. Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` "

"rounded *downward*. See :pep:`238`."

msgstr ""

"向下舍入到最接近的整数的数学除法。向下取整除法的运算符是 ``//`` 。例如，表达式 ``11 // 4`` 的计算结果是 ``2`` "

"，而与之相反的是浮点数的真正除法返回 ``2.75`` 。注意 ``(-11) // 4`` 会返回 ``-3`` 因为这是 ``-2.75`` "

"*向下* 舍入得到的结果。见 :pep:`238` 。"

#: ../../glossary.rst:405

msgid "function"

msgstr "function -- 函数"

#: ../../glossary.rst:407

msgid ""

"A series of statements which returns some value to a caller. It can also be "

"passed zero or more :term:`arguments <argument>` which may be used in the "

"execution of the body. See also :term:`parameter`, :term:`method`, and the "

":ref:`function` section."

msgstr ""

"可以向调用者返回某个值的一组语句。还可以向其传入零个或多个 :term:`参数 <argument>` 并在函数体执行中被使用。另见 "

":term:`parameter`, :term:`method` 和 :ref:`function` 等节。"

#: ../../glossary.rst:411

msgid "function annotation"

msgstr "function annotation -- 函数标注"

#: ../../glossary.rst:413

msgid "An :term:`annotation` of a function parameter or return value."

msgstr "即针对函数形参或返回值的 :term:`annotation` 。"

#: ../../glossary.rst:415

msgid ""

"Function annotations are usually used for :term:`type hints <type hint>`: "

"for example, this function is expected to take two :class:`int` arguments "

"and is also expected to have an :class:`int` return value::"

msgstr ""

"函数标注通常用于 :term:`类型提示 <type hint>`：例如以下函数预期接受两个 :class:`int` 参数并预期返回一个 "

":class:`int` 值::"

#: ../../glossary.rst:423

msgid "Function annotation syntax is explained in section :ref:`function`."

msgstr "函数标注语法的详解见 :ref:`function` 一节。"

#: ../../glossary.rst:425

msgid ""

"See :term:`variable annotation` and :pep:`484`, which describe this "

"functionality."

msgstr ""

#: ../../glossary.rst:427

msgid "__future__"

msgstr "__future__"

#: ../../glossary.rst:429

msgid ""

"A :ref:`future statement <future>`, ``from __future__ import <feature>``, "

"directs the compiler to compile the current module using syntax or semantics"

" that will become standard in a future release of Python. The "

":mod:`__future__` module documents the possible values of *feature*. By "

"importing this module and evaluating its variables, you can see when a new "

"feature was first added to the language and when it will (or did) become the"

" default::"

msgstr ""

":ref:`future 语句 <future>`, ``from __future__ import <feature>`` 指示编译器使用将在未来的"

" Python 发布版中成为标准的语法和语义来编译当前模块。 :mod:`__future__` 模块文档记录了可能 的 *feature* 取值。 "

"通过导入此模块并对其变量求值，你可以看到每项新特性在何时被首次加入到该语言中以及它将（或已）在何时成为默认::"

#: ../../glossary.rst:440

msgid "garbage collection"

msgstr "garbage collection -- 垃圾回收"

#: ../../glossary.rst:442

msgid ""

"The process of freeing memory when it is not used anymore. Python performs "

"garbage collection via reference counting and a cyclic garbage collector "

"that is able to detect and break reference cycles. The garbage collector "

"can be controlled using the :mod:`gc` module."

msgstr ""

"释放不再被使用的内存空间的过程。Python 是通过引用计数和一个能够检测和打破循环引用的循环垃圾回收器来执行垃圾回收的。可以使用 :mod:`gc` "

"模块来控制垃圾回收器。"

#: ../../glossary.rst:448

msgid "generator"

msgstr "generator -- 生成器"

#: ../../glossary.rst:450

msgid ""

"A function which returns a :term:`generator iterator`. It looks like a "

"normal function except that it contains :keyword:`yield` expressions for "

"producing a series of values usable in a for-loop or that can be retrieved "

"one at a time with the :func:`next` function."

msgstr ""

"返回一个 :term:`generator iterator` 的函数。它看起来很像普通函数，不同点在于其包含 :keyword:`yield` "

"表达式以便产生一系列值供给 for-循环使用或是通过 :func:`next` 函数逐一获取。"

#: ../../glossary.rst:455

msgid ""

"Usually refers to a generator function, but may refer to a *generator "

"iterator* in some contexts. In cases where the intended meaning isn't "

"clear, using the full terms avoids ambiguity."

msgstr "通常是指生成器函数，但在某些情况下也可能是指 *生成器迭代器*。如果需要清楚表达具体含义，请使用全称以避免歧义。"

#: ../../glossary.rst:458

msgid "generator iterator"

msgstr "generator iterator -- 生成器迭代器"

#: ../../glossary.rst:460

msgid "An object created by a :term:`generator` function."

msgstr ":term:`generator` 函数所创建的对象。"

#: ../../glossary.rst:462

msgid ""

"Each :keyword:`yield` temporarily suspends processing, remembering the "

"location execution state (including local variables and pending try-"

"statements). When the *generator iterator* resumes, it picks up where it "

"left off (in contrast to functions which start fresh on every invocation)."

msgstr ""

"每个 :keyword:`yield` 会临时暂停处理，记住当前位置执行状态（包括局部变量和挂起的 try 语句）。当该 *生成器迭代器* "

"恢复时，它会从离开位置继续执行（这与每次调用都从新开始的普通函数差别很大）。"

#: ../../glossary.rst:469

msgid "generator expression"

msgstr "generator expression -- 生成器表达式"

#: ../../glossary.rst:471

msgid ""

"An expression that returns an iterator. It looks like a normal expression "

"followed by a :keyword:`!for` clause defining a loop variable, range, and an"

" optional :keyword:`!if` clause. The combined expression generates values "

"for an enclosing function::"

msgstr ""

"返回迭代器的表达式。它看起来像一个普通表达式，后面跟着一个:keyword:`!for` "

"子句，定义了一个循环变量、范围和一个可选的:keyword:`!if` 子句。以下复合表达式会为外层函数生成一系列值:::"

#: ../../glossary.rst:478

msgid "generic function"

msgstr "generic function -- 泛型函数"

#: ../../glossary.rst:480

msgid ""

"A function composed of multiple functions implementing the same operation "

"for different types. Which implementation should be used during a call is "

"determined by the dispatch algorithm."

msgstr "为不同的类型实现相同操作的多个函数所组成的函数。在调用时会由调度算法来确定应该使用哪个实现。"

#: ../../glossary.rst:484

msgid ""

"See also the :term:`single dispatch` glossary entry, the "

":func:`functools.singledispatch` decorator, and :pep:`443`."

msgstr ""

"另请参见 :term:`single dispatch` 术语表条目、:func:`functools.singledispatch` 装饰器以及 "

":pep:`443`。"

#: ../../glossary.rst:486

msgid "generic type"

msgstr "generic type -- 泛型"

#: ../../glossary.rst:488

msgid ""

"A :term:`type` that can be parameterized; typically a :ref:`container "

"class<sequence-types>` such as :class:`list` or :class:`dict`. Used for "

":term:`type hints <type hint>` and :term:`annotations <annotation>`."

msgstr ""

"可参数化的 :term:`type`；通常为 :class:`list` 或 :class:`dict` 这样的 :ref:`容器类 "

"<sequence-types>`。用于 :term:`类型提示 <type hint>` 和 :term:`注解 <annotation>`。"

#: ../../glossary.rst:493

msgid ""

"For more details, see :ref:`generic alias types<types-genericalias>`, "

":pep:`483`, :pep:`484`, :pep:`585`, and the :mod:`typing` module."

msgstr ""

"更多细节参见 :ref:`泛型别名类型 <types-genericalias>`、:pep:`483`、:pep:`484`、:pep:`585` 和"

" :mod:`typing` 模块。"

#: ../../glossary.rst:495

msgid "GIL"

msgstr "GIL"

#: ../../glossary.rst:497

msgid "See :term:`global interpreter lock`."

msgstr "参见 :term:`global interpreter lock`。"

#: ../../glossary.rst:498

msgid "global interpreter lock"

msgstr "global interpreter lock -- 全局解释器锁"