datamodel.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2026, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# python-doc bot, 2025
# Freesand Leo <yuqinju@163.com>, 2026
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-01-21 16:04+0000\n"
"PO-Revision-Date: 2025-07-18 19:59+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2026\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"

#: ../../reference/datamodel.rst:6
msgid "Data model"
msgstr "数据模型"

#: ../../reference/datamodel.rst:12
msgid "Objects, values and types"
msgstr "对象、值与类型"

#: ../../reference/datamodel.rst:18
msgid ""
":dfn:`Objects` are Python's abstraction for data.  All data in a Python "
"program is represented by objects or by relations between objects. (In a "
"sense, and in conformance to Von Neumann's model of a \"stored program "
"computer\", code is also represented by objects.)"
msgstr ""
":dfn:`对象` 是 Python 中对数据的抽象。 Python 程序中的所有数据都是由对象或对象间关系来表示的。 "
"（从某种意义上说，按照冯·诺依曼的“存储程序计算机”模型，代码本身也是由对象来表示的。）"

#: ../../reference/datamodel.rst:35
msgid ""
"Every object has an identity, a type and a value.  An object's *identity* "
"never changes once it has been created; you may think of it as the object's "
"address in memory.  The :keyword:`is` operator compares the identity of two "
"objects; the :func:`id` function returns an integer representing its "
"identity."
msgstr ""
"每个对象都有相应的标识号、类型和值。 一个对象被创建后它的 *标识号* 就绝不会改变；你可以将其理解为该对象在内存中的地址。 :keyword:`is`"
" 运算符比较两个对象的标识号是否相同；:func:`id` 函数返回一个代表其标识号的整数。"

#: ../../reference/datamodel.rst:42
msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored."
msgstr "在 CPython 中，``id(x)`` 就是存放 ``x`` 的内存的地址。"

#: ../../reference/datamodel.rst:44
msgid ""
"An object's type determines the operations that the object supports (e.g., "
"\"does it have a length?\") and also defines the possible values for objects"
" of that type.  The :func:`type` function returns an object's type (which is"
" an object itself).  Like its identity, an object's :dfn:`type` is also "
"unchangeable. [#]_"
msgstr ""
"对象的类型决定该对象所支持的操作 (例如 \"对象是否有长度属性？\") 并且定义了该类型的对象可能的取值。:func:`type` "
"函数能返回一个对象的类型 (类型本身也是对象)。与编号一样，一个对象的 :dfn:`类型` 也是不可改变的。[#]_"

#: ../../reference/datamodel.rst:50
msgid ""
"The *value* of some objects can change.  Objects whose value can change are "
"said to be *mutable*; objects whose value is unchangeable once they are "
"created are called *immutable*. (The value of an immutable container object "
"that contains a reference to a mutable object can change when the latter's "
"value is changed; however the container is still considered immutable, "
"because the collection of objects it contains cannot be changed.  So, "
"immutability is not strictly the same as having an unchangeable value, it is"
" more subtle.) An object's mutability is determined by its type; for "
"instance, numbers, strings and tuples are immutable, while dictionaries and "
"lists are mutable."
msgstr ""
"有些对象的 *值* 可以改变。值可以改变的对象被称为 *可变对象*；值不可以改变的对象就被称为 "
"*不可变对象*。(一个不可变容器对象如果包含对可变对象的引用，当后者的值改变时，前者的值也会改变；但是该容器仍属于不可变对象，因为它所包含的对象集是不会改变的。因此，不可变并不严格等同于值不能改变，实际含义要更微妙。)"
" 一个对象的可变性是由其类型决定的；例如，数字、字符串和元组是不可变的，而字典和列表是可变的。"

#: ../../reference/datamodel.rst:65
msgid ""
"Objects are never explicitly destroyed; however, when they become "
"unreachable they may be garbage-collected.  An implementation is allowed to "
"postpone garbage collection or omit it altogether --- it is a matter of "
"implementation quality how garbage collection is implemented, as long as no "
"objects are collected that are still reachable."
msgstr ""
"对象绝不会被显式地销毁；然而，当无法访问时它们可能会被作为垃圾回收。允许具体的实现推迟垃圾回收或完全省略此机制 --- "
"如何实现垃圾回收是实现的质量问题，只要可访问的对象不会被回收即可。"

#: ../../reference/datamodel.rst:73
msgid ""
"CPython currently uses a reference-counting scheme with (optional) delayed "
"detection of cyclically linked garbage, which collects most objects as soon "
"as they become unreachable, but is not guaranteed to collect garbage "
"containing circular references.  See the documentation of the :mod:`gc` "
"module for information on controlling the collection of cyclic garbage. "
"Other implementations act differently and CPython may change. Do not depend "
"on immediate finalization of objects when they become unreachable (so you "
"should always close files explicitly)."
msgstr ""
"CPython 目前使用带有 (可选) "
"延迟检测循环链接垃圾的引用计数方案，会在对象不可访问时立即回收其中的大部分，但不保证回收包含循环引用的垃圾。请查看 :mod:`gc` "
"模块的文档了解如何控制循环垃圾的收集相关信息。其他实现会有不同的行为方式，CPython 现有方式也可能改变。不要依赖不可访问对象的立即终结机制 "
"(所以你应当总是显式地关闭文件)。"

#: ../../reference/datamodel.rst:82
msgid ""
"Note that the use of the implementation's tracing or debugging facilities "
"may keep objects alive that would normally be collectable. Also note that "
"catching an exception with a :keyword:`try`...\\ :keyword:`except` statement"
" may keep objects alive."
msgstr ""
"注意：使用实现的跟踪或调试功能可能令正常情况下会被回收的对象继续存活。还要注意通过 :keyword:`try`...\\ "
":keyword:`except` 语句捕捉异常也可能令对象保持存活。"

#: ../../reference/datamodel.rst:87
msgid ""
"Some objects contain references to \"external\" resources such as open files"
" or windows.  It is understood that these resources are freed when the "
"object is garbage-collected, but since garbage collection is not guaranteed "
"to happen, such objects also provide an explicit way to release the external"
" resource, usually a :meth:`!close` method. Programs are strongly "
"recommended to explicitly close such objects.  The :keyword:`try`...\\ "
":keyword:`finally` statement and the :keyword:`with` statement provide "
"convenient ways to do this."
msgstr ""
"有些对象包含对“外部”资源如打开的文件或窗口的引用。 "
"当对象被作为垃圾回收时这些资源也应该会被释放，但由于垃圾回收并不确保发生，这些对象还提供了明确地释放外部资源的操作，通常为一个 "
":meth:`!close` 方法。 强烈推荐在程序中显式关闭此类对象。 :keyword:`try`...\\ :keyword:`finally` "
"语句和 :keyword:`with` 语句提供了进行此种操作的更便捷方式。"

