object.po

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

#: ../../c-api/object.rst:6
msgid "Object Protocol"
msgstr "对象协议"

#: ../../c-api/object.rst:11
msgid ""
"The ``NotImplemented`` singleton, used to signal that an operation is not "
"implemented for the given type combination."
msgstr "``NotImplemented`` 单例，用于标记某个操作没有针对给定类型组合的实现。"

#: ../../c-api/object.rst:17
msgid ""
"Properly handle returning :c:data:`Py_NotImplemented` from within a C "
"function (that is, increment the reference count of NotImplemented and "
"return it)."
msgstr ""
"C 函数内部应正确处理 :c:data:`Py_NotImplemented` 的返回过程（即增加 NotImplemented 的引用计数并返回之）。"

#: ../../c-api/object.rst:24
msgid ""
"Print an object *o*, on file *fp*.  Returns ``-1`` on error.  The flags "
"argument is used to enable certain printing options.  The only option "
"currently supported is :const:`Py_PRINT_RAW`; if given, the :func:`str` of "
"the object is written instead of the :func:`repr`."
msgstr ""
"将对象 *o* 写入到文件 *fp*。 出错时返回 ``-1`` 。 旗标参数被用于启用特定的输出选项。 目前唯一支持的选项是 "
":const:`Py_PRINT_RAW`；如果给出该选项，则将写入对象的 :func:`str` 而不是 :func:`repr`。"

#: ../../c-api/object.rst:32 ../../c-api/object.rst:43
msgid ""
"Returns ``1`` if *o* has the attribute *attr_name*, and ``0`` otherwise.  "
"This is equivalent to the Python expression ``hasattr(o, attr_name)``.  This"
" function always succeeds."
msgstr ""
"如果 *o* 带有属性 *attr_name*，则返回 ``1``，否则返回 ``0``。这相当于 Python 表达式 ``hasattr(o, "
"attr_name)``。 此函数总是成功。"

#: ../../c-api/object.rst:36
msgid ""
"Note that exceptions which occur while calling :meth:`__getattr__` and "
":meth:`__getattribute__` methods will get suppressed. To get error reporting"
" use :c:func:`PyObject_GetAttr()` instead."
msgstr ""
"注意，在调用 :meth:`__getattr__` 和 :meth:`__getattribute__` "
"方法时发生的异常将被抑制。若要获得错误报告，请换用 :c:func:`PyObject_GetAttr()` 。"

#: ../../c-api/object.rst:47
msgid ""
"Note that exceptions which occur while calling :meth:`__getattr__` and "
":meth:`__getattribute__` methods and creating a temporary string object will"
" get suppressed. To get error reporting use "
":c:func:`PyObject_GetAttrString()` instead."
msgstr ""
"注意，在调用 :meth:`__getattr__` 和 :meth:`__getattribute__` "
"方法并创建一个临时字符串对象时，异常将被抑制。若要获得错误报告，请换用 :c:func:`PyObject_GetAttrString()` 。"

#: ../../c-api/object.rst:55
msgid ""
"Retrieve an attribute named *attr_name* from object *o*. Returns the "
"attribute value on success, or ``NULL`` on failure.  This is the equivalent "
"of the Python expression ``o.attr_name``."
msgstr ""
"从对象 *o* 中读取名为 *attr_name* 的属性。成功返回属性值，失败则返回  ``NULL``。 这相当于 Python 表达式 "
"``o.attr_name``。"

#: ../../c-api/object.rst:62
msgid ""
"Retrieve an attribute named *attr_name* from object *o*. Returns the "
"attribute value on success, or ``NULL`` on failure. This is the equivalent "
"of the Python expression ``o.attr_name``."
msgstr ""
"从对象 *o* 中读取一个名为 *attr_name* 的属性。成功时返回属性值，失败则返回 ``NULL``。这相当于 Python 表达式 "
"``o.attr_name``。"

