abc.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# eric R <trencyclopedia@gmail.com>, 2019
# cissoid <yangtukun1412@gmail.com>, 2019
# wenhui <suwenhui1991@gmail.com>, 2019
# Alpha Du <alphanow@gmail.com>, 2019
# Jarry Shaw <jarryshaw@icloud.com>, 2019
# Freesand Leo <yuqinju@163.com>, 2020
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 16:02+0000\n"
"PO-Revision-Date: 2019-09-01 03:24+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2020\n"
"Language-Team: Chinese (China) (https://www.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 hashable or if it is a mapping."
msgstr ""
":mod:`collections` 模块中有一些派生自 ABC "
"的具体类；当然这些类还可以进一步被派生。此外，:mod:`collections.abc` 子模块中有一些 ABC "
"可被用于测试一个类或实例是否提供特定的接口，例如它是否可哈希或它是否为映射等。"

#: ../../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: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` "
"仍然需要关注元类使用中的注意事项，比如可能会导致元类冲突的多重继承。当然你也可以直接使用 :class:`ABCMeta` "
"作为元类来定义抽象基类，例如："

#: ../../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 "将“子类”注册为该抽象基类的“抽象子类”，例如："

#: ../../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 "你可以使用 :func:`get_cache_token` 函数来检测对 :meth:`register` 的调用。"

#: ../../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 ``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:`__subclasscheck__` method of the ABC.)"
msgstr ""
"检查 *subclass* 是否是该抽象基类的子类。也就是说对于那些你希望定义为该抽象基类的子类的类，你不用对每个类都调用 "
":meth:`register` 方法了，而是可以直接自定义 ``issubclass`` 的行为。（这个类方法是在抽象基类的 "
":meth:`__subclasscheck__` 方法中调用的。）"

#: ../../library/abc.rst:104
msgid ""
"This method should return ``True``, ``False`` or ``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 ``NotImplemented``, the "
"subclass check is continued with the usual mechanism."
msgstr ""
"该方法必须返回 ``True``, ``False`` 或是 ``NotImplemented``。如果返回 ``True``，*subclass* "
"就会被认为是这个抽象基类的子类。如果返回 ``False``，无论正常情况是否应该认为是其子类，统一视为不是。如果返回 "
"``NotImplemented``，子类检查会按照正常机制继续执行。"

#: ../../library/abc.rst:114
msgid ""
"For a demonstration of these concepts, look at this example ABC definition::"
msgstr "为了对这些概念做一演示，请看以下定义 ABC 的示例："

#: ../../library/abc.rst:143
msgid ""
"The ABC ``MyIterable`` defines the standard iterable method, "
":meth:`~iterator.__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:`~iterator.__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:`~iterator.__iter__` method in its "
":attr:`~object.__dict__` (or in that of one of its base classes, accessed "
"via the :attr:`~class.__mro__` list) is considered a ``MyIterable`` too."
msgstr ""
"这里定义的 :meth:`__subclasshook__` 类方法指明了任何在其 :attr:`~object.__dict__` (或在其通过 "
":attr:`~class.__mro__` 列表访问的基类) 中具有 :meth:`~iterator.__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:`~iterator.__iter__` method (it uses"
" the old-style iterable protocol, defined in terms of :meth:`__len__` and "
":meth:`__getitem__`).  Note that this will not make ``get_iterator`` "
"available as a method of ``Foo``, so it is provided separately."
msgstr ""
"最后，末尾行使得 ``Foo`` 成为 ``MyIterable`` 的一个虚子类，即使它没有定义 :meth:`~iterator.__iter__`"
" 方法（它使用了以 :meth:`__len__` 和 :meth:`__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 not "
"supported.  The :func:`abstractmethod` only affects subclasses derived using"
" regular inheritance; \"virtual subclasses\" registered with the ABC's "
":meth:`register` method are not affected."
msgstr ""
"不支持动态添加抽象方法到一个类，或试图在方法或类被创建后修改其抽象状态等操作。 :func:`abstractmethod` "
"只会影响使用常规继承所派生的子类；通过 ABC 的 :meth:`register` 方法注册的“虚子类”不会受到影响。"

#: ../../library/abc.rst:182
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:216
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:231
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` 机制来调用。 "
"这在使用协作多重继承的框架中可以被用作超调用的一个端点。"

#: ../../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: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: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: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: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: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 "Footnotes"
msgstr "备注"

#: ../../library/abc.rst:341
msgid ""
"C++ programmers should note that Python's virtual base class concept is not "
"the same as C++'s."
msgstr "C++ 程序员需要注意：Python 中虚基类的概念和 C++ 中的并不相同。"