#: ../../reference/datamodel.rst:97
msgid ""
"Some objects contain references to other objects; these are called "
"*containers*. Examples of containers are tuples, lists and dictionaries.  "
"The references are part of a container's value.  In most cases, when we talk"
" about the value of a container, we imply the values, not the identities of "
"the contained objects; however, when we talk about the mutability of a "
"container, only the identities of the immediately contained objects are "
"implied.  So, if an immutable container (like a tuple) contains a reference "
"to a mutable object, its value changes if that mutable object is changed."
msgstr ""
"有些对象包含对其他对象的引用；它们被称为 "
"*容器*。容器的例子有元组、列表和字典等。这些引用是容器对象值的组成部分。在多数情况下，当谈论一个容器的值时，我们是指所包含对象的值而不是其编号；但是，当我们谈论一个容器的可变性时，则仅指其直接包含的对象的编号。因此，如果一个不可变容器"
" (例如元组) 包含对一个可变对象的引用，则当该可变对象被改变时容器的值也会改变。"

#: ../../reference/datamodel.rst:106
msgid ""
"Types affect almost all aspects of object behavior.  Even the importance of "
"object identity is affected in some sense: for immutable types, operations "
"that compute new values may actually return a reference to any existing "
"object with the same type and value, while for mutable objects this is not "
"allowed. For example, after ``a = 1; b = 1``, *a* and *b* may or may not "
"refer to the same object with the value one, depending on the "
"implementation. This is because :class:`int` is an immutable type, so the "
"reference to ``1`` can be reused. This behaviour depends on the "
"implementation used, so should not be relied upon, but is something to be "
"aware of when making use of object identity tests. However, after ``c = []; "
"d = []``, *c* and *d* are guaranteed to refer to two different, unique, "
"newly created empty lists. (Note that ``e = f = []`` assigns the *same* "
"object to both *e* and *f*.)"
msgstr ""
"类型会影响对象行为的几乎所有方面。 "
"甚至对象标识号的重要性也在某种程度上受到影响：对于不可变类型，计算新值的操作实际上可能返回一个指向具有相同类型和值的任何现存对象的引用，而对于可变对象来说这是不允许的。"
" 例如在 ``a = 1; b = 1`` 之后，*a* 和 *b* 可能会也可能不会指向同一个值为一的对象。 这是因为 :class:`int` "
"是不可变对象，因此对 ``1`` 的引用可以被重用。 此行为依赖于所使用的具体实现，因此不应该依赖它，而在使用对象标识测试时需要注意。 不过，在 ``c"
" = []; d = []`` 之后，*c* 和 *d* 保证会指向两个不同的、独特的、新创建的空列表。 (注意 ``e = f = []`` 会将 "
"*同一个* 对象同时赋值给 *e* 和 *f*。)"

#: ../../reference/datamodel.rst:124
msgid "The standard type hierarchy"
msgstr "标准类型层级结构"

#: ../../reference/datamodel.rst:133
msgid ""
"Below is a list of the types that are built into Python.  Extension modules "
"(written in C, Java, or other languages, depending on the implementation) "
"can define additional types.  Future versions of Python may add types to the"
" type hierarchy (e.g., rational numbers, efficiently stored arrays of "
"integers, etc.), although such additions will often be provided via the "
"standard library instead."
msgstr ""
"以下是 Python 内置类型的列表。扩展模块 (具体实现会以 C, Java 或其他语言编写) 可以定义更多的类型。未来版本的 Python "
"可能会加入更多的类型 (例如有理数、高效存储的整型数组等等)，不过新增类型往往都是通过标准库来提供的。"

#: ../../reference/datamodel.rst:144
msgid ""
"Some of the type descriptions below contain a paragraph listing 'special "
"attributes.'  These are attributes that provide access to the implementation"
" and are not intended for general use.  Their definition may change in the "
"future."
msgstr "以下部分类型的描述中包含有 '特殊属性列表' 段落。这些属性提供对具体实现的访问而非通常使用。它们的定义在未来可能会改变。"

#: ../../reference/datamodel.rst:150 ../../reference/datamodel.rst:152
msgid "None"
msgstr "None"

#: ../../reference/datamodel.rst:154
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the built-in name ``None``. It is used to "
"signify the absence of a value in many situations, e.g., it is returned from"
" functions that don't explicitly return anything. Its truth value is false."
msgstr ""
"此类型只有一种取值。是一个具有此值的单独对象。此对象通过内置名称 ``None`` 访问。在许多情况下它被用来表示空值，例如未显式指明返回值的函数将返回"
" None。它的逻辑值为假。"

#: ../../reference/datamodel.rst:161 ../../reference/datamodel.rst:163
msgid "NotImplemented"
msgstr "NotImplemented"

#: ../../reference/datamodel.rst:165
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the built-in name :data:`NotImplemented`. "
"Numeric methods and rich comparison methods should return this value if they"
" do not implement the operation for the operands provided.  (The interpreter"
" will then try the reflected operation, or some other fallback, depending on"
" the operator.)  It should not be evaluated in a boolean context."
msgstr ""
"此类型只有一种取值。 是一个具有该值的单独对象。 此对象通过内置名称 :data:`NotImplemented` 访问。 "
"数值方法和丰富比较方法如未实现指定运算符表示的运算则应返回该值。 （解释器会根据具体运算符继续尝试反向运算或其他回退操作。） 它不应被解读为布尔值。"

#: ../../reference/datamodel.rst:172
msgid "See :ref:`implementing-the-arithmetic-operations` for more details."
msgstr "详情参见 :ref:`implementing-the-arithmetic-operations`。"

