abc.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Adrian Liaw <adrianliaw2000@gmail.com>, 2018
# Matt Wang <mattwang44@gmail.com>, 2022
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-09-27 00:14+0000\n"
"PO-Revision-Date: 2022-11-16 03:29+0800\n"
"Last-Translator: Matt Wang <mattwang44@gmail.com>\n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.2\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 ""
"如同在 :pep:`3119` 中所述，該模組提供了在 Python 中定義\\ :term:`抽象基底類"
"別 <abstract base class>` (ABC) 的基礎元件；若想瞭解為什麼需要在 Python 中增"
"加這個模組，請見 PEP 文件。（也請見 :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) "
"<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 ""
"該模組提供了一個用來定義 ABC 的元類別 (metaclass) :class:`ABCMeta` 和另一個以"
"繼承的方式定義 ABC 的工具類別 :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` 仍然"
"需要關注使用元類別的注意事項，如多重繼承可能會導致元類別衝突。當然你也可以傳"
"入元類別關鍵字並直接使用 :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 ""
"使用該元類別以建立一個 ABC。一個 ABC 可以像 mix-in 類別一樣直接被子類別繼承。"
"你也可以將不相關的具體類別（甚至是內建類別）和 ABC 註冊為「虛擬子類別 "
"(virtual subclass)」 —— 這些類別以及它們的子類別會被內建函式 :func:"
"`issubclass` 識別為已註冊 ABC 的子類別，但是該 ABC 不會出現在其 MRO（Method "
"Resolution Order，方法解析順序）中，由該 ABC 所定義的方法實作也不可呼叫（即使"
"透過 :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 "將\\ *子類別*\\ 註冊為該 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 ""
"你可以使用 :func:`get_cache_token` 函式來檢測對 :meth:`!register` 的呼叫。"

#: ../../library/abc.rst:92
msgid "You can also override this method in an abstract base class:"
msgstr "你也可以覆寫 (override) 虛擬基底類別中的這個方法："

#: ../../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``，*subclass* 就會被認為是這個 ABC 的子類別。如果回傳 ``False``，"
"*subclass* 就會被判定並非該 ABC 的子類別，即便正常情況應如此。如果回傳 :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:"
"`~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:"
"`~type.__mro__` list) is considered a ``MyIterable`` too."
msgstr ""
"這裡定義的 :meth:`__subclasshook__` 類別方法說明任何在其 :attr:`~object."
"__dict__` (或在其透過 :attr:`~type.__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:`~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`` 沒有定義 :meth:`~iterator.__iter__` 方法（它使用了以 :"
"meth:`~object.__len__` 和 :meth:`~object.__getitem__` 所定義的舊式可疊代物件"
"協定），最末一行使其成為 ``MyIterable`` 的一個虛擬子類別。請注意這不會使 "
"``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` 與其他方法描述器 (method descriptor) 配合應用時，"
"它應被當最內層的裝飾器，如以下用法範例所示： ::"

#: ../../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 ""
"為了能正確地與 ABC 機制實作相互操作，描述器必須使用 :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` 機制來呼叫。這在使用協作多重繼承 (cooperative multiple-"
"inheritance) 的框架中，可以被用作 super 呼叫的一個端點 (end-point)。"

#: ../../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 "回傳當前 ABC 快取令牌 (cache token)。"

#: ../../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 ""
"此令牌是一個（支援相等性測試的）不透明物件 (opaque object)，用於為虛擬子類別"
"標識抽象基底類別快取的當前版本。此令牌會在任何 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* 的超類別 (superclass) 已經被更新。它不會更新任何子類別。"

#: ../../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++ 中的並不相同。"