# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# tomo, 2021

# mollinaca, 2021

# 渋川よしき <yoshiki@shibu.jp>, 2021

# souma987, 2023

# TENMYO Masakazu, 2024

# Arihiro TAKASE, 2024

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-05-08 02:53-0300\n"

"PO-Revision-Date: 2021-06-28 00:53+0000\n"

"Last-Translator: Arihiro TAKASE, 2024\n"

"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"

"ja/)\n"

"Language: ja\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"

#: ../../howto/descriptor.rst:5

msgid "Descriptor Guide"

msgstr "デスクリプタ ガイド"

#: ../../howto/descriptor.rst:0

msgid "Author"

msgstr "著者"

#: ../../howto/descriptor.rst:7

msgid "Raymond Hettinger"

msgstr "Raymond Hettinger"

#: ../../howto/descriptor.rst:0

msgid "Contact"

msgstr "問い合わせ先"

#: ../../howto/descriptor.rst:8

msgid "<python at rcn dot com>"

msgstr "<python at rcn dot com>"

#: ../../howto/descriptor.rst:11

msgid "Contents"

msgstr "内容"

#: ../../howto/descriptor.rst:13

msgid ""

":term:`Descriptors <descriptor>` let objects customize attribute lookup, "

"storage, and deletion."

msgstr ""

":term:`デスクリプタ <descriptor>` を使うと、オブジェクトの属性検索、保存、削"

"除をカスタマイズできます。"

#: ../../howto/descriptor.rst:16

msgid "This guide has four major sections:"

msgstr "本ガイドは4つの大項目から構成されています。"

#: ../../howto/descriptor.rst:18

msgid ""

"The \"primer\" gives a basic overview, moving gently from simple examples, "

"adding one feature at a time. Start here if you're new to descriptors."

msgstr ""

"最初の「入門」では基本の紹介をして、シンプルな例から少しずつ概念を説明してい"

"きます。もしデスクリプタに触れるのが初めての場合はここから学んでいきましょ"

"う。"

#: ../../howto/descriptor.rst:21

msgid ""

"The second section shows a complete, practical descriptor example. If you "

"already know the basics, start there."

msgstr ""

"2つ目のセクションでは完全で実践的なデスクリプタのサンプルを紹介します。もしデ"

"スクリプタの基本を理解しているのであれば、ここから読み始めても良いでしょう。"

#: ../../howto/descriptor.rst:24

msgid ""

"The third section provides a more technical tutorial that goes into the "

"detailed mechanics of how descriptors work. Most people don't need this "

"level of detail."

msgstr ""

"3番目のセクションはより技巧的なチュートリアルを通じて、デスクリプタがどのよう"

"なメカニズムで動作しているのかを紹介します。多くの人はこのレベルの理解は不要"

"でしょう。"

#: ../../howto/descriptor.rst:28

msgid ""

"The last section has pure Python equivalents for built-in descriptors that "

"are written in C. Read this if you're curious about how functions turn into "

"bound methods or about the implementation of common tools like :func:"

"`classmethod`, :func:`staticmethod`, :func:`property`, and :term:`__slots__`."

msgstr ""

"最後のセクションは、Cで書かれた組み込みのデスクリプタをピュアPythonで実現する"

"方法を紹介します。このセクションがどのように関数が束縛メソッドになるのか、 :"

"func:`classmethod` や :func:`staticmethod`, :func:`property`, :term:"

"`__slots__` といった一般的なツールの実装がどのようになっているのか興味を持っ"

"たら読んでください。"

#: ../../howto/descriptor.rst:36

msgid "Primer"

msgstr "入門"

#: ../../howto/descriptor.rst:38

msgid ""

"In this primer, we start with the most basic possible example and then we'll "

"add new capabilities one by one."

msgstr ""

"この入門では、なるべく基礎的なところから開始し、新しい要素を一つずつ紹介して"

"いきます。"

#: ../../howto/descriptor.rst:43

msgid "Simple example: A descriptor that returns a constant"

msgstr "シンプルな例: 定数を返すデスクリプタ"

#: ../../howto/descriptor.rst:45

msgid ""

"The :class:`!Ten` class is a descriptor whose :meth:`~object.__get__` method "

"always returns the constant ``10``:"

msgstr ""

#: ../../howto/descriptor.rst:48

msgid ""

"class Ten:\n"

" def __get__(self, obj, objtype=None):\n"

" return 10"

msgstr ""

#: ../../howto/descriptor.rst:54

msgid ""

"To use the descriptor, it must be stored as a class variable in another "

"class:"

msgstr "このデスクリプタを使うには他のクラスのクラス変数として保存します:"

#: ../../howto/descriptor.rst:56

msgid ""

"class A:\n"

" x = 5 # Regular class attribute\n"

" y = Ten() # Descriptor instance"

msgstr ""