#: ../../reference/datamodel.rst:176
msgid ""
"Evaluating :data:`NotImplemented` in a boolean context is deprecated. While "
"it currently evaluates as true, it will emit a :exc:`DeprecationWarning`. It"
" will raise a :exc:`TypeError` in a future version of Python."
msgstr ""
"对 :data:`NotImplemented` 求布尔值的操作已被弃用。 虽然它目前会被求解为真值，但将同时发出 "
":exc:`DeprecationWarning`。 它将在未来的 Python 版本中引发 :exc:`TypeError`。"

#: ../../reference/datamodel.rst:183 ../../reference/datamodel.rst:184
msgid "Ellipsis"
msgstr "Ellipsis"

#: ../../reference/datamodel.rst:188
msgid ""
"This type has a single value.  There is a single object with this value. "
"This object is accessed through the literal ``...`` or the built-in name "
"``Ellipsis``.  Its truth value is true."
msgstr ""
"此类型只有一种取值。是一个具有此值的单独对象。此对象通过字面值 ``...`` 或内置名称 ``Ellipsis`` 访问。它的逻辑值为真。"

#: ../../reference/datamodel.rst:194
msgid ":class:`numbers.Number`"
msgstr ":class:`numbers.Number`"

#: ../../reference/datamodel.rst:198
msgid ""
"These are created by numeric literals and returned as results by arithmetic "
"operators and arithmetic built-in functions.  Numeric objects are immutable;"
" once created their value never changes.  Python numbers are of course "
"strongly related to mathematical numbers, but subject to the limitations of "
"numerical representation in computers."
msgstr ""
"此类对象由数字字面值创建，并会被作为算术运算符和算术内置函数的返回结果。数字对象是不可变的；一旦创建其值就不再改变。Python "
"中的数字当然非常类似数学中的数字，但也受限于计算机中的数字表示方法。"

#: ../../reference/datamodel.rst:204
msgid ""
"The string representations of the numeric classes, computed by "
":meth:`~object.__repr__` and :meth:`~object.__str__`, have the following "
"properties:"
msgstr ""
"数字类的字符串表示形式，由 :meth:`~object.__repr__` 和 :meth:`~object.__str__` "
"算出，具有以下特征属性:"

#: ../../reference/datamodel.rst:208
msgid ""
"They are valid numeric literals which, when passed to their class "
"constructor, produce an object having the value of the original numeric."
msgstr "它们是有效的数字字面值，当被传给它们的类构造器时，将会产生具有原数字值的对象。"

#: ../../reference/datamodel.rst:212
msgid "The representation is in base 10, when possible."
msgstr "表示形式会在可能的情况下采用 10 进制。"

#: ../../reference/datamodel.rst:214
msgid ""
"Leading zeros, possibly excepting a single zero before a decimal point, are "
"not shown."
msgstr "开头的零，除小数点前可能存在的单个零之外，将不会被显示。"

#: ../../reference/datamodel.rst:217
msgid ""
"Trailing zeros, possibly excepting a single zero after a decimal point, are "
"not shown."
msgstr "末尾的零，除小数点后可能存在的单个零之外，将不会被显示。"

#: ../../reference/datamodel.rst:220
msgid "A sign is shown only when the number is negative."
msgstr "正负号仅在当数字为负值时会被显示。"

#: ../../reference/datamodel.rst:222
msgid ""
"Python distinguishes between integers, floating-point numbers, and complex "
"numbers:"
msgstr "Python 区分整型数、浮点型数和复数："

#: ../../reference/datamodel.rst:227
msgid ":class:`numbers.Integral`"
msgstr ":class:`numbers.Integral`"

#: ../../reference/datamodel.rst:231
msgid ""
"These represent elements from the mathematical set of integers (positive and"
" negative)."
msgstr "此类对象表示数学中整数集合的成员 (包括正数和负数)。"

#: ../../reference/datamodel.rst:237
msgid ""
"The rules for integer representation are intended to give the most "
"meaningful interpretation of shift and mask operations involving negative "
"integers."
msgstr "整型数表示规则的目的是在涉及负整型数的变换和掩码运算时提供最为合理的解释。"

#: ../../reference/datamodel.rst:240
msgid "There are two types of integers:"
msgstr "整型数可细分为两种类型:"

#: ../../reference/datamodel.rst:242
msgid "Integers (:class:`int`)"
msgstr "整型 (:class:`int`)"

#: ../../reference/datamodel.rst:243
msgid ""
"These represent numbers in an unlimited range, subject to available "
"(virtual) memory only.  For the purpose of shift and mask operations, a "
"binary representation is assumed, and negative numbers are represented in a "
"variant of 2's complement which gives the illusion of an infinite string of "
"sign bits extending to the left."
msgstr ""
"此类对象表示任意大小的数字，仅受限于可用的内存 (包括虚拟内存)。在变换和掩码运算中会以二进制表示，负数会以 2 "
"的补码表示，看起来像是符号位向左延伸补满空位。"

#: ../../reference/datamodel.rst:249
msgid "Booleans (:class:`bool`)"
msgstr "布尔型 (:class:`bool`)"

#: ../../reference/datamodel.rst:255
msgid ""
"These represent the truth values False and True.  The two objects "
"representing the values ``False`` and ``True`` are the only Boolean objects."
" The Boolean type is a subtype of the integer type, and Boolean values "
"behave like the values 0 and 1, respectively, in almost all contexts, the "
"exception being that when converted to a string, the strings ``\"False\"`` "
"or ``\"True\"`` are returned, respectively."
msgstr ""
"此类对象表示逻辑值 False 和 True。代表 ``False`` 和 ``True`` "
"值的两个对象是唯二的布尔对象。布尔类型是整型的子类型，两个布尔值在各种场合的行为分别类似于数值 0 和 1，例外情况只有在转换为字符串时分别返回字符串 "
"``\"False\"`` 或 ``\"True\"``。"

#: ../../reference/datamodel.rst:263
msgid ":class:`numbers.Real` (:class:`float`)"
msgstr ":class:`numbers.Real` (:class:`float`)"

#: ../../reference/datamodel.rst:271
msgid ""
"These represent machine-level double precision floating-point numbers. You "
"are at the mercy of the underlying machine architecture (and C or Java "
"implementation) for the accepted range and handling of overflow. Python does"
" not support single-precision floating-point numbers; the savings in "
"processor and memory usage that are usually the reason for using these are "
"dwarfed by the overhead of using objects in Python, so there is no reason to"
" complicate the language with two kinds of floating-point numbers."
msgstr ""
"此类对象表示机器级的双精度浮点数。其所接受的取值范围和溢出处理将受制于底层的机器架构 (以及 C 或 Java 实现)。Python "
"不支持单精度浮点数；支持后者通常的理由是节省处理器和内存消耗，但这点节省相对于在 Python "
"中使用对象的开销来说太过微不足道，因此没有理由包含两种浮点数而令该语言变得复杂。"