#: ../../c-api/object.rst:69
msgid ""
"Generic attribute getter function that is meant to be put into a type "
"object's ``tp_getattro`` slot.  It looks for a descriptor in the dictionary "
"of classes in the object's MRO as well as an attribute in the object's "
":attr:`~object.__dict__` (if present).  As outlined in :ref:`descriptors`, "
"data descriptors take preference over instance attributes, while non-data "
"descriptors don't.  Otherwise, an :exc:`AttributeError` is raised."
msgstr ""
"通用的属性获取函数，用于放入类型对象的 ``tp_getattro`` 槽中。它在类的字典中（位于对象的 MRO 中）查找某个描述符，并在对象的 "
":attr:`~object.__dict__` 中查找某个属性。正如 :ref:`descriptors` "
"所述，数据描述符优先于实例属性，而非数据描述符则不优先。失败则会触发 :exc:`AttributeError` 。"

#: ../../c-api/object.rst:79 ../../c-api/object.rst:91
msgid ""
"Set the value of the attribute named *attr_name*, for object *o*, to the "
"value *v*. Raise an exception and return ``-1`` on failure; return ``0`` on "
"success.  This is the equivalent of the Python statement ``o.attr_name = "
"v``."
msgstr ""
"将对象 *o* 中名为 *attr_name* 的属性值设为 *v* 。失败时引发异常并返回 ``-1``；成功时返 回 ``0`` 。这相当于 "
"Python 语句 ``o.attr_name = v``。"

#: ../../c-api/object.rst:84
msgid ""
"If *v* is ``NULL``, the attribute is deleted. This behaviour is deprecated "
"in favour of using :c:func:`PyObject_DelAttr`, but there are currently no "
"plans to remove it."
msgstr ""
"如果 *v* 为 ``NULL``，该属性将被删除。 此行为已被弃用而应改用 "
":c:func:`PyObject_DelAttr`，但目前还没有移除它的计划。"

#: ../../c-api/object.rst:96
msgid ""
"If *v* is ``NULL``, the attribute is deleted, but this feature is deprecated"
" in favour of using :c:func:`PyObject_DelAttrString`."
msgstr ""
"如果 *v* 为 ``NULL``，该属性将被删除，但是此功能已被弃用而应改用 :c:func:`PyObject_DelAttrString`。"

#: ../../c-api/object.rst:102
msgid ""
"Generic attribute setter and deleter function that is meant to be put into a"
" type object's :c:member:`~PyTypeObject.tp_setattro` slot.  It looks for a "
"data descriptor in the dictionary of classes in the object's MRO, and if "
"found it takes preference over setting or deleting the attribute in the "
"instance dictionary. Otherwise, the attribute is set or deleted in the "
"object's :attr:`~object.__dict__` (if present). On success, ``0`` is "
"returned, otherwise an :exc:`AttributeError` is raised and ``-1`` is "
"returned."
msgstr ""
"通用的属性设置和删除函数，用于放入类型对象的 :c:member:`~PyTypeObject.tp_setattro` "
"槽。它在类的字典中（位于对象的MRO中）查找数据描述器，如果找到，则将比在实例字典中设置或删除属性优先执行。否则，该属性将在对象的 "
":attr:`~object.__dict__` 中设置或删除。如果成功将返回 ``0``，否则将引发 :exc:`AttributeError` "
"并返回 ``-1``。"

#: ../../c-api/object.rst:114 ../../c-api/object.rst:120
msgid ""
"Delete attribute named *attr_name*, for object *o*. Returns ``-1`` on "
"failure. This is the equivalent of the Python statement ``del o.attr_name``."
msgstr ""
"删除对象 *o* 中名为 *attr_name* 的属性。失败时返回 ``-1``。这相当于 Python 语句 ``del "
"o.attr_name``。"

#: ../../c-api/object.rst:126
msgid ""
"A generic implementation for the getter of a ``__dict__`` descriptor. It "
"creates the dictionary if necessary."
msgstr "``__dict__`` 描述符的获取函数的一种通用实现。必要时会创建该字典。"

#: ../../c-api/object.rst:134
msgid ""
"A generic implementation for the setter of a ``__dict__`` descriptor. This "
"implementation does not allow the dictionary to be deleted."
msgstr "``__dict__`` 描述符设置函数的一种通用实现。这里不允许删除该字典。"