#: ../../howto/descriptor.rst:62

msgid ""

"An interactive session shows the difference between normal attribute lookup "

"and descriptor lookup:"

msgstr ""

"インタラクティブセッションを使って、通常の属性ルックアップと、デスクリプタの"

"ルックアップの違いを見てみましょう。"

#: ../../howto/descriptor.rst:65

msgid ""

">>> a = A() # Make an instance of class A\n"

">>> a.x # Normal attribute lookup\n"

"5\n"

">>> a.y # Descriptor lookup\n"

"10"

msgstr ""

#: ../../howto/descriptor.rst:73

msgid ""

"In the ``a.x`` attribute lookup, the dot operator finds ``'x': 5`` in the "

"class dictionary. In the ``a.y`` lookup, the dot operator finds a "

"descriptor instance, recognized by its ``__get__`` method. Calling that "

"method returns ``10``."

msgstr ""

"``a.x`` 属性ルックアップではドット演算子がクラス辞書の中から ``'x': 5`` を見"

"つけます。 ``a.y`` ルックアップではドット演算子は ``__get__`` メソッドを持つ"

"デスクリプタインスタンスを取得します。そのメソッドを呼び出すと、 ``10`` を返"

"します。"

#: ../../howto/descriptor.rst:78

msgid ""

"Note that the value ``10`` is not stored in either the class dictionary or "

"the instance dictionary. Instead, the value ``10`` is computed on demand."

msgstr ""

"``10`` はクラスの辞書にも、インスタンスの辞書にも格納されていません。その代わ"

"り、 ``10`` はオンデマンドに計算されます。"

#: ../../howto/descriptor.rst:81

msgid ""

"This example shows how a simple descriptor works, but it isn't very useful. "

"For retrieving constants, normal attribute lookup would be better."

msgstr ""

"このサンプルは、シンプルなデスクリプタがどのように動作するかを説明するための"

"ものですが、実用的ではありません。定数を返す場合、通常の属性アクセスの方が良"

"いでしょう。"

#: ../../howto/descriptor.rst:84

msgid ""

"In the next section, we'll create something more useful, a dynamic lookup."

msgstr "次のセクションでは、より実践的な動的なルックアップを作成します。"

#: ../../howto/descriptor.rst:88

msgid "Dynamic lookups"

msgstr "動的なルックアップ"

#: ../../howto/descriptor.rst:90

msgid ""

"Interesting descriptors typically run computations instead of returning "

"constants:"

msgstr ""

"単に定数を返すよりも、なにか処理を実行するデスクリプタの方が面白いでしょう。"

#: ../../howto/descriptor.rst:93

msgid ""

"import os\n"

"\n"

"class DirectorySize:\n"

"\n"

" def __get__(self, obj, objtype=None):\n"

" return len(os.listdir(obj.dirname))\n"

"\n"

"class Directory:\n"

"\n"

" size = DirectorySize() # Descriptor instance\n"

"\n"

" def __init__(self, dirname):\n"

" self.dirname = dirname # Regular instance attribute"

msgstr ""

#: ../../howto/descriptor.rst:109

msgid ""

"An interactive session shows that the lookup is dynamic — it computes "

"different, updated answers each time::"

msgstr ""

"インタラクティブセッションで見たように、この探索は動的です。実行ごとに異なる"

"計算を行い、毎回答えが更新されます。"

#: ../../howto/descriptor.rst:112

msgid ""

">>> s = Directory('songs')\n"

">>> g = Directory('games')\n"

">>> s.size # The songs directory has twenty "

"files\n"

"20\n"

">>> g.size # The games directory has three "

"files\n"

"3\n"

">>> os.remove('games/chess') # Delete a game\n"

">>> g.size # File count is automatically "

"updated\n"

"2"

msgstr ""

#: ../../howto/descriptor.rst:122

msgid ""

"Besides showing how descriptors can run computations, this example also "

"reveals the purpose of the parameters to :meth:`~object.__get__`. The "

"*self* parameter is *size*, an instance of *DirectorySize*. The *obj* "

"parameter is either *g* or *s*, an instance of *Directory*. It is the *obj* "

"parameter that lets the :meth:`~object.__get__` method learn the target "

"directory. The *objtype* parameter is the class *Directory*."

msgstr ""

#: ../../howto/descriptor.rst:131

msgid "Managed attributes"

msgstr "管理された属性"

#: ../../howto/descriptor.rst:133

msgid ""

"A popular use for descriptors is managing access to instance data. The "

"descriptor is assigned to a public attribute in the class dictionary while "

"the actual data is stored as a private attribute in the instance "

"dictionary. The descriptor's :meth:`~object.__get__` and :meth:`~object."

"__set__` methods are triggered when the public attribute is accessed."

msgstr ""

#: ../../howto/descriptor.rst:139

msgid ""

