abc.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# 秘湯 <xwhhsprings@gmail.com>, 2017
# 松井 鉄史 <VED03370@nifty.ne.jp>, 2017
# Inada Naoki <songofacandy@gmail.com>, 2017
# Arihiro TAKASE, 2017
# hitsumabushi.org, 2018
# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2018
# tomo, 2019
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 12:40+0000\n"
"PO-Revision-Date: 2017-02-16 17:47+0000\n"
"Last-Translator: tomo, 2019\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\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 に :pep:`3119` で概要が示された :term:`抽象基底クラス <abstract base class>`"
" (ABC) を定義する基盤を提供します。なぜこれが Python に付け加えられたかについてはその PEP を参照してください。 (ABC "
"に基づいた数の型階層を扱った :pep:`3141` と :mod:`numbers` モジュールも参照してください。)"

#: ../../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` サブモジュールには ABC から派生した具象クラスがいくつかあります。\n"
"もちろん、このクラスから、さらに派生させることもできます。\n"
"また :mod:`collections.abs` サブモジュールにはいくつかの 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` "
"から継承するときは、メタクラスの衝突を引き起こし得る多重継承のような、メタクラスを使う上でのいつもの用心が求められることに注意してください。 "
"metaclass キーワードを渡し、 :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 ""
"ABC を作るときにこのメタクラスを使います。ABC は直接的にサブクラス化することができ、ミックスイン(mix-"
"in)クラスのように振る舞います。また、無関係な具象クラス(組み込み型でも構いません)と無関係な ABC を \"仮想的サブクラス\" "
"として登録できます -- これらとその子孫は組み込み関数 :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 "*subclass* を \"仮想的サブクラス\" としてこの ABC に登録します。たとえば::"

#: ../../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 ``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* がこの ABC のサブクラスと見なせるかどうかチェックします。これによって ABC のサブクラスと見なしたい全てのクラスについて "
":meth:`register` を呼び出すことなく ``issubclass`` の振る舞いをさらにカスタマイズできます。 (このクラスメソッドは "
"ABC の :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* はこの ABC のサブクラスと見なされます。``False`` を返す場合は、*subclass* "
"はたとえ通常の意味でサブクラスであっても ABC のサブクラスではないと見なされます。``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__` の意味は、 :meth:`~iterator.__iter__` "
"メソッドがクラスの(または :attr:`~class.__mro__` でアクセスされる基底クラスの一つの) "
":attr:`~object.__dict__` にある場合にもそのクラスが ``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`` を :meth:`~iterator.__iter__` メソッドを定義しないにもかかわらず "
"``MyIterable`` の仮想的サブクラスにします(``Foo`` は古い様式の :meth:`__len__` と "
":meth:`__getitem__` を用いたイテレータプロトコルを使っています。)。これによって ``Foo`` のメソッドとして "
"``get_iterator`` が手に入るわけではないことに注意してください。それは別に提供されています。"

#: ../../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 ""
"デスクリプタをABC 機構と協調させるために、デスクリプタは :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` "
"メカニズムを通してそれをオーバーライドしたクラスから呼び出すことができます。これは協調的多重継承を使ったフレームワークにおいて 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 ""
"この例は読み出し専用のプロパティを定義しています。プロパティを構成するメソッドの1つ以上を abstract "
"にすることで、読み書きできる抽象プロパティを定義することができます::"

#: ../../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 ""
"構成するメソッド全てが abstract でない場合、abstract "
"と定義されたメソッドのみが、具象サブクラスによってオーバーライドする必要があります::"

#: ../../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 ""
"このトークンは、仮想サブクラスのための抽象基底クラスの現在のバージョンを特定する (等価性検査をサポートしている) 不透明なオブジェクトです。\n"
"任意の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++ のものと同じではないということを銘記すべきです。"