#: ../../c-api/object.rst:142
msgid ""
"Compare the values of *o1* and *o2* using the operation specified by *opid*,"
" which must be one of :const:`Py_LT`, :const:`Py_LE`, :const:`Py_EQ`, "
":const:`Py_NE`, :const:`Py_GT`, or :const:`Py_GE`, corresponding to ``<``, "
"``<=``, ``==``, ``!=``, ``>``, or ``>=`` respectively. This is the "
"equivalent of the Python expression ``o1 op o2``, where ``op`` is the "
"operator corresponding to *opid*. Returns the value of the comparison on "
"success, or ``NULL`` on failure."
msgstr ""
"用 *opid* 指定的操作比较 *o1* 和 *o2* 的值，必须是 :const:`Py_LT` 、 :const:`Py_LE` 、 "
":const:`Py_EQ` 、 :const:`Py_NE` 、 :const:`Py_GT` 或 :const:`Py_GE` "
"之一，分别对应于``<``、``<=`` 、``==`` 、 ``!=`` 、``>`` 或 ``>=``。这相当于 Python 表达式 ``o1 "
"op o2``，其中 ``op`` 是对应于 *opid* 的操作符。成功时返回比较值，失败时返回 ``NULL``。"

#: ../../c-api/object.rst:152
msgid ""
"Compare the values of *o1* and *o2* using the operation specified by *opid*,"
" which must be one of :const:`Py_LT`, :const:`Py_LE`, :const:`Py_EQ`, "
":const:`Py_NE`, :const:`Py_GT`, or :const:`Py_GE`, corresponding to ``<``, "
"``<=``, ``==``, ``!=``, ``>``, or ``>=`` respectively. Returns ``-1`` on "
"error, ``0`` if the result is false, ``1`` otherwise. This is the equivalent"
" of the Python expression ``o1 op o2``, where ``op`` is the operator "
"corresponding to *opid*."
msgstr ""
"用 *opid* 指定的操作比较 *o1* 和 *o2* 的值，必须是 :const:`Py_LT` 、 :const:`Py_LE` 、 "
":const:`Py_EQ` 、 :const:`Py_NE` 、 :const:`Py_GT` 或 :const:`Py_GE` 之一，分别对应于 "
"``<`` 、``<=``、 ``==`` 、``!=`` 、``>`` 或 ``>=``。错误时返回 ``-1``，若结果为 false 则返回 "
"``0``，否则返回 ``1``。这相当于 Python 表达式 ``o1 op o2``，其中 ``op`` 是对应于 *opid* 的操作符。"

#: ../../c-api/object.rst:161
msgid ""
"If *o1* and *o2* are the same object, :c:func:`PyObject_RichCompareBool` "
"will always return ``1`` for :const:`Py_EQ` and ``0`` for :const:`Py_NE`."
msgstr ""
"如果 *o1* 和 *o2* 是同一个对象，:c:func:`PyObject_RichCompareBool` 为 :const:`Py_EQ` "
"则返回 ``1`` ，为 :const:`Py_NE` 则返回 ``0``。"

#: ../../c-api/object.rst:168
msgid ""
"Compute a string representation of object *o*.  Returns the string "
"representation on success, ``NULL`` on failure.  This is the equivalent of "
"the Python expression ``repr(o)``.  Called by the :func:`repr` built-in "
"function."
msgstr ""
"计算对象 *o* 的字符串形式。 成功时返回字符串，失败时返回 ``NULL``。 这相当于 Python 表达式 ``repr(o)``。 由内置函数"
" :func:`repr`  调用。"

#: ../../c-api/object.rst:172 ../../c-api/object.rst:196
msgid ""
"This function now includes a debug assertion to help ensure that it does not"
" silently discard an active exception."
msgstr "该函数现在包含一个调试断言，用以确保不会静默地丢弃活动的异常。"

#: ../../c-api/object.rst:180
msgid ""
"As :c:func:`PyObject_Repr`, compute a string representation of object *o*, "
"but escape the non-ASCII characters in the string returned by "
":c:func:`PyObject_Repr` with ``\\x``, ``\\u`` or ``\\U`` escapes.  This "
"generates a string similar to that returned by :c:func:`PyObject_Repr` in "
"Python 2. Called by the :func:`ascii` built-in function."
msgstr ""
"与 :c:func:`PyObject_Repr` 一样，计算对象 *o* 的字符串形式，但在 :c:func:`PyObject_Repr` "
"返回的字符串中用 ``\\x``、``\\u`` 或 ``\\U`` 转义非 ASCII 字符。这将生成一个类似于 Python 2 中由 "
":c:func:`PyObject_Repr` 返回的字符串。由内置函数 :func:`ascii` 调用。"