"In the following example, *age* is the public attribute and *_age* is the "

"private attribute. When the public attribute is accessed, the descriptor "

"logs the lookup or update:"

msgstr ""

"このサンプルでは *age* はパブリックな属性で、 *_age* はプライベートな属性で"

"す。パブリックな属性がアクセスされると、デスクリプタはルックアップや更新のロ"

"グ出力をします。"

#: ../../howto/descriptor.rst:143

msgid ""

"import logging\n"

"\n"

"logging.basicConfig(level=logging.INFO)\n"

"\n"

"class LoggedAgeAccess:\n"

"\n"

" def __get__(self, obj, objtype=None):\n"

" value = obj._age\n"

" logging.info('Accessing %r giving %r', 'age', value)\n"

" return value\n"

"\n"

" def __set__(self, obj, value):\n"

" logging.info('Updating %r to %r', 'age', value)\n"

" obj._age = value\n"

"\n"

"class Person:\n"

"\n"

" age = LoggedAgeAccess() # Descriptor instance\n"

"\n"

" def __init__(self, name, age):\n"

" self.name = name # Regular instance attribute\n"

" self.age = age # Calls __set__()\n"

"\n"

" def birthday(self):\n"

" self.age += 1 # Calls both __get__() and __set__()"

msgstr ""

#: ../../howto/descriptor.rst:172

msgid ""

"An interactive session shows that all access to the managed attribute *age* "

"is logged, but that the regular attribute *name* is not logged:"

msgstr ""

"インタラクティブセッションの結果で見てわかるように、管理された属性の *age* の"

"ログ出力が行われますが、通常の属性の *name* はログ出力されません。"

#: ../../howto/descriptor.rst:181

msgid ""

">>> mary = Person('Mary M', 30) # The initial age update is logged\n"

"INFO:root:Updating 'age' to 30\n"

">>> dave = Person('David D', 40)\n"

"INFO:root:Updating 'age' to 40\n"

"\n"

">>> vars(mary) # The actual data is in a private "

"attribute\n"

"{'name': 'Mary M', '_age': 30}\n"

">>> vars(dave)\n"

"{'name': 'David D', '_age': 40}\n"

"\n"

">>> mary.age # Access the data and log the "

"lookup\n"

"INFO:root:Accessing 'age' giving 30\n"

"30\n"

">>> mary.birthday() # Updates are logged as well\n"

"INFO:root:Accessing 'age' giving 30\n"

"INFO:root:Updating 'age' to 31\n"

"\n"

">>> dave.name # Regular attribute lookup isn't "

"logged\n"

"'David D'\n"

">>> dave.age # Only the managed attribute is "

"logged\n"

"INFO:root:Accessing 'age' giving 40\n"

"40"

msgstr ""

#: ../../howto/descriptor.rst:206

msgid ""

"One major issue with this example is that the private name *_age* is "

"hardwired in the *LoggedAgeAccess* class. That means that each instance can "

"only have one logged attribute and that its name is unchangeable. In the "

"next example, we'll fix that problem."

msgstr ""

"このサンプル実装には大きな問題があります。プライベートな名前の *_age* が "

"*LoggedAgeAccess* クラスの中でハードコードされています。そのため、どのインス"

"タンスも1つしかこのログ出力される属性が作れず、名前を変更できません。次のサン"

"プルでこの問題を解決していきます。"

#: ../../howto/descriptor.rst:213

msgid "Customized names"

msgstr "名前のカスタマイズ"

#: ../../howto/descriptor.rst:215

msgid ""

"When a class uses descriptors, it can inform each descriptor about which "

"variable name was used."

msgstr ""

"クラスがデスクリプタを使うときに、クラスはそれぞれのデスクリプタにどのような"

"変数名を使うかを通知します。"

#: ../../howto/descriptor.rst:218

msgid ""

"In this example, the :class:`!Person` class has two descriptor instances, "

"*name* and *age*. When the :class:`!Person` class is defined, it makes a "

"callback to :meth:`~object.__set_name__` in *LoggedAccess* so that the field "

"names can be recorded, giving each descriptor its own *public_name* and "

"*private_name*:"

msgstr ""

#: ../../howto/descriptor.rst:223

msgid ""

"import logging\n"

"\n"

"logging.basicConfig(level=logging.INFO)\n"

"\n"

"class LoggedAccess:\n"

"\n"

" def __set_name__(self, owner, name):\n"

" self.public_name = name\n"

" self.private_name = '_' + name\n"

"\n"

" def __get__(self, obj, objtype=None):\n"

" value = getattr(obj, self.private_name)\n"

" logging.info('Accessing %r giving %r', self.public_name, value)\n"

" return value\n"

"\n"

" def __set__(self, obj, value):\n"

" logging.info('Updating %r to %r', self.public_name, value)\n"

" setattr(obj, self.private_name, value)\n"

