# SOME DESCRIPTIVE TITLE.

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

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Rafael Fontenelle <[email protected]>, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

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

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

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

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

"MIME-Version: 1.0\n"

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

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

"Language: zh_CN\n"

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

#: ../../library/abc.rst:2

msgid ":mod:`!abc` --- Abstract Base Classes"

msgstr ":mod:`!abc` --- 抽象基类"

#: ../../library/abc.rst:11

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

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

#: ../../library/abc.rst:15

msgid ""

"This module provides the infrastructure for defining :term:`abstract base "

"classes <abstract base class>` (ABCs) in Python, as outlined in :pep:`3119`;"

" see the PEP for why this was added to Python. (See also :pep:`3141` and the"

" :mod:`numbers` module regarding a type hierarchy for numbers based on "

"ABCs.)"

msgstr ""

"该模块提供了在 Python 中定义 :term:`抽象基类 <abstract base class>` (ABC) 的组件，在 "

":pep:`3119` 中已有概述。查看 PEP 文档了解为什么需要在 Python 中增加这个模块。（也可查看 :pep:`3141` 以及 "

":mod:`numbers` 模块了解基于 ABC 的数字类型继承关系。）"

#: ../../library/abc.rst:20

msgid ""

"The :mod:`collections` module has some concrete classes that derive from "

"ABCs; these can, of course, be further derived. In addition, the "

":mod:`collections.abc` submodule has some ABCs that can be used to test "

"whether a class or instance provides a particular interface, for example, if"

" it is :term:`hashable` or if it is a :term:`mapping`."

msgstr ""

":mod:`collections` 模块中有一些派生自 ABC 的实体类；当然，这些类还可以进一步被派生。 "

"此外，:mod:`collections.abc` 子模块中有一些可被用于测试一个类或实例是否提供了特定接口的 ABC，例如，它是否为 "

":term:`hashable` 或者是否为 :term:`mapping` 等。"

#: ../../library/abc.rst:27

msgid ""

"This module provides the metaclass :class:`ABCMeta` for defining ABCs and a "

"helper class :class:`ABC` to alternatively define ABCs through inheritance:"

msgstr ""

"该模块提供了一个元类 :class:`ABCMeta`，可以用来定义抽象类，另外还提供一个工具类 "

":class:`ABC`，可以用它以继承的方式定义抽象基类。"

#: ../../library/abc.rst:32

msgid ""

"A helper class that has :class:`ABCMeta` as its metaclass. With this class,"

" an abstract base class can be created by simply deriving from :class:`!ABC`"

" avoiding sometimes confusing metaclass usage, for example::"

msgstr ""

"一个使用 :class:`ABCMeta` 作为元类的辅助类。 使用这个类，可以通过简单地从 :class:`!ABC` "

"派生的方式创建抽象基类，这将避免时常令人混淆的元类用法，例如::"

#: ../../library/abc.rst:36

msgid ""

"from abc import ABC\n"

"\n"

"class MyABC(ABC):\n"

" pass"

msgstr ""

"from abc import ABC\n"

"\n"

"class MyABC(ABC):\n"

" pass"

#: ../../library/abc.rst:41

msgid ""

"Note that the type of :class:`!ABC` is still :class:`ABCMeta`, therefore "

"inheriting from :class:`!ABC` requires the usual precautions regarding "

"metaclass usage, as multiple inheritance may lead to metaclass conflicts. "

"One may also define an abstract base class by passing the metaclass keyword "

"and using :class:`!ABCMeta` directly, for example::"

msgstr ""

"请注意 :class:`!ABC` 的类型仍然是 :class:`ABCMeta`，因此继承 :class:`!ABC` "

"仍然需要考虑使用元类的注意事项，比如可能会导致元类冲突的多重继承。 你也可以通过传入 metaclass 关键字并直接使用 "

":class:`!ABCMeta` 来定义抽象基类，例如::"

#: ../../library/abc.rst:47

msgid ""

"from abc import ABCMeta\n"

"\n"

"class MyABC(metaclass=ABCMeta):\n"

" pass"

msgstr ""

"from abc import ABCMeta\n"

"\n"

"class MyABC(metaclass=ABCMeta):\n"

" pass"

#: ../../library/abc.rst:57

msgid "Metaclass for defining Abstract Base Classes (ABCs)."

msgstr "用于定义抽象基类（ABC）的元类。"

#: ../../library/abc.rst:59

msgid ""