#: ../../reference/datamodel.rst:281
msgid ":class:`numbers.Complex` (:class:`complex`)"
msgstr ":class:`numbers.Complex` (:class:`complex`)"

#: ../../reference/datamodel.rst:287
msgid ""
"These represent complex numbers as a pair of machine-level double precision "
"floating-point numbers.  The same caveats apply as for floating-point "
"numbers. The real and imaginary parts of a complex number ``z`` can be "
"retrieved through the read-only attributes ``z.real`` and ``z.imag``."
msgstr ""
"此类对象以一对机器级的双精度浮点数来表示复数值。有关浮点数的附带规则对其同样有效。一个复数值 ``z`` 的实部和虚部可通过只读属性 "
"``z.real`` 和 ``z.imag`` 来获取。"

#: ../../reference/datamodel.rst:294
msgid "Sequences"
msgstr "序列"

#: ../../reference/datamodel.rst:303
msgid ""
"These represent finite ordered sets indexed by non-negative numbers. The "
"built-in function :func:`len` returns the number of items of a sequence. "
"When the length of a sequence is *n*, the index set contains the numbers 0, "
"1, ..., *n*-1.  Item *i* of sequence *a* is selected by ``a[i]``. Some "
"sequences, including built-in sequences, interpret negative subscripts by "
"adding the sequence length. For example, ``a[-2]`` equals ``a[n-2]``, the "
"second to last item of sequence a with length ``n``."
msgstr ""
"这些代表以非负数为索引的有限有序集合。 内置函数 :func:`len` 将返回序列的项数。 当序列 的长度为 *n* 时，索引集合将包含数字 0, "
"1, ..., *n*-1。 ``a[i]`` 是选择序列 *a* 中的第 *i* 项。 某些序列，包括内置的序列，可通过加上序列长度来解读负下标值。 "
"例如，``a[-2]`` 等价于 ``a[n-2]``，即长度为 ``n`` 的 a 序列的倒数第二项。"

#: ../../reference/datamodel.rst:313
msgid ""
"Sequences also support slicing: ``a[i:j]`` selects all items with index *k* "
"such that *i* ``<=`` *k* ``<`` *j*.  When used as an expression, a slice is "
"a sequence of the same type. The comment above about negative indexes also "
"applies to negative slice positions."
msgstr ""
"序列还支持切片: ``a[i:j]`` 是选择索引为 *k* 使得 *i* ``<=`` *k* ``<`` *j* 的所有条目。 "
"当用作表达式时，切片就是一个相同类型的新序列。 以上有关负索引的注释也适用于切片位置的负值。"

#: ../../reference/datamodel.rst:318
msgid ""
"Some sequences also support \"extended slicing\" with a third \"step\" "
"parameter: ``a[i:j:k]`` selects all items of *a* with index *x* where ``x = "
"i + n*k``, *n* ``>=`` ``0`` and *i* ``<=`` *x* ``<`` *j*."
msgstr ""
"有些序列还支持带有第三个 \"step\" 形参的 \"扩展切片\": ``a[i:j:k]`` 选择 *a* 中索引号为 *x* 的所有条目，``x "
"= i + n*k``, *n* ``>=`` ``0`` 且 *i* ``<=`` *x* ``<`` *j*。"

#: ../../reference/datamodel.rst:322
msgid "Sequences are distinguished according to their mutability:"
msgstr "序列可根据其可变性来加以区分:"

#: ../../reference/datamodel.rst:326
msgid "Immutable sequences"
msgstr "不可变序列"

#: ../../reference/datamodel.rst:332
msgid ""
"An object of an immutable sequence type cannot change once it is created.  "
"(If the object contains references to other objects, these other objects may"
" be mutable and may be changed; however, the collection of objects directly "
"referenced by an immutable object cannot change.)"
msgstr ""
"不可变序列类型的对象一旦创建就不能再改变。(如果对象包含对其他对象的引用，其中的可变对象就是可以改变的；但是，一个不可变对象所直接引用的对象集是不能改变的。)"

#: ../../reference/datamodel.rst:337
msgid "The following types are immutable sequences:"
msgstr "以下类型属于不可变对象:"

#: ../../reference/datamodel.rst:342
msgid "Strings"
msgstr "字符串"

#: ../../reference/datamodel.rst:350
msgid ""
"A string is a sequence of values that represent Unicode code points. All the"
" code points in the range ``U+0000 - U+10FFFF`` can be represented in a "
"string.  Python doesn't have a :c:expr:`char` type; instead, every code "
"point in the string is represented as a string object with length ``1``.  "
"The built-in function :func:`ord` converts a code point from its string form"
" to an integer in the range ``0 - 10FFFF``; :func:`chr` converts an integer "
"in the range ``0 - 10FFFF`` to the corresponding length ``1`` string object."
" :meth:`str.encode` can be used to convert a :class:`str` to :class:`bytes` "
"using the given text encoding, and :meth:`bytes.decode` can be used to "
"achieve the opposite."
msgstr ""
"字符串是由代表 Unicode 码位的值组成的序列。 取值范围在 ``U+0000 - U+10FFFF`` 之内的所有码位都可在字符串中使用。 "
"Python 没有 :c:expr:`char` 类型；而是将字符串中的每个码位表示为一个长度为 ``1`` 的字符串对象。 内置函数 "
":func:`ord` 可将一个码位由字符串形式转换为取值范围在 ``0 - 10FFFF`` 之内的整数；:func:`chr` 可将一个取值范围在 "
"``0 - 10FFFF`` 之内的整数转换为长度为 ``1`` 的对应字符串对象。 :meth:`str.encode` 可以使用给定的文本编码格式将"
" :class:`str` 转换为 :class:`bytes`，而 :meth:`bytes.decode` 则可以被用来实现相反的解码操作。"

#: ../../reference/datamodel.rst:362
msgid "Tuples"
msgstr "元组"