"\n"

"class Person:\n"

"\n"

" name = LoggedAccess() # First descriptor instance\n"

" age = LoggedAccess() # Second descriptor instance\n"

"\n"

" def __init__(self, name, age):\n"

" self.name = name # Calls the first descriptor\n"

" self.age = age # Calls the second descriptor\n"

"\n"

" def birthday(self):\n"

" self.age += 1"

msgstr ""

#: ../../howto/descriptor.rst:256

msgid ""

"An interactive session shows that the :class:`!Person` class has called :"

"meth:`~object.__set_name__` so that the field names would be recorded. Here "

"we call :func:`vars` to look up the descriptor without triggering it:"

msgstr ""

#: ../../howto/descriptor.rst:260

msgid ""

">>> vars(vars(Person)['name'])\n"

"{'public_name': 'name', 'private_name': '_name'}\n"

">>> vars(vars(Person)['age'])\n"

"{'public_name': 'age', 'private_name': '_age'}"

msgstr ""

#: ../../howto/descriptor.rst:267

msgid "The new class now logs access to both *name* and *age*:"

msgstr "新しいクラスは *name* と *age* の両方でログを出力します。"

#: ../../howto/descriptor.rst:275

msgid ""

">>> pete = Person('Peter P', 10)\n"

"INFO:root:Updating 'name' to 'Peter P'\n"

"INFO:root:Updating 'age' to 10\n"

">>> kate = Person('Catherine C', 20)\n"

"INFO:root:Updating 'name' to 'Catherine C'\n"

"INFO:root:Updating 'age' to 20"

msgstr ""

#: ../../howto/descriptor.rst:284

msgid "The two *Person* instances contain only the private names:"

msgstr "2つの *Person* のインスタンスは、プライベート名しか保持していません。"

#: ../../howto/descriptor.rst:286

msgid ""

">>> vars(pete)\n"

"{'_name': 'Peter P', '_age': 10}\n"

">>> vars(kate)\n"

"{'_name': 'Catherine C', '_age': 20}"

msgstr ""

#: ../../howto/descriptor.rst:295

msgid "Closing thoughts"

msgstr "まとめ"

#: ../../howto/descriptor.rst:297

msgid ""

"A :term:`descriptor` is what we call any object that defines :meth:`~object."

"__get__`, :meth:`~object.__set__`, or :meth:`~object.__delete__`."

msgstr ""

#: ../../howto/descriptor.rst:300

msgid ""

"Optionally, descriptors can have a :meth:`~object.__set_name__` method. "

"This is only used in cases where a descriptor needs to know either the class "

"where it was created or the name of class variable it was assigned to. "

"(This method, if present, is called even if the class is not a descriptor.)"

msgstr ""

#: ../../howto/descriptor.rst:305

msgid ""

"Descriptors get invoked by the dot operator during attribute lookup. If a "

"descriptor is accessed indirectly with ``vars(some_class)"

"[descriptor_name]``, the descriptor instance is returned without invoking it."

msgstr ""

"デスクリプタは属性のルックアップ中に、ドット演算子によって呼び出されます。 "

"``vars(some_class)[descriptor_name]`` という書き方によって間接的にデスクリプ"

"タがアクセスされると、デスクリプタを実行することなく、デスクリプタのインスタ"

"ンスが返されます。"

#: ../../howto/descriptor.rst:309

msgid ""

"Descriptors only work when used as class variables. When put in instances, "

"they have no effect."

msgstr ""

"デスクリプタはクラス変数として利用したときにだけ動作します。インスタンスに設"

"定しても効果はありません。"

#: ../../howto/descriptor.rst:312

msgid ""

"The main motivation for descriptors is to provide a hook allowing objects "

"stored in class variables to control what happens during attribute lookup."

msgstr ""

"デスクリプタは、クラス変数として格納されているオブジェクトが属性ルックアップ"

"中に発生することを制御できるように、フックを提供することが主なモチベーション"

"となっています。"

#: ../../howto/descriptor.rst:315

msgid ""

"Traditionally, the calling class controls what happens during lookup. "

"Descriptors invert that relationship and allow the data being looked-up to "

"have a say in the matter."

msgstr ""

"伝統的には、呼び出し側のクラスが、ルックアップ中に発生することを制御してきま"

"したが、デスクリプタはその関係を逆転させ、検索されているデータが問題に介入で"

"きるようにします。"

#: ../../howto/descriptor.rst:319

msgid ""

"Descriptors are used throughout the language. It is how functions turn into "

"bound methods. Common tools like :func:`classmethod`, :func:"

"`staticmethod`, :func:`property`, and :func:`functools.cached_property` are "

"all implemented as descriptors."

msgstr ""

"デスクリプタは、Pythonのさまざまなところで利用されています。これにより、単な"