"Use this metaclass to create an ABC. An ABC can be subclassed directly, and"

" then acts as a mix-in class. You can also register unrelated concrete "

"classes (even built-in classes) and unrelated ABCs as \"virtual subclasses\""

" -- these and their descendants will be considered subclasses of the "

"registering ABC by the built-in :func:`issubclass` function, but the "

"registering ABC won't show up in their MRO (Method Resolution Order) nor "

"will method implementations defined by the registering ABC be callable (not "

"even via :func:`super`). [#]_"

msgstr ""

"使用该元类以创建抽象基类。抽象基类可以像 mix-in 类一样直接被子类继承。你也可以将不相关的具体类（包括内建类）和抽象基类注册为“抽象子类” —— "

"这些类以及它们的子类会被内建函数 :func:`issubclass` 识别为对应的抽象基类的子类，但是该抽象基类不会出现在其 MRO（Method "

"Resolution Order，方法解析顺序）中，抽象基类中实现的方法也不可调用（即使通过 :func:`super` 调用也不行）。[#]_"

#: ../../library/abc.rst:68

msgid ""

"Classes created with a metaclass of :class:`!ABCMeta` have the following "

"method:"

msgstr "使用 :class:`!ABCMeta` 元类创建的类具有以下方法："

#: ../../library/abc.rst:72

msgid "Register *subclass* as a \"virtual subclass\" of this ABC. For example::"

msgstr "将 *subclass* 注册为该 ABC 的“虚拟子类”。 例如::"

#: ../../library/abc.rst:75

msgid ""

"from abc import ABC\n"

"\n"

"class MyABC(ABC):\n"

" pass\n"

"\n"

"MyABC.register(tuple)\n"

"\n"

"assert issubclass(tuple, MyABC)\n"

"assert isinstance((), MyABC)"

msgstr ""

"from abc import ABC\n"

"\n"

"class MyABC(ABC):\n"

" pass\n"

"\n"

"MyABC.register(tuple)\n"

"\n"

"assert issubclass(tuple, MyABC)\n"

"assert isinstance((), MyABC)"

#: ../../library/abc.rst:85

msgid "Returns the registered subclass, to allow usage as a class decorator."

msgstr "返回注册的子类，使其能够作为类装饰器。"

#: ../../library/abc.rst:88

msgid ""

"To detect calls to :meth:`!register`, you can use the "

":func:`get_cache_token` function."

msgstr "要检测对 :meth:`!register` 的调用，你可以使用 :func:`get_cache_token` 函数。"

#: ../../library/abc.rst:92

msgid "You can also override this method in an abstract base class:"

msgstr "你也可以在虚基类中重写这个方法。"

#: ../../library/abc.rst:96

msgid "(Must be defined as a class method.)"

msgstr "（必须定义为类方法。）"

#: ../../library/abc.rst:98

msgid ""

"Check whether *subclass* is considered a subclass of this ABC. This means "

"that you can customize the behavior of :func:`issubclass` further without "

"the need to call :meth:`register` on every class you want to consider a "

"subclass of the ABC. (This class method is called from the "

":meth:`~type.__subclasscheck__` method of the ABC.)"

msgstr ""

"检查 *subclass* 是否为该 ABC 的子类。 这意味着你可以进一步定制 :func:`issubclass` 的行为而无需在每个你希望作为该 "

"ABC 的子类的类上调用 :meth:`register`。 （这个类方法是在该 ABC 的 "

":meth:`~type.__subclasscheck__` 方法上被调用的。）"

#: ../../library/abc.rst:104

msgid ""

"This method should return ``True``, ``False`` or :data:`NotImplemented`. If"

" it returns ``True``, the *subclass* is considered a subclass of this ABC. "

"If it returns ``False``, the *subclass* is not considered a subclass of this"

" ABC, even if it would normally be one. If it returns "

":data:`!NotImplemented`, the subclass check is continued with the usual "

"mechanism."

msgstr ""

"该方法应为返回 ``True`` , ``False`` 或 :data:`NotImplemented` 。如果返回 ``True`` ，则 *子类*"

" 被视为该抽象基类的子类 。如果返回 ``False`` ，则 *子类* 不被视为此抽象基类的子类 ，即使它通常是。 如果返回 "

":data:`!NotImplemented` ，则继续按照常规机制检查子类 。"

#: ../../library/abc.rst:114

msgid ""

"For a demonstration of these concepts, look at this example ABC definition::"