#: ../../reference/datamodel.rst:368
msgid ""
"The items of a tuple are arbitrary Python objects. Tuples of two or more "
"items are formed by comma-separated lists of expressions.  A tuple of one "
"item (a 'singleton') can be formed by affixing a comma to an expression (an "
"expression by itself does not create a tuple, since parentheses must be "
"usable for grouping of expressions).  An empty tuple can be formed by an "
"empty pair of parentheses."
msgstr ""
"一个元组中的条目可以是任意 Python 对象。包含两个或以上条目的元组由逗号分隔的表达式构成。只有一个条目的元组 ('单项元组') "
"可通过在表达式后加一个逗号来构成 (一个表达式本身不能创建为元组，因为圆括号要用来设置表达式分组)。一个空元组可通过一对内容为空的圆括号创建。"

#: ../../reference/datamodel.rst:375
msgid "Bytes"
msgstr "字节串"

#: ../../reference/datamodel.rst:378
msgid ""
"A bytes object is an immutable array.  The items are 8-bit bytes, "
"represented by integers in the range 0 <= x < 256.  Bytes literals (like "
"``b'abc'``) and the built-in :func:`bytes` constructor can be used to create"
" bytes objects.  Also, bytes objects can be decoded to strings via the "
":meth:`~bytes.decode` method."
msgstr ""
"字节串对象是不是变的数组。 其中的条目是 8 比特位的字节，以取值范围 0 <= x < 256 内的整数表示。 字节串字面值 (如 "
"``b'abc'``) 和内置的 :func:`bytes` 构造器可被用来创建字节串对象。 并且，字节串对象还可通过 "
":meth:`~bytes.decode` 方法被解码为字符串。"

#: ../../reference/datamodel.rst:386
msgid "Mutable sequences"
msgstr "可变序列"

#: ../../reference/datamodel.rst:395
msgid ""
"Mutable sequences can be changed after they are created.  The subscription "
"and slicing notations can be used as the target of assignment and "
":keyword:`del` (delete) statements."
msgstr "可变序列在被创建后仍可被改变。下标和切片标注可被用作赋值和 :keyword:`del` (删除) 语句的目标。"

#: ../../reference/datamodel.rst:403
msgid ""
"The :mod:`collections` and :mod:`array` module provide additional examples "
"of mutable sequence types."
msgstr ":mod:`collections` 和 :mod:`array` 模块提供了可变序列类型的更多例子。"

#: ../../reference/datamodel.rst:406
msgid "There are currently two intrinsic mutable sequence types:"
msgstr "目前有两种内生可变序列类型:"

#: ../../reference/datamodel.rst:408
msgid "Lists"
msgstr "列表"

#: ../../reference/datamodel.rst:411
msgid ""
"The items of a list are arbitrary Python objects.  Lists are formed by "
"placing a comma-separated list of expressions in square brackets. (Note that"
" there are no special cases needed to form lists of length 0 or 1.)"
msgstr ""
"列表中的条目可以是任意 Python 对象。列表由用方括号括起并由逗号分隔的多个表达式构成。(注意创建长度为 0 或 1 的列表无需使用特殊规则。)"

#: ../../reference/datamodel.rst:415
msgid "Byte Arrays"
msgstr "字节数组"

#: ../../reference/datamodel.rst:418
msgid ""
"A bytearray object is a mutable array. They are created by the built-in "
":func:`bytearray` constructor.  Aside from being mutable (and hence "
"unhashable), byte arrays otherwise provide the same interface and "
"functionality as immutable :class:`bytes` objects."
msgstr ""
"字节数组对象属于可变数组。可以通过内置的 :func:`bytearray` 构造器来创建。除了是可变的 "
"(因而也是不可哈希的)，在其他方面字节数组提供的接口和功能都与不可变的 :class:`bytes` 对象一致。"

#: ../../reference/datamodel.rst:425
msgid "Set types"
msgstr "集合类型"

#: ../../reference/datamodel.rst:431
msgid ""
"These represent unordered, finite sets of unique, immutable objects. As "
"such, they cannot be indexed by any subscript. However, they can be iterated"
" over, and the built-in function :func:`len` returns the number of items in "
"a set. Common uses for sets are fast membership testing, removing duplicates"
" from a sequence, and computing mathematical operations such as "
"intersection, union, difference, and symmetric difference."
msgstr ""
"此类对象表示由不重复且不可变对象组成的无序且有限的集合。因此它们不能通过下标来索引。但是它们可被迭代，也可用内置函数 :func:`len` "
"返回集合中的条目数。集合常见的用处是快速成员检测，去除序列中的重复项，以及进行交、并、差和对称差等数学运算。"

#: ../../reference/datamodel.rst:438
msgid ""
"For set elements, the same immutability rules apply as for dictionary keys. "
"Note that numeric types obey the normal rules for numeric comparison: if two"
" numbers compare equal (e.g., ``1`` and ``1.0``), only one of them can be "
"contained in a set."
msgstr ""
"对于集合元素所采用的不可变规则与字典的键相同。注意数字类型遵循正常的数字比较规则: 如果两个数字相等 (例如 ``1`` 和 "
"``1.0``)，则同一集合中只能包含其中一个。"

#: ../../reference/datamodel.rst:443
msgid "There are currently two intrinsic set types:"
msgstr "目前有两种内生集合类型:"

#: ../../reference/datamodel.rst:446
msgid "Sets"
msgstr "集合"

#: ../../reference/datamodel.rst:449
msgid ""
"These represent a mutable set. They are created by the built-in :func:`set` "
"constructor and can be modified afterwards by several methods, such as "
":meth:`~set.add`."
msgstr ""
"此类对象表示可变集合。它们可通过内置的 :func:`set` 构造器创建，并且创建之后可以通过方法进行修改，例如 :meth:`~set.add`。"

#: ../../reference/datamodel.rst:454
msgid "Frozen sets"
msgstr "冻结集合"

#: ../../reference/datamodel.rst:457
msgid ""
"These represent an immutable set.  They are created by the built-in "
":func:`frozenset` constructor.  As a frozenset is immutable and "
":term:`hashable`, it can be used again as an element of another set, or as a"
" dictionary key."
msgstr ""
"此类对象表示不可变集合。它们可通过内置的 :func:`frozenset` 构造器创建。由于 frozenset 对象不可变且 "
":term:`hashable`，它可以被用作另一个集合的元素或是字典的键。"