#: ../../c-api/object.rst:191
msgid ""
"Compute a string representation of object *o*.  Returns the string "
"representation on success, ``NULL`` on failure.  This is the equivalent of "
"the Python expression ``str(o)``.  Called by the :func:`str` built-in "
"function and, therefore, by the :func:`print` function."
msgstr ""
"计算对象 *o* 的字符串形式。 成功时返回字符串，失败时返回 ``NULL``。 这相当于 Python 表达式 ``str(o)``。由内置函数 "
":func:`str` 调用，因此也由 :func:`print` 函数调用。"

#: ../../c-api/object.rst:205
msgid ""
"Compute a bytes representation of object *o*.  ``NULL`` is returned on "
"failure and a bytes object on success.  This is equivalent to the Python "
"expression ``bytes(o)``, when *o* is not an integer.  Unlike ``bytes(o)``, a"
" TypeError is raised when *o* is an integer instead of a zero-initialized "
"bytes object."
msgstr ""
"计算对象 *o* 的字节形式。失败时返回 ``NULL``，成功时返回一个字节串对象。这相当于 *o* 不是整数时的 Python 表达式 "
"``bytes(o)`` 。与 ``bytes(o)`` 不同的是，当 *o* 是整数而不是初始为 0 的字节串对象时，会触发 TypeError。"

#: ../../c-api/object.rst:214
msgid ""
"Return ``1`` if the class *derived* is identical to or derived from the "
"class *cls*, otherwise return ``0``.  In case of an error, return ``-1``."
msgstr "如果 *derived* 类与 *cls* 类相同或为其派生类，则返回 ``1``，否则返回 ``0``。 如果出错则返回 ``-1``。"

#: ../../c-api/object.rst:217 ../../c-api/object.rst:236
msgid ""
"If *cls* is a tuple, the check will be done against every entry in *cls*. "
"The result will be ``1`` when at least one of the checks returns ``1``, "
"otherwise it will be ``0``."
msgstr ""
"如果 *cls* 是元组，则会对 *cls* 进行逐项检测。如果至少有一次检测返回 ``1``，结果将为 ``1``，否则将是 ``0``。"

#: ../../c-api/object.rst:221
msgid ""
"If *cls* has a :meth:`~class.__subclasscheck__` method, it will be called to"
" determine the subclass status as described in :pep:`3119`.  Otherwise, "
"*derived* is a subclass of *cls* if it is a direct or indirect subclass, "
"i.e. contained in ``cls.__mro__``."
msgstr ""
"正如 :pep:`3119` 所述，如果 *cls* 带有 :meth:`~class.__subclasscheck__` "
"方法，将会被调用以确定子类的状态。 否则，如果 *derived* 是个直接或间接子类，即包含在 ``cls.__mro__`` 中，那么它就是 "
"*cls* 的一个子类。"

#: ../../c-api/object.rst:226
msgid ""
"Normally only class objects, i.e. instances of :class:`type` or a derived "
"class, are considered classes.  However, objects can override this by having"
" a :attr:`__bases__` attribute (which must be a tuple of base classes)."
msgstr ""
"通常只有类对象才会被视为类，即 :class:`type` 或派生类的实例。然而，对象可以通过拥有 :attr:`__bases__` "
"属性（必须是基类的元组）来覆盖这一点。"

#: ../../c-api/object.rst:233
msgid ""
"Return ``1`` if *inst* is an instance of the class *cls* or a subclass of "
"*cls*, or ``0`` if not.  On error, returns ``-1`` and sets an exception."
msgstr ""
"如果 *inst* 是 *cls* 类或其子类的实例，则返回 ``1``，如果不是则返回 ``0``。 如果出错则返回 ``-1`` 并设置一个异常。"