"る関数は、インスタンスに束縛されたメソッドになります。 :func:`classmethod`, :"

"func:`staticmethod`, :func:`property`, :func:`functools.cached_property` と"

"いったツールもすべて、デスクリプタとして実装されています。"

#: ../../howto/descriptor.rst:326

msgid "Complete Practical Example"

msgstr "実践的なサンプル"

#: ../../howto/descriptor.rst:328

msgid ""

"In this example, we create a practical and powerful tool for locating "

"notoriously hard to find data corruption bugs."

msgstr ""

"このサンプルでは、発見が極めて難しいデータ破損バグを特定するのに利用可能な、"

"実践的でパワフルなツールを紹介します。"

#: ../../howto/descriptor.rst:333

msgid "Validator class"

msgstr "バリデータクラス"

#: ../../howto/descriptor.rst:335

msgid ""

"A validator is a descriptor for managed attribute access. Prior to storing "

"any data, it verifies that the new value meets various type and range "

"restrictions. If those restrictions aren't met, it raises an exception to "

"prevent data corruption at its source."

msgstr ""

"バリデータは管理された属性アクセスのためのデスクリプタです。データを格納する"

"前に、新しい値が型が適合しているか、値の範囲制限に適合しているかを検証しま"

"す。もし制限に合わなければ、例外を送出し、データが不正な状態になるのを防ぎま"

"す。"

#: ../../howto/descriptor.rst:340

msgid ""

"This :class:`!Validator` class is both an :term:`abstract base class` and a "

"managed attribute descriptor:"

msgstr ""

#: ../../howto/descriptor.rst:343

msgid ""

"from abc import ABC, abstractmethod\n"

"\n"

"class Validator(ABC):\n"

"\n"

" def __set_name__(self, owner, name):\n"

" self.private_name = '_' + name\n"

"\n"

" def __get__(self, obj, objtype=None):\n"

" return getattr(obj, self.private_name)\n"

"\n"

" def __set__(self, obj, value):\n"

" self.validate(value)\n"

" setattr(obj, self.private_name, value)\n"

"\n"

" @abstractmethod\n"

" def validate(self, value):\n"

" pass"

msgstr ""

#: ../../howto/descriptor.rst:363

msgid ""

"Custom validators need to inherit from :class:`!Validator` and must supply "

"a :meth:`!validate` method to test various restrictions as needed."

msgstr ""

#: ../../howto/descriptor.rst:368

msgid "Custom validators"

msgstr "カスタムバリデータ"

#: ../../howto/descriptor.rst:370

msgid "Here are three practical data validation utilities:"

msgstr ""

"ここでは3つの実践的なバリデーションのユーティリティのサンプルを紹介します。"

#: ../../howto/descriptor.rst:372

msgid ""

":class:`!OneOf` verifies that a value is one of a restricted set of options."

msgstr ""

#: ../../howto/descriptor.rst:374

msgid ""

":class:`!Number` verifies that a value is either an :class:`int` or :class:"

"`float`. Optionally, it verifies that a value is between a given minimum or "

"maximum."

msgstr ""

#: ../../howto/descriptor.rst:378

msgid ""

":class:`!String` verifies that a value is a :class:`str`. Optionally, it "

"validates a given minimum or maximum length. It can validate a user-defined "

"`predicate <https://en.wikipedia.org/wiki/Predicate_(mathematical_logic)>`_ "

"as well."

msgstr ""

#: ../../howto/descriptor.rst:383

msgid ""

"class OneOf(Validator):\n"

"\n"

" def __init__(self, *options):\n"

" self.options = set(options)\n"

"\n"

" def validate(self, value):\n"

" if value not in self.options:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be one of {self.options!r}'\n"

" )\n"

"\n"

"class Number(Validator):\n"

"\n"

" def __init__(self, minvalue=None, maxvalue=None):\n"

" self.minvalue = minvalue\n"

" self.maxvalue = maxvalue\n"

"\n"

" def validate(self, value):\n"

" if not isinstance(value, (int, float)):\n"

" raise TypeError(f'Expected {value!r} to be an int or float')\n"

" if self.minvalue is not None and value < self.minvalue:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be at least {self.minvalue!r}'\n"

" )\n"

" if self.maxvalue is not None and value > self.maxvalue:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be no more than {self.maxvalue!r}'\n"

" )\n"

"\n"

"class String(Validator):\n"

"\n"

" def __init__(self, minsize=None, maxsize=None, predicate=None):\n"

" self.minsize = minsize\n"

" self.maxsize = maxsize\n"

" self.predicate = predicate\n"

"\n"

" def validate(self, value):\n"

" if not isinstance(value, str):\n"

" raise TypeError(f'Expected {value!r} to be an str')\n"

" if self.minsize is not None and len(value) < self.minsize:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be no smaller than {self.minsize!"

"r}'\n"

" )\n"