#: ../../reference/datamodel.rst:464
msgid "Mappings"
msgstr "映射"

#: ../../reference/datamodel.rst:471
msgid ""
"These represent finite sets of objects indexed by arbitrary index sets. The "
"subscript notation ``a[k]`` selects the item indexed by ``k`` from the "
"mapping ``a``; this can be used in expressions and as the target of "
"assignments or :keyword:`del` statements. The built-in function :func:`len` "
"returns the number of items in a mapping."
msgstr ""
"此类对象表示由任意索引集合所索引的对象的集合。通过下标 ``a[k]`` 可在映射 ``a`` 中选择索引为 ``k`` "
"的条目；这可以在表达式中使用，也可作为赋值或 :keyword:`del` 语句的目标。内置函数 :func:`len` 可返回一个映射中的条目数。"

#: ../../reference/datamodel.rst:477
msgid "There is currently a single intrinsic mapping type:"
msgstr "目前只有一种内生映射类型:"

#: ../../reference/datamodel.rst:481
msgid "Dictionaries"
msgstr "字典"

#: ../../reference/datamodel.rst:485
msgid ""
"These represent finite sets of objects indexed by nearly arbitrary values.  "
"The only types of values not acceptable as keys are values containing lists "
"or dictionaries or other mutable types that are compared by value rather "
"than by object identity, the reason being that the efficient implementation "
"of dictionaries requires a key's hash value to remain constant. Numeric "
"types used for keys obey the normal rules for numeric comparison: if two "
"numbers compare equal (e.g., ``1`` and ``1.0``) then they can be used "
"interchangeably to index the same dictionary entry."
msgstr ""
"此类对象表示由几乎任意值作为索引的有限个对象的集合。不可作为键的值类型只有包含列表或字典或其他可变类型，通过值而非对象编号进行比较的值，其原因在于高效的字典实现需要使用键的哈希值以保持一致性。用作键的数字类型遵循正常的数字比较规则:"
" 如果两个数字相等 (例如 ``1`` 和 ``1.0``) 则它们均可来用来索引同一个字典条目。"

#: ../../reference/datamodel.rst:494
msgid ""
"Dictionaries preserve insertion order, meaning that keys will be produced in"
" the same order they were added sequentially over the dictionary. Replacing "
"an existing key does not change the order, however removing a key and re-"
"inserting it will add it to the end instead of keeping its old place."
msgstr ""
"字典会保留插入顺序，这意味着键将以它们被添加的顺序在字典中依次产生。 "
"替换某个现有的键不会改变其顺序，但是移除某个键再重新插入则会将其添加到末尾而不会保留其原有位置。"

#: ../../reference/datamodel.rst:499
msgid ""
"Dictionaries are mutable; they can be created by the ``{}`` notation (see "
"section :ref:`dict`)."
msgstr "字典是可变对象；它们可通过 ``{}`` 标注方式来创建（参见 :ref:`dict` 一节）。"

#: ../../reference/datamodel.rst:506
msgid ""
"The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide additional "
"examples of mapping types, as does the :mod:`collections` module."
msgstr ""
"扩展模块 :mod:`dbm.ndbm` 和 :mod:`dbm.gnu` 提供了额外的映射类型示例，:mod:`collections` "
"模块也是如此。"

#: ../../reference/datamodel.rst:510
msgid ""
"Dictionaries did not preserve insertion order in versions of Python before "
"3.6. In CPython 3.6, insertion order was preserved, but it was considered an"
" implementation detail at that time rather than a language guarantee."
msgstr ""
"在 Python 3.6 版之前字典不会保留插入顺序。 在 CPython 3.6 "
"中插入顺序会被保留，但这在当时被当作是一个实现细节而非确定的语言特性。"

#: ../../reference/datamodel.rst:517
msgid "Callable types"
msgstr "可调用类型"

#: ../../reference/datamodel.rst:525
msgid ""
"These are the types to which the function call operation (see section "
":ref:`calls`) can be applied:"
msgstr "此类型可以被应用于函数调用操作 (参见 :ref:`calls` 小节):"

#: ../../reference/datamodel.rst:532
msgid "User-defined functions"
msgstr "用户定义函数"

#: ../../reference/datamodel.rst:539
msgid ""
"A user-defined function object is created by a function definition (see "
"section :ref:`function`).  It should be called with an argument list "
"containing the same number of items as the function's formal parameter list."
msgstr ""
"用户定义函数对象可通过函数定义来创建 (参见 :ref:`function` "
"小节)。它被调用时应附带一个参数列表，其中包含的条目应与函数所定义的形参列表一致。"

#: ../../reference/datamodel.rst:545 ../../reference/datamodel.rst:1367
#: ../../reference/datamodel.rst:1562
msgid "Special read-only attributes"
msgstr "特殊的只读属性"

#: ../../reference/datamodel.rst:555 ../../reference/datamodel.rst:589
#: ../../reference/datamodel.rst:1156
msgid "Attribute"
msgstr "属性"

#: ../../reference/datamodel.rst:556 ../../reference/datamodel.rst:590
#: ../../reference/datamodel.rst:1157
msgid "Meaning"
msgstr "含意"

#: ../../reference/datamodel.rst:559
msgid ""
"A reference to the :class:`dictionary <dict>` that holds the function's "
":ref:`global variables <naming>` -- the global namespace of the module in "
"which the function was defined."
msgstr ""
"对存放该函数中 :ref:`全局变量 <naming>` 的 :class:`字典 <dict>` 的引用 —— 函数定义所在模块的全局命名空间。"

#: ../../reference/datamodel.rst:564
msgid ""
"``None`` or a :class:`tuple` of cells that contain bindings for the "
"function's free variables."
msgstr "``None`` 或是一个包含该函数的自由变量的绑定单元的 :class:`tuple`。"

#: ../../reference/datamodel.rst:567
msgid ""
"A cell object has the attribute ``cell_contents``. This can be used to get "
"the value of the cell, as well as set the value."
msgstr "单元对象具有 ``cell_contents`` 属性。这可被用来获取以及设置单元的值。"

#: ../../reference/datamodel.rst:571 ../../reference/datamodel.rst:1599
msgid "Special writable attributes"
msgstr "特殊的可写属性"

#: ../../reference/datamodel.rst:584
msgid "Most of these attributes check the type of the assigned value:"
msgstr "这些属性大多会检查赋值的类型："