msgstr "为了对这些概念做一演示，请看以下定义 ABC 的示例："

#: ../../library/abc.rst:116

msgid ""

"class Foo:\n"

" def __getitem__(self, index):\n"

" ...\n"

" def __len__(self):\n"

" ...\n"

" def get_iterator(self):\n"

" return iter(self)\n"

"\n"

"class MyIterable(ABC):\n"

"\n"

" @abstractmethod\n"

" def __iter__(self):\n"

" while False:\n"

" yield None\n"

"\n"

" def get_iterator(self):\n"

" return self.__iter__()\n"

"\n"

" @classmethod\n"

" def __subclasshook__(cls, C):\n"

" if cls is MyIterable:\n"

" if any(\"__iter__\" in B.__dict__ for B in C.__mro__):\n"

" return True\n"

" return NotImplemented\n"

"\n"

"MyIterable.register(Foo)"

msgstr ""

"class Foo:\n"

" def __getitem__(self, index):\n"

" ...\n"

" def __len__(self):\n"

" ...\n"

" def get_iterator(self):\n"

" return iter(self)\n"

"\n"

"class MyIterable(ABC):\n"

"\n"

" @abstractmethod\n"

" def __iter__(self):\n"

" while False:\n"

" yield None\n"

"\n"

" def get_iterator(self):\n"

" return self.__iter__()\n"

"\n"

" @classmethod\n"

" def __subclasshook__(cls, C):\n"

" if cls is MyIterable:\n"

" if any(\"__iter__\" in B.__dict__ for B in C.__mro__):\n"

" return True\n"

" return NotImplemented\n"

"\n"

"MyIterable.register(Foo)"

#: ../../library/abc.rst:143

msgid ""

"The ABC ``MyIterable`` defines the standard iterable method, "

":meth:`~object.__iter__`, as an abstract method. The implementation given "

"here can still be called from subclasses. The :meth:`!get_iterator` method "

"is also part of the ``MyIterable`` abstract base class, but it does not have"

" to be overridden in non-abstract derived classes."

msgstr ""

"ABC ``MyIterable`` 将标准的可迭代对象方法 :meth:`~object.__iter__` 定义为一个抽象方法。 "

"这里给出的实现仍可以从子类中调用。 :meth:`!get_iterator` 方法也是 ``MyIterable`` "

"抽象基类的一部分，但它并非必须在非抽象的派生类中被重写。"

#: ../../library/abc.rst:149

msgid ""

"The :meth:`__subclasshook__` class method defined here says that any class "

"that has an :meth:`~object.__iter__` method in its :attr:`~object.__dict__` "

"(or in that of one of its base classes, accessed via the "

":attr:`~type.__mro__` list) is considered a ``MyIterable`` too."

msgstr ""

"这里定义的 :meth:`__subclasshook__` 类方法指明任何在其 :attr:`~object.__dict__` (或在其通过 "

":attr:`~type.__mro__` 列表访问的基本) 中具有 :meth:`~object.__iter__` 方法的类也都会被视为 "

"``MyIterable``。"

#: ../../library/abc.rst:154

msgid ""

"Finally, the last line makes ``Foo`` a virtual subclass of ``MyIterable``, "

"even though it does not define an :meth:`~object.__iter__` method (it uses "

"the old-style iterable protocol, defined in terms of :meth:`~object.__len__`"

" and :meth:`~object.__getitem__`). Note that this will not make "

"``get_iterator`` available as a method of ``Foo``, so it is provided "

"separately."

msgstr ""

"最后，末尾的行使得 ``Foo`` 成为 ``MyIterable`` 的一个虚子类，即使它没有定义 :meth:`~object.__iter__` "

"方法（它使用了以 :meth:`~object.__len__` 和 :meth:`~object.__getitem__` "

"等方法定义的旧式可迭代协议）。 请注意这将不会使 ``get_iterator`` 成为 ``Foo`` 可用的方法，所以它会被单独提供。"

#: ../../library/abc.rst:163

msgid "The :mod:`!abc` module also provides the following decorator:"

msgstr ":mod:`!abc` 模块还提供了下列装饰器："

#: ../../library/abc.rst:167

msgid "A decorator indicating abstract methods."

msgstr "用于声明抽象方法的装饰器。"

#: ../../library/abc.rst:169

msgid ""

"Using this decorator requires that the class's metaclass is :class:`ABCMeta`"

" or is derived from it. A class that has a metaclass derived from "