" if self.maxsize is not None and len(value) > self.maxsize:\n"

" raise ValueError(\n"

" f'Expected {value!r} to be no bigger than {self.maxsize!r}'\n"

" )\n"

" if self.predicate is not None and not self.predicate(value):\n"

" raise ValueError(\n"

" f'Expected {self.predicate} to be true for {value!r}'\n"

" )"

msgstr ""

#: ../../howto/descriptor.rst:439

msgid "Practical application"

msgstr "実践的なアプリケーション"

#: ../../howto/descriptor.rst:441

msgid "Here's how the data validators can be used in a real class:"

msgstr "次のコードは実際のクラスでデータバリデータを使う方法のサンプルです。"

#: ../../howto/descriptor.rst:443

msgid ""

"class Component:\n"

"\n"

" name = String(minsize=3, maxsize=10, predicate=str.isupper)\n"

" kind = OneOf('wood', 'metal', 'plastic')\n"

" quantity = Number(minvalue=0)\n"

"\n"

" def __init__(self, name, kind, quantity):\n"

" self.name = name\n"

" self.kind = kind\n"

" self.quantity = quantity"

msgstr ""

#: ../../howto/descriptor.rst:456

msgid "The descriptors prevent invalid instances from being created:"

msgstr "これらのデスクリプタは、不正インスタンスが作成されるのを防ぎます。"

#: ../../howto/descriptor.rst:458

msgid ""

">>> Component('Widget', 'metal', 5) # Blocked: 'Widget' is not all "

"uppercase\n"

"Traceback (most recent call last):\n"

" ...\n"

"ValueError: Expected <method 'isupper' of 'str' objects> to be true for "

"'Widget'\n"

"\n"

">>> Component('WIDGET', 'metle', 5) # Blocked: 'metle' is misspelled\n"

"Traceback (most recent call last):\n"

" ...\n"

"ValueError: Expected 'metle' to be one of {'metal', 'plastic', 'wood'}\n"

"\n"

">>> Component('WIDGET', 'metal', -5) # Blocked: -5 is negative\n"

"Traceback (most recent call last):\n"

" ...\n"

"ValueError: Expected -5 to be at least 0\n"

"\n"

">>> Component('WIDGET', 'metal', 'V') # Blocked: 'V' isn't a number\n"

"Traceback (most recent call last):\n"

" ...\n"

"TypeError: Expected 'V' to be an int or float\n"

"\n"

">>> c = Component('WIDGET', 'metal', 5) # Allowed: The inputs are valid"

msgstr ""

#: ../../howto/descriptor.rst:484

msgid "Technical Tutorial"

msgstr "技術的なチュートリアル"

#: ../../howto/descriptor.rst:486

msgid ""

"What follows is a more technical tutorial for the mechanics and details of "

"how descriptors work."

msgstr ""

"これから先はデスクリプタのメカニズムや動作の詳細について、よりテクニカルな"

"チュートリアルになります。"

#: ../../howto/descriptor.rst:491

msgid "Abstract"

msgstr "概要"

#: ../../howto/descriptor.rst:493

msgid ""

"Defines descriptors, summarizes the protocol, and shows how descriptors are "

"called. Provides an example showing how object relational mappings work."

msgstr ""

"デスクリプタの定義、プロトコルのサマリー、デスクリプタがどのように呼び出され"

"るかの説明、ORマッパーがどのように動作するかのサンプルを提示します。"

#: ../../howto/descriptor.rst:496

msgid ""

"Learning about descriptors not only provides access to a larger toolset, it "

"creates a deeper understanding of how Python works."

msgstr ""

"デスクリプタについて学ぶことにより、新しいツールセットが使えるようになるだけ"

"でなく、Python の仕組みについてのより深い理解が得られます。"

#: ../../howto/descriptor.rst:501

msgid "Definition and introduction"

msgstr "定義と導入"

#: ../../howto/descriptor.rst:503

msgid ""

"In general, a descriptor is an attribute value that has one of the methods "

"in the descriptor protocol. Those methods are :meth:`~object.__get__`, :"

"meth:`~object.__set__`, and :meth:`~object.__delete__`. If any of those "

"methods are defined for an attribute, it is said to be a :term:`descriptor`."

msgstr ""

#: ../../howto/descriptor.rst:508

msgid ""

"The default behavior for attribute access is to get, set, or delete the "

"attribute from an object's dictionary. For instance, ``a.x`` has a lookup "

"chain starting with ``a.__dict__['x']``, then ``type(a).__dict__['x']``, and "

"continuing through the method resolution order of ``type(a)``. If the looked-"

"up value is an object defining one of the descriptor methods, then Python "

"may override the default behavior and invoke the descriptor method instead. "

"Where this occurs in the precedence chain depends on which descriptor "

"methods were defined."

msgstr ""