#: ../../reference/datamodel.rst:593
msgid "The function's documentation string, or ``None`` if unavailable."
msgstr "函数的文档字符串，或者如果不可用则为 ``None``。"

#: ../../reference/datamodel.rst:596
msgid ""
"The function's name. See also: :attr:`__name__ attributes "
"<definition.__name__>`."
msgstr "函数的名称。 另请参阅: :attr:`__name__ 属性 <definition.__name__>`。"

#: ../../reference/datamodel.rst:600
msgid ""
"The function's :term:`qualified name`. See also: :attr:`__qualname__ "
"attributes <definition.__qualname__>`."
msgstr ""
"函数的 :term:`qualified name`。 另请参阅: :attr:`__qualname__ 属性 "
"<definition.__qualname__>`。"

#: ../../reference/datamodel.rst:606
msgid ""
"The name of the module the function was defined in, or ``None`` if "
"unavailable."
msgstr "该函数所属模块的名称，没有则为 ``None``。"

#: ../../reference/datamodel.rst:610
msgid ""
"A :class:`tuple` containing default :term:`parameter` values for those "
"parameters that have defaults, or ``None`` if no parameters have a default "
"value."
msgstr ""
"由具有默认值的形参的默认 :term:`parameter` 值组成的 :class:`tuple`，或者如果无任何形参具有默认值则为 "
"``None``。"

#: ../../reference/datamodel.rst:615
msgid ""
"The :ref:`code object <code-objects>` representing the compiled function "
"body."
msgstr "代表已编译的函数体的 :ref:`代码对象 <code-objects>`。"

#: ../../reference/datamodel.rst:619
msgid ""
"The namespace supporting arbitrary function attributes. See also: "
":attr:`__dict__ attributes <object.__dict__>`."
msgstr "命名空间支持任意函数属性。 另请参阅: :attr:`__dict__ 属性 <object.__dict__>`。"

#: ../../reference/datamodel.rst:623
msgid ""
"A :class:`dictionary <dict>` containing annotations of :term:`parameters "
"<parameter>`. The keys of the dictionary are the parameter names, and "
"``'return'`` for the return annotation, if provided. See also: "
":ref:`annotations-howto`."
msgstr ""
"包含 :term:`形参 <parameter>` 标注的 :class:`字典 <dict>`。 该字典的键是形参名称，如存在返回标注则将包含 "
"``'return'`` 键。 另请参阅: :ref:`annotations-howto`。"

#: ../../reference/datamodel.rst:630
msgid ""
"A :class:`dictionary <dict>` containing defaults for keyword-only "
":term:`parameters <parameter>`."
msgstr "包含仅限关键字 :term:`形参 <parameter>` 默认值的 :class:`字典 <dict>`。"

#: ../../reference/datamodel.rst:634
msgid ""
"A :class:`tuple` containing the :ref:`type parameters <type-params>` of a "
":ref:`generic function <generic-functions>`."
msgstr ""
"包含 :ref:`泛型函数 <generic-functions>` :ref:`类型形参 <type-params>` 的 "
":class:`tuple`。"

#: ../../reference/datamodel.rst:639
msgid ""
"Function objects also support getting and setting arbitrary attributes, "
"which can be used, for example, to attach metadata to functions.  Regular "
"attribute dot-notation is used to get and set such attributes."
msgstr "函数对象也支持获取和设置任意属性，举例来说，这可被用于将元数据关联到函数。 通常使用带点号的属性标注来获取和设置这样的属性。"

#: ../../reference/datamodel.rst:645
msgid ""
"CPython's current implementation only supports function attributes on user-"
"defined functions. Function attributes on :ref:`built-in functions <builtin-"
"functions>` may be supported in the future."
msgstr ""
"CPython 目前的实现仅支持用户自定义函数上的函数属性。 未来可能会支持 :ref:`内置函数 <builtin-functions>` "
"上的函数属性。"

#: ../../reference/datamodel.rst:650
msgid ""
"Additional information about a function's definition can be retrieved from "
"its :ref:`code object <code-objects>` (accessible via the "
":attr:`~function.__code__` attribute)."
msgstr ""
"有关函数定义的额外信息可以从其 :ref:`代码对象 <code-objects>` 中提取（可通过 "
":attr:`~function.__code__` 属性来访问）。"

#: ../../reference/datamodel.rst:658
msgid "Instance methods"
msgstr "实例方法"

#: ../../reference/datamodel.rst:665
msgid ""
"An instance method object combines a class, a class instance and any "
"callable object (normally a user-defined function)."
msgstr "实例方法用于结合类、类实例和任何可调用对象 (通常为用户定义函数)。"

#: ../../reference/datamodel.rst:675 ../../reference/datamodel.rst:1690
msgid "Special read-only attributes:"
msgstr "特殊的只读属性："

#: ../../reference/datamodel.rst:680
msgid ""
"Refers to the class instance object to which the method is :ref:`bound "
"<method-binding>`"
msgstr "指向方法所 :ref:`绑定 <method-binding>` 的类实例对象。"

#: ../../reference/datamodel.rst:684
msgid "Refers to the original :ref:`function object <user-defined-funcs>`"
msgstr "指向原本的 :ref:`函数对象 <user-defined-funcs>`"

#: ../../reference/datamodel.rst:687
msgid ""
"The method's documentation (same as :attr:`method.__func__.__doc__ "
"<function.__doc__>`). A :class:`string <str>` if the original function had a"
" docstring, else ``None``."
msgstr ""
"方法的文档 (等同于 :attr:`method.__func__.__doc__ <function.__doc__>`)。 "
"如果原始函数具有文档字符串则为一个 :class:`字符串 <str>`，否则为 ``None``。"

#: ../../reference/datamodel.rst:693
msgid ""
"The name of the method (same as :attr:`method.__func__.__name__ "
"<function.__name__>`)"
msgstr "方法名称（与 :attr:`method.__func__.__name__ <function.__name__>` 相同）"

#: ../../reference/datamodel.rst:697
msgid ""
"The name of the module the method was defined in, or ``None`` if "
"unavailable."
msgstr "方法定义所在模块的名称，如不可用则为 ``None``。"