":class:`!ABCMeta` cannot be instantiated unless all of its abstract methods "

"and properties are overridden. The abstract methods can be called using any"

" of the normal 'super' call mechanisms. :func:`!abstractmethod` may be used"

" to declare abstract methods for properties and descriptors."

msgstr ""

"使用此装饰器要求类的元类是 :class:`ABCMeta` 或是其派生类。 一个具有派生自 :class:`!ABCMeta` "

"的元类的类无法被实例化，除非它全部的抽象方法和特征属性均已被重载。 抽象方法可通过任何普通的 'super' 调用机制来调用。 "

":func:`!abstractmethod` 可被用于声明特征属性和描述器的抽象方法。"

#: ../../library/abc.rst:176

msgid ""

"Dynamically adding abstract methods to a class, or attempting to modify the "

"abstraction status of a method or class once it is created, are only "

"supported using the :func:`update_abstractmethods` function. The "

":func:`!abstractmethod` only affects subclasses derived using regular "

"inheritance; \"virtual subclasses\" registered with the ABC's "

":meth:`~ABCMeta.register` method are not affected."

msgstr ""

"动态地添加抽象方法到一个类，或尝试在方法或类被创建后修改其抽象状态等操作仅在使用 :func:`update_abstractmethods` "

"函数时受到支持。 :func:`!abstractmethod` 只会影响使用常规继承所派生的子类；通过 ABC 的 "

":meth:`~ABCMeta.register` 方法注册的“虚子类”不会受到影响。"

#: ../../library/abc.rst:183

msgid ""

"When :func:`!abstractmethod` is applied in combination with other method "

"descriptors, it should be applied as the innermost decorator, as shown in "

"the following usage examples::"

msgstr "当 :func:`!abstractmethod` 与其他方法描述器配合应用时，它应当被应用为最内层的装饰器，如以下用法示例所示::"

#: ../../library/abc.rst:187

msgid ""

"class C(ABC):\n"

" @abstractmethod\n"

" def my_abstract_method(self, arg1):\n"

" ...\n"

" @classmethod\n"

" @abstractmethod\n"

" def my_abstract_classmethod(cls, arg2):\n"

" ...\n"

" @staticmethod\n"

" @abstractmethod\n"

" def my_abstract_staticmethod(arg3):\n"

" ...\n"

"\n"

" @property\n"

" @abstractmethod\n"

" def my_abstract_property(self):\n"

" ...\n"

" @my_abstract_property.setter\n"

" @abstractmethod\n"

" def my_abstract_property(self, val):\n"

" ...\n"

"\n"

" @abstractmethod\n"

" def _get_x(self):\n"

" ...\n"

" @abstractmethod\n"

" def _set_x(self, val):\n"

" ...\n"

" x = property(_get_x, _set_x)"

msgstr ""

"class C(ABC):\n"

" @abstractmethod\n"

" def my_abstract_method(self, arg1):\n"

" ...\n"

" @classmethod\n"

" @abstractmethod\n"

" def my_abstract_classmethod(cls, arg2):\n"

" ...\n"

" @staticmethod\n"

" @abstractmethod\n"

" def my_abstract_staticmethod(arg3):\n"

" ...\n"

"\n"

" @property\n"

" @abstractmethod\n"

" def my_abstract_property(self):\n"

" ...\n"

" @my_abstract_property.setter\n"

" @abstractmethod\n"

" def my_abstract_property(self, val):\n"

" ...\n"

"\n"

" @abstractmethod\n"

" def _get_x(self):\n"

" ...\n"

" @abstractmethod\n"

" def _set_x(self, val):\n"

" ...\n"

" x = property(_get_x, _set_x)"

#: ../../library/abc.rst:217

msgid ""

"In order to correctly interoperate with the abstract base class machinery, "

"the descriptor must identify itself as abstract using "

":attr:`!__isabstractmethod__`. In general, this attribute should be ``True``"

" if any of the methods used to compose the descriptor are abstract. For "

"example, Python's built-in :class:`property` does the equivalent of::"

msgstr ""

"为了正确地与抽象基类机制互操作，描述器必须使用 :attr:`!__isabstractmethod__` 将自身标识为抽象的。 "

"通常，如果组成描述器的任一方法是抽象的，那么此属性就应为 ``True``。 例如，Python 的内置 :class:`property` "

"所做的就等价于::"

#: ../../library/abc.rst:223

msgid ""

"class Descriptor:\n"

" ...\n"