#: ../../c-api/object.rst:240
msgid ""
"If *cls* has a :meth:`~class.__instancecheck__` method, it will be called to"
" determine the subclass status as described in :pep:`3119`.  Otherwise, "
"*inst* is an instance of *cls* if its class is a subclass of *cls*."
msgstr ""
"正如 :pep:`3119` 所述，如果 *cls* 带有 :meth:`~class.__subclasscheck__` "
"方法，将会被调用以确定子类的状态。 否则，如果 *derived* 是 *cls* 的子类，那么它就是 *cls* 的一个实例。"

#: ../../c-api/object.rst:244
msgid ""
"An instance *inst* can override what is considered its class by having a "
":attr:`__class__` attribute."
msgstr "实例 *inst* 可以通过 :attr:`__class__` 属性来覆盖其所属类。"

#: ../../c-api/object.rst:247
msgid ""
"An object *cls* can override if it is considered a class, and what its base "
"classes are, by having a :attr:`__bases__` attribute (which must be a tuple "
"of base classes)."
msgstr "对象 *cls* 是否被认作类，以及基类是什么，均可通过 :attr:`__bases__` 属性（必须是基类的元组）进行覆盖。"

#: ../../c-api/object.rst:256
msgid ""
"Compute and return the hash value of an object *o*.  On failure, return "
"``-1``. This is the equivalent of the Python expression ``hash(o)``."
msgstr "计算并返回对象的哈希值 *o*。 失败时返回 ``-1``。这相当于 Python 表达式 ``hash(o)``。"

#: ../../c-api/object.rst:259
msgid ""
"The return type is now Py_hash_t.  This is a signed integer the same size as"
" :c:type:`Py_ssize_t`."
msgstr "现在的返回类型是 Py_hash_t。 这是一个大小与 :c:type:`Py_ssize_t` 相同的有符号整数。"

#: ../../c-api/object.rst:266
msgid ""
"Set a :exc:`TypeError` indicating that ``type(o)`` is not hashable and "
"return ``-1``. This function receives special treatment when stored in a "
"``tp_hash`` slot, allowing a type to explicitly indicate to the interpreter "
"that it is not hashable."
msgstr ""
"设置一个 :exc:`TypeError` 表示 ``type(o)`` 是不可哈希的，并返回 ``-1`` 。该函数保存在 ``tp_hash`` "
"槽中时会受到特别对待，允许某个类型向解释器显式表明它不可散列。"

#: ../../c-api/object.rst:274
msgid ""
"Returns ``1`` if the object *o* is considered to be true, and ``0`` "
"otherwise. This is equivalent to the Python expression ``not not o``.  On "
"failure, return ``-1``."
msgstr ""
"如果对象 *o* 被认为是 true，则返回 ``1``，否则返回 ``0``。这相当于 Python 表达式 ``not not o``。 失败则返回"
" ``-1``。"

#: ../../c-api/object.rst:281
msgid ""
"Returns ``0`` if the object *o* is considered to be true, and ``1`` "
"otherwise. This is equivalent to the Python expression ``not o``.  On "
"failure, return ``-1``."
msgstr ""
"如果对象 *o* 被认为是 true，则返回 ``1``，否则返回 ``0``。这相当于 Python 表达式 ``not not o``。 失败则返回"
" ``-1``。"

#: ../../c-api/object.rst:290
msgid ""
"When *o* is non-``NULL``, returns a type object corresponding to the object "
"type of object *o*. On failure, raises :exc:`SystemError` and returns "
"``NULL``.  This is equivalent to the Python expression ``type(o)``. This "
"function increments the reference count of the return value. There's really "
"no reason to use this function instead of the :c:func:`Py_TYPE()` function, "
"which returns a pointer of type :c:type:`PyTypeObject*`, except when the "
"incremented reference count is needed."
msgstr ""
"当 *o* 不为 ``NULL`` 时，返回一个与对象 *o* 的类型相对应的类型对象。 当失败时，将引发 :exc:`SystemError` 并返回"
" ``NULL``。 这等同于 Python 表达式 ``type(o)``。 该函数会增加返回值的引用计数。 实际上没有理由不去用普通的表达式 "
":c:func:`Py_TYPE()` 函数而使用该函数，它将返回一个 :c:type:`PyTypeObject*` "
"类型的指针，除非是需要增强引用计数的时候。"