#: ../../reference/datamodel.rst:700
msgid ""
"Methods also support accessing (but not setting) the arbitrary function "
"attributes on the underlying :ref:`function object <user-defined-funcs>`."
msgstr "方法还支持读取（但不能设置）下层 :ref:`函数对象 <user-defined-funcs>` 的任意函数属性。"

#: ../../reference/datamodel.rst:703
msgid ""
"User-defined method objects may be created when getting an attribute of a "
"class (perhaps via an instance of that class), if that attribute is a user-"
"defined :ref:`function object <user-defined-funcs>` or a "
":class:`classmethod` object."
msgstr ""
"用户自定义方法对象可在获取一个类的属性（可能是通过该类的实例）时被创建，如果该属性是一个用户自定义 :ref:`函数对象 <user-defined-"
"funcs>` 或 :class:`classmethod` 对象的话。"

#: ../../reference/datamodel.rst:710
msgid ""
"When an instance method object is created by retrieving a user-defined "
":ref:`function object <user-defined-funcs>` from a class via one of its "
"instances, its :attr:`~method.__self__` attribute is the instance, and the "
"method object is said to be *bound*.  The new method's "
":attr:`~method.__func__` attribute is the original function object."
msgstr ""
"当通过从类的实例获取一个用户自定义 :ref:`函数对象 <user-defined-funcs>` 的方式创建一个实例方法对象时，该方法对象的 "
":attr:`~method.__self__` 属性即为该实例，而该方法对象将被称作已 *绑定*。 该新建方法的 "
":attr:`~method.__func__` 属性将是原来的函数对象。"

#: ../../reference/datamodel.rst:716
msgid ""
"When an instance method object is created by retrieving a "
":class:`classmethod` object from a class or instance, its "
":attr:`~method.__self__` attribute is the class itself, and its "
":attr:`~method.__func__` attribute is the function object underlying the "
"class method."
msgstr ""
"当通过从类或实例获取一个 :class:`classmethod` 对象的方式创建一个实例方法对象时，该对象的 "
":attr:`~method.__self__` 属性即为该类本身，而其 :attr:`~method.__func__` "
"属性将是类方法对应的下层函数对象。"

#: ../../reference/datamodel.rst:721
msgid ""
"When an instance method object is called, the underlying function "
"(:attr:`~method.__func__`) is called, inserting the class instance "
"(:attr:`~method.__self__`) in front of the argument list.  For instance, "
"when :class:`!C` is a class which contains a definition for a function "
":meth:`!f`, and ``x`` is an instance of :class:`!C`, calling ``x.f(1)`` is "
"equivalent to calling ``C.f(x, 1)``."
msgstr ""
"当一个实例方法被调用时，会调用对应的下层函数 (:attr:`~method.__func__`)，并将类实例 "
"(:attr:`~method.__self__`) 插入参数列表的开头。 例如，当 :class:`!C` 是一个包含 :meth:`!f` "
"函数定义的类，而 ``x`` 是 :class:`!C` 的一个实例，则调用 ``x.f(1)`` 就等价于调用 ``C.f(x, 1)``。"

#: ../../reference/datamodel.rst:728
msgid ""
"When an instance method object is derived from a :class:`classmethod` "
"object, the \"class instance\" stored in :attr:`~method.__self__` will "
"actually be the class itself, so that calling either ``x.f(1)`` or "
"``C.f(1)`` is equivalent to calling ``f(C,1)`` where ``f`` is the underlying"
" function."
msgstr ""
"当一个实例方法对象是派生自一个 :class:`classmethod` 对象时，保存在 :attr:`~method.__self__` "
"中的“类实例”实际上会是该类本身，因此无论是调用 ``x.f(1)`` 还是 ``C.f(1)`` 都等同于调用 ``f(C,1)``，其中 ``f``"
" 为对应的下层函数。"

#: ../../reference/datamodel.rst:733
msgid ""
"It is important to note that user-defined functions which are attributes of "
"a class instance are not converted to bound methods; this *only* happens "
"when the function is an attribute of the class."
msgstr "需要重点关注的是作为类实例的属性的用户自定义函数不会被转换为绑定方法；这 *只会* 在函数是类的属性时才会发生。"

#: ../../reference/datamodel.rst:740
msgid "Generator functions"
msgstr "生成器函数"

#: ../../reference/datamodel.rst:746
msgid ""
"A function or method which uses the :keyword:`yield` statement (see section "
":ref:`yield`) is called a :dfn:`generator function`.  Such a function, when "
"called, always returns an :term:`iterator` object which can be used to "
"execute the body of the function:  calling the iterator's "
":meth:`iterator.__next__` method will cause the function to execute until it"
" provides a value using the :keyword:`!yield` statement.  When the function "
"executes a :keyword:`return` statement or falls off the end, a "
":exc:`StopIteration` exception is raised and the iterator will have reached "
"the end of the set of values to be returned."
msgstr ""
"一个使用 :keyword:`yield` 语句（见 :ref:`yield` 章节）的函数或方法被称为 :dfn:`生成器函数`。 "
"这样的函数在被调用时，总是返回一个可以执行该函数体的 :term:`iterator` 对象：调用该迭代器的 "
":meth:`iterator.__next__` 方法将导致这个函数一直运行到它使用 :keyword:`!yield` 语句提供一个值。 "
"当这个函数执行 :keyword:`return` 语句或到达函数体末尾时，将引发 :exc:`StopIteration` "
"异常并且该迭代器将到达所返回的值集合的末尾。"

#: ../../reference/datamodel.rst:758
msgid "Coroutine functions"
msgstr "协程函数"

#: ../../reference/datamodel.rst:763
msgid ""
"A function or method which is defined using :keyword:`async def` is called a"
" :dfn:`coroutine function`.  Such a function, when called, returns a "
":term:`coroutine` object.  It may contain :keyword:`await` expressions, as "
"well as :keyword:`async with` and :keyword:`async for` statements. See also "
"the :ref:`coroutine-objects` section."
msgstr ""
"使用 :keyword:`async def` 来定义的函数或方法就被称为 :dfn:`协程函数`。这样的函数在被调用时会返回一个 "
":term:`coroutine` 对象。它可能包含 :keyword:`await` 表达式以及 :keyword:`async with` 和 "
":keyword:`async for` 语句。详情可参见 :ref:`coroutine-objects` 一节。"

#: ../../reference/datamodel.rst:771
msgid "Asynchronous generator functions"