" @property\n"

" def __isabstractmethod__(self):\n"

" return any(getattr(f, '__isabstractmethod__', False) for\n"

" f in (self._fget, self._fset, self._fdel))"

msgstr ""

"class Descriptor:\n"

" ...\n"

" @property\n"

" def __isabstractmethod__(self):\n"

" return any(getattr(f, '__isabstractmethod__', False) for\n"

" f in (self._fget, self._fset, self._fdel))"

#: ../../library/abc.rst:232

msgid ""

"Unlike Java abstract methods, these abstract methods may have an "

"implementation. This implementation can be called via the :func:`super` "

"mechanism from the class that overrides it. This could be useful as an end-"

"point for a super-call in a framework that uses cooperative multiple-"

"inheritance."

msgstr ""

"不同于 Java 抽象方法，这些抽象方法可能具有一个实现。 这个实现可在重写它的类上通过 :func:`super` 机制来调用。 "

"这在使用协作多重继承的框架中可以被用作 super 调用的一个终点。"

#: ../../library/abc.rst:239

msgid "The :mod:`!abc` module also supports the following legacy decorators:"

msgstr ":mod:`!abc` 模块还支持下列旧式装饰器："

#: ../../library/abc.rst:244

msgid ""

"It is now possible to use :class:`classmethod` with :func:`abstractmethod`, "

"making this decorator redundant."

msgstr "现在可以让 :class:`classmethod` 配合 :func:`abstractmethod` 使用，使得此装饰器变得冗余。"

#: ../../library/abc.rst:248

msgid ""

"A subclass of the built-in :func:`classmethod`, indicating an abstract "

"classmethod. Otherwise it is similar to :func:`abstractmethod`."

msgstr ""

"内置 :func:`classmethod` 的子类，指明一个抽象类方法。 在其他方面它都类似于 :func:`abstractmethod`。"

#: ../../library/abc.rst:251

msgid ""

"This special case is deprecated, as the :func:`classmethod` decorator is now"

" correctly identified as abstract when applied to an abstract method::"

msgstr "这个特例已被弃用，因为现在当 :func:`classmethod` 装饰器应用于抽象方法时它会被正确地标识为抽象的::"

#: ../../library/abc.rst:255

msgid ""

"class C(ABC):\n"

" @classmethod\n"

" @abstractmethod\n"

" def my_abstract_classmethod(cls, arg):\n"

" ..."

msgstr ""

"class C(ABC):\n"

" @classmethod\n"

" @abstractmethod\n"

" def my_abstract_classmethod(cls, arg):\n"

" ..."

#: ../../library/abc.rst:265

msgid ""

"It is now possible to use :class:`staticmethod` with :func:`abstractmethod`,"

" making this decorator redundant."

msgstr "现在可以让 :class:`staticmethod` 配合 :func:`abstractmethod` 使用，使得此装饰器变得冗余。"

#: ../../library/abc.rst:269

msgid ""

"A subclass of the built-in :func:`staticmethod`, indicating an abstract "

"staticmethod. Otherwise it is similar to :func:`abstractmethod`."

msgstr ""

"内置 :func:`staticmethod` 的子类，指明一个抽象静态方法。 在其他方面它都类似于 :func:`abstractmethod`。"

#: ../../library/abc.rst:272

msgid ""

"This special case is deprecated, as the :func:`staticmethod` decorator is "

"now correctly identified as abstract when applied to an abstract method::"

msgstr "这个特例已被弃用，因为现在当 :func:`staticmethod` 装饰器应用于抽象方法时它会被正确地标识为抽象的::"

#: ../../library/abc.rst:276

msgid ""

"class C(ABC):\n"

" @staticmethod\n"

" @abstractmethod\n"

" def my_abstract_staticmethod(arg):\n"

" ..."

msgstr ""

"class C(ABC):\n"

" @staticmethod\n"

" @abstractmethod\n"

" def my_abstract_staticmethod(arg):\n"

" ..."

#: ../../library/abc.rst:285

msgid ""

"It is now possible to use :class:`property`, :meth:`property.getter`, "

":meth:`property.setter` and :meth:`property.deleter` with "

":func:`abstractmethod`, making this decorator redundant."

msgstr ""

"现在可以让 :class:`property`, :meth:`property.getter`, :meth:`property.setter` 和 "

":meth:`property.deleter` 配合 :func:`abstractmethod` 使用，使得此装饰器变得冗余。"