#: ../../c-api/object.rst:301
msgid ""
"Return true if the object *o* is of type *type* or a subtype of *type*.  "
"Both parameters must be non-``NULL``."
msgstr "如果对象 *o* 为 *type* 类型或 *type* 的子类型则返回真值。 两个参数都必须非 ``NULL``。"

#: ../../c-api/object.rst:310
msgid ""
"Return the length of object *o*.  If the object *o* provides either the "
"sequence and mapping protocols, the sequence length is returned.  On error, "
"``-1`` is returned.  This is the equivalent to the Python expression "
"``len(o)``."
msgstr ""
"返回对象 *o* 的长度。 如果对象 *o* 支持序列和映射协议，则返回序列长度。 出错时返回 ``-1``。这等同于 Python 表达式 "
"``len(o)``。"

#: ../../c-api/object.rst:317
msgid ""
"Return an estimated length for the object *o*. First try to return its "
"actual length, then an estimate using :meth:`~object.__length_hint__`, and "
"finally return the default value. On error return ``-1``. This is the "
"equivalent to the Python expression ``operator.length_hint(o, "
"defaultvalue)``."
msgstr ""
"返回对象 *o* 的估计长度。首先尝试返回实际长度，然后用  :meth:`~object.__length_hint__` "
"进行估计，最后返回默认值。出错时返回 ``-1``。这等同于 Python 表达式 ``operator.length_hint(o, "
"defaultvalue)``。"

#: ../../c-api/object.rst:327
msgid ""
"Return element of *o* corresponding to the object *key* or ``NULL`` on "
"failure. This is the equivalent of the Python expression ``o[key]``."
msgstr "返回对象 *key* 对应的 *o* 元素，或在失败时返回 ``NULL``。这等同于 Python 表达式 ``o[key]``。"

#: ../../c-api/object.rst:333
msgid ""
"Map the object *key* to the value *v*.  Raise an exception and return ``-1``"
" on failure; return ``0`` on success.  This is the equivalent of the Python "
"statement ``o[key] = v``.  This function *does not* steal a reference to "
"*v*."
msgstr ""
"将对象 *key* 映射到值 *v*。 失败时引发异常并返回 ``-1``；成功时返回 ``0``。 这相当于 Python 语句 ``o[key] ="
" v``。该函数 *不会* 偷取 *v* 的引用计数。"

#: ../../c-api/object.rst:341
msgid ""
"Remove the mapping for the object *key* from the object *o*.  Return ``-1`` "
"on failure.  This is equivalent to the Python statement ``del o[key]``."
msgstr "从对象 *o* 中移除对象 *key* 的映射。失败时返回 ``-1``。 这相当于 Python 语句 ``del o[key]``。"

#: ../../c-api/object.rst:347
msgid ""
"This is equivalent to the Python expression ``dir(o)``, returning a "
"(possibly empty) list of strings appropriate for the object argument, or "
"``NULL`` if there was an error.  If the argument is ``NULL``, this is like "
"the Python ``dir()``, returning the names of the current locals; in this "
"case, if no execution frame is active then ``NULL`` is returned but "
":c:func:`PyErr_Occurred` will return false."
msgstr ""
"相当于 Python 表达式 ``dir(o)``，返回一个（可能为空）适合对象参数的字符串列表，如果出错则返回 ``NULL``。 如果参数为 "
"``NULL``，类似 Python 的 ``dir()``，则返回当前 locals 的名字；这时如果没有活动的执行框架，则返回 ``NULL``，但"
" :c:func:`PyErr_Occurred` 将返回 false。"

#: ../../c-api/object.rst:356
msgid ""
"This is equivalent to the Python expression ``iter(o)``. It returns a new "
"iterator for the object argument, or the object  itself if the object is "
"already an iterator.  Raises :exc:`TypeError` and returns ``NULL`` if the "
"object cannot be iterated."
msgstr ""
"等同于 Python 表达式 "
"``iter(o)``。为对象参数返回一个新的迭代器，如果该对象已经是一个迭代器，则返回对象本身。如果对象不能被迭代，会引发  "
":exc:`TypeError` ，并返回  ``NULL``。"