"属性アクセスのデフォルトの振る舞いは、オブジェクトの辞書の属性の取得、設定、"

"削除です。例えば ``a.x`` は、まず ``a.__dict__['x']``、それから ``type(a)."

"__dict__['x']``、さらに ``type(a)`` のメソッド探索順序に従ったさらなる探索へ"

"と連鎖します。見つかった値が、デスクリプタメソッドのいずれかを定義しているオ"

"ブジェクトなら、Python はそのデフォルトの振る舞いをオーバーライドし、代わりに"

"デスクリプタメソッドを呼び出します。これがどの連鎖順位で行われるかは、どのデ"

"スクリプタメソッドが定義されているかに依ります。"

#: ../../howto/descriptor.rst:517

msgid ""

"Descriptors are a powerful, general purpose protocol. They are the "

"mechanism behind properties, methods, static methods, class methods, and :"

"func:`super`. They are used throughout Python itself. Descriptors simplify "

"the underlying C code and offer a flexible set of new tools for everyday "

"Python programs."

msgstr ""

#: ../../howto/descriptor.rst:525

msgid "Descriptor protocol"

msgstr "デスクリプタプロトコル"

#: ../../howto/descriptor.rst:527

msgid "``descr.__get__(self, obj, type=None)``"

msgstr "``descr.__get__(self, obj, type=None)``"

#: ../../howto/descriptor.rst:529

msgid "``descr.__set__(self, obj, value)``"

msgstr "``descr.__set__(self, obj, value)``"

#: ../../howto/descriptor.rst:531

msgid "``descr.__delete__(self, obj)``"

msgstr "``descr.__delete__(self, obj)``"

#: ../../howto/descriptor.rst:533

msgid ""

"That is all there is to it. Define any of these methods and an object is "

"considered a descriptor and can override default behavior upon being looked "

"up as an attribute."

msgstr ""

"これで全てです。これらのメソッドのいずれかを定義すれば、オブジェクトはデスク"

"リプタとみなされ、探索された際のデフォルトの振る舞いをオーバーライドできま"

"す。"

#: ../../howto/descriptor.rst:537

msgid ""

"If an object defines :meth:`~object.__set__` or :meth:`~object.__delete__`, "

"it is considered a data descriptor. Descriptors that only define :meth:"

"`~object.__get__` are called non-data descriptors (they are often used for "

"methods but other uses are possible)."

msgstr ""

#: ../../howto/descriptor.rst:542

msgid ""

"Data and non-data descriptors differ in how overrides are calculated with "

"respect to entries in an instance's dictionary. If an instance's dictionary "

"has an entry with the same name as a data descriptor, the data descriptor "

"takes precedence. If an instance's dictionary has an entry with the same "

"name as a non-data descriptor, the dictionary entry takes precedence."

msgstr ""

"データデスクリプタと非データデスクリプタでは、オーバーライドがインスタンスの"

"辞書のエントリに関してどのように計算されるかが異なります。インスタンスの辞書"

"に、データデスクリプタと同名の項目があれば、データデスクリプタの方が優先され"

"ます。インスタンスの辞書に、非データデスクリプタと同名の項目があれば、辞書の"

"項目の方が優先されます。"

#: ../../howto/descriptor.rst:548

msgid ""

"To make a read-only data descriptor, define both :meth:`~object.__get__` "

"and :meth:`~object.__set__` with the :meth:`~object.__set__` raising an :exc:"

"`AttributeError` when called. Defining the :meth:`~object.__set__` method "

"with an exception raising placeholder is enough to make it a data descriptor."

msgstr ""

#: ../../howto/descriptor.rst:555

msgid "Overview of descriptor invocation"

msgstr "デスクリプタ呼び出しの概要"

#: ../../howto/descriptor.rst:557

msgid ""

"A descriptor can be called directly with ``desc.__get__(obj)`` or ``desc."

"__get__(None, cls)``."

msgstr ""

"``desc.__get__(obj)`` や ``desc.__get__(None, cls)`` を使うとデスクリプタを直"

"接呼び出すことができます。"

#: ../../howto/descriptor.rst:560

msgid ""

"But it is more common for a descriptor to be invoked automatically from "

"attribute access."

msgstr ""

"しかし、属性アクセスの際に自動的に呼び出されるのが、一般的なデスクリプタの呼"

"び出し方法です。"

#: ../../howto/descriptor.rst:563

msgid ""

"The expression ``obj.x`` looks up the attribute ``x`` in the chain of "

"namespaces for ``obj``. If the search finds a descriptor outside of the "

"instance :attr:`~object.__dict__`, its :meth:`~object.__get__` method is "

"invoked according to the precedence rules listed below."

msgstr ""

#: ../../howto/descriptor.rst:568

msgid ""

"The details of invocation depend on whether ``obj`` is an object, class, or "

"instance of super."

msgstr ""