#: ../../library/abc.rst:290

msgid ""

"A subclass of the built-in :func:`property`, indicating an abstract "

"property."

msgstr "内置 :func:`property` 的子类，指明一个抽象特性属性。"

#: ../../library/abc.rst:293

msgid ""

"This special case is deprecated, as the :func:`property` decorator is now "

"correctly identified as abstract when applied to an abstract method::"

msgstr "这个特例已被弃用，因为现在当 :func:`property` 装饰器应用于抽象方法时它会被正确地标识为抽象的::"

#: ../../library/abc.rst:297

msgid ""

"class C(ABC):\n"

" @property\n"

" @abstractmethod\n"

" def my_abstract_property(self):\n"

" ..."

msgstr ""

"class C(ABC):\n"

" @property\n"

" @abstractmethod\n"

" def my_abstract_property(self):\n"

" ..."

#: ../../library/abc.rst:303

msgid ""

"The above example defines a read-only property; you can also define a read-"

"write abstract property by appropriately marking one or more of the "

"underlying methods as abstract::"

msgstr "上面的例子定义了一个只读特征属性；你也可以通过适当地将一个或多个下层方法标记为抽象的来定义可读写的抽象特征属性::"

#: ../../library/abc.rst:307

msgid ""

"class C(ABC):\n"

" @property\n"

" def x(self):\n"

" ...\n"

"\n"

" @x.setter\n"

" @abstractmethod\n"

" def x(self, val):\n"

" ..."

msgstr ""

"class C(ABC):\n"

" @property\n"

" def x(self):\n"

" ...\n"

"\n"

" @x.setter\n"

" @abstractmethod\n"

" def x(self, val):\n"

" ..."

#: ../../library/abc.rst:317

msgid ""

"If only some components are abstract, only those components need to be "

"updated to create a concrete property in a subclass::"

msgstr "如果只有某些组件是抽象的，则只需更新那些组件即可在子类中创建具体的特征属性::"

#: ../../library/abc.rst:320

msgid ""

"class D(C):\n"

" @C.x.setter\n"

" def x(self, val):\n"

" ..."

msgstr ""

"class D(C):\n"

" @C.x.setter\n"

" def x(self, val):\n"

" ..."

#: ../../library/abc.rst:326

msgid "The :mod:`!abc` module also provides the following functions:"

msgstr ":mod:`!abc` 模块还提供了下列函数："

#: ../../library/abc.rst:330

msgid "Returns the current abstract base class cache token."

msgstr "返回当前抽象基类的缓存令牌"

#: ../../library/abc.rst:332

msgid ""

"The token is an opaque object (that supports equality testing) identifying "

"the current version of the abstract base class cache for virtual subclasses."

" The token changes with every call to :meth:`ABCMeta.register` on any ABC."

msgstr ""

"此令牌是一个不透明对象（支持相等性测试），用于为虚子类标识抽象基类缓存的当前版本。 此令牌会在任何 ABC 上每次调用 "

":meth:`ABCMeta.register` 时发生更改。"

#: ../../library/abc.rst:340

msgid ""

"A function to recalculate an abstract class's abstraction status. This "

"function should be called if a class's abstract methods have been "

"implemented or changed after it was created. Usually, this function should "

"be called from within a class decorator."

msgstr ""

"重新计算一个抽象类的抽象状态的函数。 如果一个类的抽象方法在类被创建后被实现或被修改则应当调用此函数。 通常，此函数应当在一个类装饰器内部被调用。"

#: ../../library/abc.rst:345

msgid "Returns *cls*, to allow usage as a class decorator."

msgstr "返回 *cls*，使其能够用作类装饰器。"

#: ../../library/abc.rst:347

msgid "If *cls* is not an instance of :class:`ABCMeta`, does nothing."

msgstr "如果 *cls* 不是 :class:`ABCMeta` 的子类，则不做任何操作。"

#: ../../library/abc.rst:351

msgid ""

"This function assumes that *cls*'s superclasses are already updated. It does"

" not update any subclasses."

msgstr "此函数会假定 *cls* 的上级类已经被更新。 它不会更新任何子类。"

#: ../../library/abc.rst:357

msgid "Footnotes"

msgstr "备注"

#: ../../library/abc.rst:358

msgid ""

"C++ programmers should note that Python's virtual base class concept is not "

"the same as C++'s."

msgstr "C++ 程序员需要注意：Python 中虚基类的概念和 C++ 中的并不相同。"