"呼び出しの詳細は、``obj`` がオブジェクトかクラスか、superのインスタンスかに依"

"ります。"

#: ../../howto/descriptor.rst:573

msgid "Invocation from an instance"

msgstr "インスタンスからの呼び出し"

#: ../../howto/descriptor.rst:575

msgid ""

"Instance lookup scans through a chain of namespaces giving data descriptors "

"the highest priority, followed by instance variables, then non-data "

"descriptors, then class variables, and lastly :meth:`~object.__getattr__` if "

"it is provided."

msgstr ""

#: ../../howto/descriptor.rst:580

msgid ""

"If a descriptor is found for ``a.x``, then it is invoked with: ``desc."

"__get__(a, type(a))``."

msgstr ""

"``a.x`` に対するデスクリプタが見つかった場合、 ``desc.__get__(a, type(a))`` "

"という形式で呼び出されます。"

#: ../../howto/descriptor.rst:583

msgid ""

"The logic for a dotted lookup is in :meth:`object.__getattribute__`. Here "

"is a pure Python equivalent:"

msgstr ""

"ドットによるルックアップのロジックは\\ :meth:`object.__getattribute__` の中で"

"行われます。ピュアPythonで表した等価なロジックは次の通りです。"

#: ../../howto/descriptor.rst:586

msgid ""

"def find_name_in_mro(cls, name, default):\n"

" \"Emulate _PyType_Lookup() in Objects/typeobject.c\"\n"

" for base in cls.__mro__:\n"

" if name in vars(base):\n"

" return vars(base)[name]\n"

" return default\n"

"\n"

"def object_getattribute(obj, name):\n"

" \"Emulate PyObject_GenericGetAttr() in Objects/object.c\"\n"

" null = object()\n"

" objtype = type(obj)\n"

" cls_var = find_name_in_mro(objtype, name, null)\n"

" descr_get = getattr(type(cls_var), '__get__', null)\n"

" if descr_get is not null:\n"

" if (hasattr(type(cls_var), '__set__')\n"

" or hasattr(type(cls_var), '__delete__')):\n"

" return descr_get(cls_var, obj, objtype) # data descriptor\n"

" if hasattr(obj, '__dict__') and name in vars(obj):\n"

" return vars(obj)[name] # instance variable\n"

" if descr_get is not null:\n"

" return descr_get(cls_var, obj, objtype) # non-data "

"descriptor\n"

" if cls_var is not null:\n"

" return cls_var # class variable\n"

" raise AttributeError(name)"

msgstr ""

#: ../../howto/descriptor.rst:722

msgid ""

"Note, there is no :meth:`~object.__getattr__` hook in the :meth:`~object."

"__getattribute__` code. That is why calling :meth:`~object."

"__getattribute__` directly or with ``super().__getattribute__`` will bypass :"

"meth:`~object.__getattr__` entirely."

msgstr ""

#: ../../howto/descriptor.rst:726

msgid ""

"Instead, it is the dot operator and the :func:`getattr` function that are "

"responsible for invoking :meth:`~object.__getattr__` whenever :meth:`~object."

"__getattribute__` raises an :exc:`AttributeError`. Their logic is "

"encapsulated in a helper function:"

msgstr ""

#: ../../howto/descriptor.rst:731

msgid ""

"def getattr_hook(obj, name):\n"

" \"Emulate slot_tp_getattr_hook() in Objects/typeobject.c\"\n"

" try:\n"

" return obj.__getattribute__(name)\n"

" except AttributeError:\n"

" if not hasattr(type(obj), '__getattr__'):\n"

" raise\n"

" return type(obj).__getattr__(obj, name) # __getattr__"

msgstr ""

#: ../../howto/descriptor.rst:776

msgid "Invocation from a class"

msgstr "クラスからの呼び出し"

#: ../../howto/descriptor.rst:778

msgid ""

"The logic for a dotted lookup such as ``A.x`` is in :meth:`!type."

"__getattribute__`. The steps are similar to those for :meth:`!object."

"__getattribute__` but the instance dictionary lookup is replaced by a search "

"through the class's :term:`method resolution order`."

msgstr ""

#: ../../howto/descriptor.rst:783

msgid "If a descriptor is found, it is invoked with ``desc.__get__(None, A)``."

msgstr ""

"``a.x`` に対するデスクリプタが見つかった場合、 ``desc.__get__(None, A)`` とい"

"う形式で呼び出されます。"

#: ../../howto/descriptor.rst:785

msgid ""

"The full C implementation can be found in :c:func:`!type_getattro` and :c:"

"func:`!_PyType_Lookup` in :source:`Objects/typeobject.c`."

msgstr ""

"完全な C での実装は :source:`Objects/typeobject.c` の中の:c:func:`!"

"type_getattro` と :c:func:`!_PyType_Lookup` を参照してください。"