glossary.po

# 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:
# Takanori Suzuki <takanori@takanory.net>, 2026
# python-doc bot, 2026
# Inada Naoki <songofacandy@gmail.com>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-10-23 18:01+0000\n"
"PO-Revision-Date: 2025-09-16 00:00+0000\n"
"Last-Translator: Inada Naoki <songofacandy@gmail.com>, 2026\n"
"Language-Team: Japanese (https://app.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"

#: ../../glossary.rst:5
msgid "Glossary"
msgstr "用語集"

#: ../../glossary.rst:10
msgid "``>>>``"
msgstr "``>>>``"

#: ../../glossary.rst:12
msgid ""
"The default Python prompt of the :term:`interactive` shell.  Often seen for "
"code examples which can be executed interactively in the interpreter."
msgstr ""
":term:`対話型 <interactive>` シェルにおけるデフォルトの Python プロンプトで"
"す。インタープリターで対話的に実行されるコード例でよく見られます。"

#: ../../glossary.rst:15
msgid "``...``"
msgstr "``...``"

#: ../../glossary.rst:17
msgid "Can refer to:"
msgstr "次のものが考えられます:"

#: ../../glossary.rst:19
msgid ""
"The default Python prompt of the :term:`interactive` shell when entering the "
"code for an indented code block, when within a pair of matching left and "
"right delimiters (parentheses, square brackets, curly braces or triple "
"quotes), or after specifying a decorator."
msgstr ""
"対話型 (:term:`interactive`) シェルにおいて、インデントされたコードブロック、"
"対応する左右の区切り文字の組 (丸括弧、角括弧、波括弧、三重引用符) の内側、デ"
"コレーターの後に、コードを入力する際に表示されるデフォルトの Python プロンプ"
"トです。"

msgid ""
"The three dots form of the :ref:`Ellipsis <bltin-ellipsis-object>` object."
msgstr ""
":ref:`Ellipsis <bltin-ellipsis-object>` オブジェクトの、3 つのドットを使った"
"表記。"

#: ../../glossary.rst:27
msgid "abstract base class"
msgstr "abstract base class"

#: ../../glossary.rst:29
msgid ""
"Abstract base classes complement :term:`duck-typing` by providing a way to "
"define interfaces when other techniques like :func:`hasattr` would be clumsy "
"or subtly wrong (for example with :ref:`magic methods <special-lookup>`).  "
"ABCs introduce virtual subclasses, which are classes that don't inherit from "
"a class but are still recognized by :func:`isinstance` and :func:"
"`issubclass`; see the :mod:`abc` module documentation.  Python comes with "
"many built-in ABCs for data structures (in the :mod:`collections.abc` "
"module), numbers (in the :mod:`numbers` module), streams (in the :mod:`io` "
"module), import finders and loaders (in the :mod:`importlib.abc` module).  "
"You can create your own ABCs with the :mod:`abc` module."
msgstr ""
"(抽象基底クラス) 抽象基底クラスは :term:`duck-typing` を補完するもので、 :"
"func:`hasattr` などの別のテクニックでは不恰好であったり微妙に誤る (例えば :"
"ref:`magic methods <special-lookup>` の場合) 場合にインターフェースを定義する"
"方法を提供します。ABC は仮想 (virtual) サブクラスを導入します。これは親クラス"
"から継承しませんが、それでも :func:`isinstance` や :func:`issubclass` に認識"
"されます; :mod:`abc` モジュールのドキュメントを参照してください。Python に"
"は、多くの組み込み ABC が同梱されています。その対象は、(:mod:`collections."
"abc` モジュールで) データ構造、(:mod:`numbers` モジュールで) 数、(:mod:`io` "
"モジュールで) ストリーム、(:mod:`importlib.abc` モジュールで) インポートファ"
"インダ及びローダーです。 :mod:`abc` モジュールを利用して独自の ABC を作成でき"
"ます。"

msgid "annotate function"
msgstr "annotate function"

msgid ""
"A callable that can be called to retrieve the :term:`annotations "
"<annotation>` of an object. Annotate functions are usually :term:`functions "
"<function>`, automatically generated as the :attr:`~object.__annotate__` "
"attribute of functions, classes, and modules. Annotate functions are a "
"subset of :term:`evaluate functions <evaluate function>`."
msgstr ""
"(annotate 関数) オブジェクトの :term:`アノテーション <annotation>` を取得する"
"ために呼び出せる呼び出し可能オブジェクトです。\n"
"annotate 関数は通常、関数、クラス、モジュールの :attr:`~object.__annotate__` "
"属性として自動生成される :term:`関数 <function>` です。\n"
"annotate 関数は :term:`評価関数 <evaluate function>` の一種です。"

#: ../../glossary.rst:47
msgid "annotation"
msgstr "annotation"

#: ../../glossary.rst:49
msgid ""
"A label associated with a variable, a class attribute or a function "
"parameter or return value, used by convention as a :term:`type hint`."
msgstr ""
"(アノテーション) 変数、クラス属性、関数のパラメータや返り値に関係するラベルで"
"す。\n"
"慣例により :term:`type hint` として使われています。"

msgid ""
"Annotations of local variables cannot be accessed at runtime, but "
"annotations of global variables, class attributes, and functions can be "
"retrieved by calling :func:`annotationlib.get_annotations` on modules, "
"classes, and functions, respectively."
msgstr ""
"ローカル変数のアノテーションには実行時にアクセスできませんが、グローバル変"
"数、クラス属性、関数のアノテーションは、それぞれモジュール、クラス、関数に対"
"して :func:`annotationlib.get_annotations` を呼び出すことで取得できます。"

#: ../../glossary.rst:58
msgid ""
"See :term:`variable annotation`, :term:`function annotation`, :pep:`484`, :"
"pep:`526`, and :pep:`649`, which describe this functionality. Also see :ref:"
"`annotations-howto` for best practices on working with annotations."
msgstr ""
"機能の説明がある :term:`variable annotation`, :term:`function annotation`, :"
"pep:`484`, :pep:`526`, :pep:`649` を参照してください。また、アノテーションを"
"利用するベストプラクティスとして :ref:`annotations-howto` も参照してくださ"
"い。"

#: ../../glossary.rst:62
msgid "argument"
msgstr "引数 (argument)"

#: ../../glossary.rst:64
msgid ""
"A value passed to a :term:`function` (or :term:`method`) when calling the "
"function.  There are two kinds of argument:"
msgstr ""
"(実引数) 関数を呼び出す際に、 :term:`関数<function>` (または :term:`メソッド "
"<method>`) に渡す値です。実引数には２種類あります:"

#: ../../glossary.rst:67
msgid ""
":dfn:`keyword argument`: an argument preceded by an identifier (e.g. "
"``name=``) in a function call or passed as a value in a dictionary preceded "
"by ``**``.  For example, ``3`` and ``5`` are both keyword arguments in the "
"following calls to :func:`complex`::"
msgstr ""
":dfn:`キーワード引数`: 関数呼び出しの際に引数の前に識別子がついたもの (例: "
"``name=``) や、 ``**`` に続けた辞書の中の値として渡された引数。例えば、次の :"
"func:`complex` の呼び出しでは、 ``3`` と ``5`` がキーワード引数です::"

#: ../../glossary.rst:72
msgid ""
"complex(real=3, imag=5)\n"
"complex(**{'real': 3, 'imag': 5})"
msgstr ""
"complex(real=3, imag=5)\n"
"complex(**{'real': 3, 'imag': 5})"

#: ../../glossary.rst:75
msgid ""
":dfn:`positional argument`: an argument that is not a keyword argument. "
"Positional arguments can appear at the beginning of an argument list and/or "
"be passed as elements of an :term:`iterable` preceded by ``*``. For example, "
"``3`` and ``5`` are both positional arguments in the following calls::"
msgstr ""
":dfn:`位置引数`: キーワード引数以外の引数。位置引数は引数リストの先頭に書くこ"
"とができ、また ``*`` に続けた :term:`iterable` の要素として渡すことができま"
"す。例えば、次の例では ``3`` と ``5`` は両方共位置引数です::"

#: ../../glossary.rst:81
msgid ""
"complex(3, 5)\n"
"complex(*(3, 5))"
msgstr ""
"complex(3, 5)\n"
"complex(*(3, 5))"

#: ../../glossary.rst:84
msgid ""
"Arguments are assigned to the named local variables in a function body. See "
"the :ref:`calls` section for the rules governing this assignment. "
"Syntactically, any expression can be used to represent an argument; the "
"evaluated value is assigned to the local variable."
msgstr ""
"実引数は関数の実体において名前付きのローカル変数に割り当てられます。割り当て"
"を行う規則については :ref:`calls` を参照してください。シンタックスにおいて実"
"引数を表すためにあらゆる式を使うことが出来ます。評価された値はローカル変数に"
"割り当てられます。"

#: ../../glossary.rst:89
msgid ""
"See also the :term:`parameter` glossary entry, the FAQ question on :ref:`the "
"difference between arguments and parameters <faq-argument-vs-parameter>`, "
"and :pep:`362`."
msgstr ""
":term:`仮引数<parameter>` 、FAQ の :ref:`実引数と仮引数の違いは何ですか? "
"<faq-argument-vs-parameter>` 、:pep:`362` を参照してください。"

#: ../../glossary.rst:92
msgid "asynchronous context manager"
msgstr "asynchronous context manager"

#: ../../glossary.rst:94
msgid ""
"An object which controls the environment seen in an :keyword:`async with` "
"statement by defining :meth:`~object.__aenter__` and :meth:`~object."
"__aexit__` methods.  Introduced by :pep:`492`."
msgstr ""
"(非同期コンテキストマネージャ)\n"
":meth:`~object.__aenter__` と :meth:`~object.__aexit__` メソッドを定義するこ"
"とで :keyword:`async with` 文内の環境を管理するオブジェクトです。  :pep:"
"`492` で導入されました。"

#: ../../glossary.rst:97
msgid "asynchronous generator"
msgstr "asynchronous generator"

msgid ""
"Informally used to mean either an :term:`asynchronous generator function` or "
"an :term:`asynchronous generator iterator`, depending on context.  The "
"formal terms :term:`asynchronous generator function` and :term:`asynchronous "
"generator iterator` are uncommon in practice; \"asynchronous generator\" "
"alone is almost always sufficient."
msgstr ""
"文脈に応じて、:term:`非同期ジェネレータ関数 <asynchronous generator "
"function>` または :term:`非同期ジェネレータイテレータ <asynchronous "
"generator iterator>` のどちらかを指すために非公式に使われる語です。\n"
"正式な用語である :term:`非同期ジェネレータ関数 <asynchronous generator "
"function>` と :term:`非同期ジェネレータイテレータ <asynchronous generator "
"iterator>` は、実際にはあまり使われません。\n"
"ほとんどの場合、「非同期ジェネレータ」だけで十分です。"

msgid "asynchronous generator function"
msgstr "asynchronous generator function"

msgid ""
"A function which returns an :term:`asynchronous generator iterator`. It "
"looks like a coroutine function defined with :keyword:`async def` except "
"that it contains :keyword:`yield` expressions for producing a series of "
"values usable in an :keyword:`async for` loop.  See :pep:`525`."
msgstr ""
"(非同期ジェネレータ関数) :term:`非同期ジェネレータイテレータ <asynchronous "
"generator iterator>` を返す関数です。\n"
":keyword:`async def` で定義されたコルーチン関数に似ていますが、:keyword:"
"`async for` ループで使用できる一連の値を生成するための :keyword:`yield` 式を"
"含む点が異なります。\n"
":pep:`525` を参照してください。"

#: ../../glossary.rst:111
msgid ""
"An asynchronous generator function may contain :keyword:`await` expressions "
"as well as :keyword:`async for`, and :keyword:`async with` statements."
msgstr ""
"非同期ジェネレータ関数には、 :keyword:`async for` 文や :keyword:`async with` "
"文だけでなく :keyword:`await` 式もあることがあります。"

#: ../../glossary.rst:114
msgid "asynchronous generator iterator"
msgstr "asynchronous generator iterator"

msgid "An object created by an :term:`asynchronous generator function`."
msgstr ""
":term:`非同期ジェネレータ関数 <asynchronous generator function>` が作成するオ"
"ブジェクトです。"

#: ../../glossary.rst:118
msgid ""
"This is an :term:`asynchronous iterator` which when called using the :meth:"
"`~object.__anext__` method returns an awaitable object which will execute "
"the body of the asynchronous generator function until the next :keyword:"
"`yield` expression."
msgstr ""
"これは :term:`asynchronous iterator` で、 :meth:`~object.__anext__` メソッド"
"を使って呼ばれると awaitable オブジェクトを返します。  この awaitable オブ"
"ジェクトは、次の :keyword:`yield` 式まで非同期ジェネレータ関数の本体を実行し"
"ます。"

msgid ""
"Each :keyword:`yield` temporarily suspends processing, remembering the "
"execution state (including local variables and pending try-statements).  "
"When the *asynchronous generator iterator* effectively resumes with another "
"awaitable returned by :meth:`~object.__anext__`, it picks up where it left "
"off.  See :pep:`492` and :pep:`525`."
msgstr ""
"各 :keyword:`yield` は処理を一時的に中断し、実行状態（ローカル変数や保留中の "
"try 文を含む）を記憶します。\n"
":meth:`~object.__anext__` が返す別の awaitable によって *非同期ジェネレータイ"
"テレータ* の実行が実際に再開すると、中断した箇所から処理を続けます。\n"
":pep:`492` と :pep:`525` を参照してください。"

#: ../../glossary.rst:128
msgid "asynchronous iterable"
msgstr "asynchronous iterable"

#: ../../glossary.rst:130
msgid ""
"An object, that can be used in an :keyword:`async for` statement. Must "
"return an :term:`asynchronous iterator` from its :meth:`~object.__aiter__` "
"method.  Introduced by :pep:`492`."
msgstr ""
"(非同期イテラブル)\n"
":keyword:`async for` 文の中で使用できるオブジェクトです。  自身の :meth:"
"`~object.__aiter__` メソッドから :term:`asynchronous iterator` を返さなければ"
"なりません。  :pep:`492` で導入されました。"

#: ../../glossary.rst:133
msgid "asynchronous iterator"
msgstr "asynchronous iterator"

#: ../../glossary.rst:135
msgid ""
"An object that implements the :meth:`~object.__aiter__` and :meth:`~object."
"__anext__` methods.  :meth:`~object.__anext__` must return an :term:"
"`awaitable` object. :keyword:`async for` resolves the awaitables returned by "
"an asynchronous iterator's :meth:`~object.__anext__` method until it raises "
"a :exc:`StopAsyncIteration` exception.  Introduced by :pep:`492`."
msgstr ""
"(非同期イテレータ)\n"
":meth:`~object.__aiter__` と :meth:`~object.__anext__` メソッドを実装したオブ"
"ジェクトです。  :meth:`~object.__anext__` は :term:`awaitable` オブジェクトを"
"返さなければなりません。  :keyword:`async for` は :exc:`StopAsyncIteration` "
"例外を送出するまで、非同期イテレータの :meth:`~object.__anext__` メソッドが返"
"す awaitable を解決します。  :pep:`492` で導入されました。"

msgid "atomic operation"
msgstr "atomic operation"

msgid ""
"An operation that appears to execute as a single, indivisible step: no other "
"thread can observe it half-done, and its effects become visible all at "
"once.  Python does not guarantee that high-level statements are atomic (for "
"example, ``x += 1`` performs multiple bytecode operations and is not "
"atomic).  Atomicity is only guaranteed where explicitly documented.  See "
"also :term:`race condition` and :term:`data race`."
msgstr ""
"(アトミック操作) 分割できない単一のステップとして実行されるように見える操作で"
"す。\n"
"ほかのスレッドから途中の状態は観測できず、その効果は一度に見えるようになりま"
"す。\n"
"Python は、高水準の文がアトミックであることを保証しません（たとえば、``x += "
"1`` は複数のバイトコード操作を実行し、アトミックではありません）。\n"
"アトミック性が保証されるのは、ドキュメントに明記されている場合だけです。\n"
":term:`競合状態 <race condition>` と :term:`データ競合 <data race>` も参照し"
"てください。"

msgid "attached thread state"
msgstr "attached thread state"

msgid "A :term:`thread state` that is active for the current OS thread."
msgstr ""
"(アタッチされたスレッド状態) 現在の OS スレッドで有効な :term:`スレッド状態 "
"<thread state>` です。"

msgid ""
"When a :term:`thread state` is attached, the OS thread has access to the "
"full Python C API and can safely invoke the bytecode interpreter."
msgstr ""
":term:`スレッド状態 <thread state>` がアタッチされていると、OS スレッドは "
"Python C API の全機能にアクセスでき、バイトコードインタープリタを安全に呼び出"
"せます。"

msgid ""
"Unless a function explicitly notes otherwise, attempting to call the C API "
"without an attached thread state will result in a fatal error or undefined "
"behavior.  A thread state can be attached and detached explicitly by the "
"user through the C API, or implicitly by the runtime, including during "
"blocking C calls and by the bytecode interpreter in between calls."
msgstr ""
"関数の説明に明示的な例外の記載がない限り、スレッド状態がアタッチされていない"
"状態で C API を呼び出そうとすると、致命的エラーまたは未定義の動作を引き起こし"
"ます。\n"
"スレッド状態は、利用者が C API を通じて明示的にアタッチしたりデタッチしたりで"
"きるほか、ランタイムが暗黙に行うこともあります。\n"
"後者には、ブロックする C 関数の呼び出し中に行う場合や、バイトコードインタープ"
"リタが呼び出しと呼び出しの間に行う場合が含まれます。"

msgid ""
"On most builds of Python, having an attached thread state implies that the "
"caller holds the :term:`GIL` for the current interpreter, so only one OS "
"thread can have an attached thread state at a given moment. In :term:`free-"
"threaded builds <free-threaded build>` of Python, threads can concurrently "
"hold an attached thread state, allowing for true parallelism of the bytecode "
"interpreter."
msgstr ""
"ほとんどの Python ビルドでは、スレッド状態がアタッチされていることは、呼び出"
"し元が現在のインタープリタの :term:`GIL <GIL>` を保持していることを意味しま"
"す。\n"
"そのため、ある時点でスレッド状態をアタッチできる OS スレッドは一つだけで"
"す。\n"
"Python の :term:`フリースレッドビルド <free-threaded build>` では、複数のス"
"レッドがスレッド状態を同時にアタッチでき、バイトコードインタープリタの真の並"
"列実行が可能になります。"

#: ../../glossary.rst:170
msgid "attribute"
msgstr "属性"

#: ../../glossary.rst:172
msgid ""
"A value associated with an object which is usually referenced by name using "
"dotted expressions. For example, if an object *o* has an attribute *a* it "
"would be referenced as *o.a*."
msgstr ""
"(属性) オブジェクトに関連付けられ、ドット表記式によって名前で通常参照される値"
"です。例えば、オブジェクト *o* が属性 *a* を持っているとき、その属性は *o.a* "
"で参照されます。"

#: ../../glossary.rst:177
msgid ""
"It is possible to give an object an attribute whose name is not an "
"identifier as defined by :ref:`identifiers`, for example using :func:"
"`setattr`, if the object allows it. Such an attribute will not be accessible "
"using a dotted expression, and would instead need to be retrieved with :func:"
"`getattr`."
msgstr ""
"オブジェクトには、 :ref:`identifiers` で定義される識別子ではない名前の属性を"
"与えることができます。たとえば :func:`setattr` を使い、オブジェクトがそれを許"
"可している場合に行えます。このような属性はドット表記式ではアクセスできず、代"
"わりに :func:`getattr` を使って取る必要があります。"

#: ../../glossary.rst:182
msgid "awaitable"
msgstr "awaitable"

#: ../../glossary.rst:184
msgid ""
"An object that can be used in an :keyword:`await` expression.  Can be a :"
"term:`coroutine` or an object with an :meth:`~object.__await__` method. See "
"also :pep:`492`."
msgstr ""
"(待機可能)\n"
":keyword:`await` 式で使用することが出来るオブジェクトです。  :term:"
"`coroutine` か、 :meth:`~object.__await__` メソッドがあるオブジェクトです。 :"
"pep:`492` を参照してください。"

#: ../../glossary.rst:187
msgid "BDFL"
msgstr "BDFL"

#: ../../glossary.rst:189
msgid ""
"Benevolent Dictator For Life, a.k.a. `Guido van Rossum <https://gvanrossum."
"github.io/>`_, Python's creator."
msgstr ""
"慈悲深き終身独裁者 (Benevolent Dictator For Life) の略です。Python の作者、"
"`Guido van Rossum <https://gvanrossum.github.io/>`_ のことです。"

#: ../../glossary.rst:191
msgid "binary file"
msgstr "binary file"

#: ../../glossary.rst:193
msgid ""
"A :term:`file object` able to read and write :term:`bytes-like objects "
"<bytes-like object>`. Examples of binary files are files opened in binary "
"mode (``'rb'``, ``'wb'`` or ``'rb+'``), :data:`sys.stdin.buffer <sys."
"stdin>`, :data:`sys.stdout.buffer <sys.stdout>`, and instances of :class:`io."
"BytesIO` and :class:`gzip.GzipFile`."
msgstr ""
"(バイナリファイル)\n"
":term:`bytes-like オブジェクト <bytes-like object>` の読み込みおよび書き込み"
"ができる :term:`ファイルオブジェクト <file object>` です。\n"
"バイナリファイルの例は、バイナリモード (``'rb'``, ``'wb'`` or ``'rb+'``) で開"
"かれたファイル、:data:`sys.stdin.buffer <sys.stdin>`、:data:`sys.stdout."
"buffer <sys.stdout>`、 :class:`io.BytesIO` や :class:`gzip.GzipFile`. のイン"
"スタンスです。"

#: ../../glossary.rst:200
msgid ""
"See also :term:`text file` for a file object able to read and write :class:"
"`str` objects."
msgstr ""
":class:`str` オブジェクトの読み書きができるファイルオブジェクトについては、 :"
"term:`text file` も参照してください。"

msgid "borrowed reference"
msgstr "borrowed reference"

msgid ""
"In Python's C API, a borrowed reference is a reference to an object, where "
"the code using the object does not own the reference. It becomes a dangling "
"pointer if the object is destroyed. For example, a garbage collection can "
"remove the last :term:`strong reference` to the object and so destroy it."
msgstr ""
"(借用参照) Python の C API で、オブジェクトを使うコードが所有していない、その"
"オブジェクトへの参照です。\n"
"オブジェクトが破棄されると、ダングリングポインタになります。\n"
"たとえば、ガベージコレクションによってオブジェクトへの最後の :term:`強参照 "
"<strong reference>` が取り除かれ、オブジェクトが破棄されることがあります。"

msgid ""
"Calling :c:func:`Py_INCREF` on the :term:`borrowed reference` is recommended "
"to convert it to a :term:`strong reference` in-place, except when the object "
"cannot be destroyed before the last usage of the borrowed reference. The :c:"
"func:`Py_NewRef` function can be used to create a new :term:`strong "
"reference`."
msgstr ""
":term:`借用参照 <borrowed reference>` に対して :c:func:`Py_INCREF` を呼び出"
"し、その場で :term:`強参照 <strong reference>` に変換することを推奨します。\n"
"ただし、借用参照の最後の使用までオブジェクトが破棄され得ない場合は除きま"
"す。\n"
":c:func:`Py_NewRef` 関数を使うと、新しい :term:`強参照 <strong reference>` を"
"作成できます。"

#: ../../glossary.rst:215
msgid "bytes-like object"
msgstr "bytes-like object"

#: ../../glossary.rst:217
msgid ""
"An object that supports the :ref:`bufferobjects` and can export a C-:term:"
"`contiguous` buffer. This includes all :class:`bytes`, :class:`bytearray`, "
"and :class:`array.array` objects, as well as many common :class:`memoryview` "
"objects.  Bytes-like objects can be used for various operations that work "
"with binary data; these include compression, saving to a binary file, and "
"sending over a socket."
msgstr ""
":ref:`bufferobjects` をサポートしていて、 C 言語の意味で :term:`連続した "
"<contiguous>` バッファーを提供可能なオブジェクト。\n"
":class:`bytes`, :class:`bytearray`, :class:`array.array` や、多くの一般的な :"
"class:`memoryview` オブジェクトがこれに当たります。\n"
"bytes-like オブジェクトは、データ圧縮、バイナリファイルへの保存、ソケットを経"
"由した送信など、バイナリデータを要求するいろいろな操作に利用することができま"
"す。"

msgid ""
"Some operations need the binary data to be mutable.  The documentation often "
"refers to these as \"read-write bytes-like objects\".  Example mutable "
"buffer objects include :class:`bytearray` and a :class:`memoryview` of a :"
"class:`bytearray`. Other operations require the binary data to be stored in "
"immutable objects (\"read-only bytes-like objects\"); examples of these "
"include :class:`bytes` and a :class:`memoryview` of a :class:`bytes` object."
msgstr ""
"操作によっては、バイナリデータが変更可能である必要があります。\n"
"ドキュメントでは、そのようなデータを「読み書き可能な bytes-like オブジェク"
"ト」と呼ぶことがよくあります。\n"
"変更可能なバッファオブジェクトには、:class:`bytearray` や :class:`bytearray` "
"の :class:`memoryview` があります。\n"
"一方、別の操作では、バイナリデータが不変なオブジェクト（「読み出し専用の "
"bytes-like オブジェクト」）に格納されている必要があります。\n"
"そのようなオブジェクトには、:class:`bytes` や :class:`bytes` オブジェクトの :"
"class:`memoryview` があります。"

#: ../../glossary.rst:232
msgid "bytecode"
msgstr "bytecode"

#: ../../glossary.rst:234
msgid ""
"Python source code is compiled into bytecode, the internal representation of "
"a Python program in the CPython interpreter.  The bytecode is also cached in "
"``.pyc`` files so that executing the same file is faster the second time "
"(recompilation from source to bytecode can be avoided).  This \"intermediate "
"language\" is said to run on a :term:`virtual machine` that executes the "
"machine code corresponding to each bytecode. Do note that bytecodes are not "
"expected to work between different Python virtual machines, nor to be stable "
"between Python releases."
msgstr ""
"(バイトコード) Python のソースコードは、 Python プログラムの CPython インタプ"
"リタの内部表現であるバイトコードへとコンパイルされます。\n"
"バイトコードは ``.pyc`` ファイルにキャッシュされ、同じファイルが二度目に実行"
"されるときはより高速になります (ソースコードからバイトコードへの再度のコンパ"
"イルは回避されます)。\n"
"この \"中間言語 (intermediate language)\" は、各々のバイトコードに対応する機"
"械語を実行する :term:`仮想マシン <virtual machine>` で動作するといえます。\n"
"重要な注意として、バイトコードは異なる Python 仮想マシン間で動作することや、"
"Python リリース間で安定であることは期待されていません。"

#: ../../glossary.rst:244
msgid ""
"A list of bytecode instructions can be found in the documentation for :ref:"
"`the dis module <bytecodes>`."
msgstr ""
"バイトコードの命令一覧は :ref:`dis モジュール <bytecodes>` にあります。"

#: ../../glossary.rst:246
msgid "callable"
msgstr "callable"

msgid ""
"A callable is an object that can be called, possibly with a set of arguments "
"(see :term:`argument`), with the following syntax::"
msgstr ""
"呼び出し可能オブジェクトは、次の構文で呼び出すことができるオブジェクトで"
"す。\n"
"その際、実引数（:term:`実引数 <argument>` を参照）を渡すこともできます。 ::"

#: ../../glossary.rst:251
msgid "callable(argument1, argument2, argumentN)"
msgstr "callable(argument1, argument2, argumentN)"

msgid ""
"A :term:`function`, and by extension a :term:`method`, is a callable. An "
"instance of a class that implements the :meth:`~object.__call__` method is "
"also a callable."
msgstr ""
":term:`関数 <function>` も :term:`メソッド <method>` も、呼び出し可能オブジェ"
"クトです。\n"
":meth:`~object.__call__` メソッドを実装したクラスのインスタンスも、呼び出し可"
"能オブジェクトです。"

#: ../../glossary.rst:256
msgid "callback"
msgstr "callback"

#: ../../glossary.rst:258
msgid ""
"A subroutine function which is passed as an argument to be executed at some "
"point in the future."
msgstr "(コールバック) 将来のある時点で実行されるために引数として渡される関数"

#: ../../glossary.rst:260
msgid "class"
msgstr "クラス"

#: ../../glossary.rst:262
msgid ""
"A template for creating user-defined objects. Class definitions normally "
"contain method definitions which operate on instances of the class."
msgstr ""
"(クラス) ユーザー定義オブジェクトを作成するためのテンプレートです。クラス定義"
"は普通、そのクラスのインスタンス上の操作をするメソッドの定義を含みます。"

#: ../../glossary.rst:265
msgid "class variable"
msgstr "class variable"

msgid ""
"A variable defined in a class and intended to be modified only at class "
"level (i.e., not in an instance of the class)."
msgstr ""
"(クラス変数) クラス内で定義され、クラスレベルでのみ（つまり、クラスのインスタ"
"ンスではなく）変更することを意図した変数です。"

msgid "closure variable"
msgstr "closure variable"

msgid ""
"A :term:`free variable` referenced from a :term:`nested scope` that is "
"defined in an outer scope rather than being resolved at runtime from the "
"globals or builtin namespaces. May be explicitly defined with the :keyword:"
"`nonlocal` keyword to allow write access, or implicitly defined if the "
"variable is only being read."
msgstr ""
"(クロージャ変数) :term:`ネストされたスコープ <nested scope>` から参照される :"
"term:`自由変数 <free variable>` のうち、実行時にグローバル名前空間や組み込み"
"名前空間から解決されるのではなく、外側のスコープで定義されているものです。\n"
"書き込みを可能にするために :keyword:`nonlocal` キーワードで明示的に定義する場"
"合と、変数を読み取るだけで暗黙に定義される場合があります。"

msgid ""
"For example, in the ``inner`` function in the following code, both ``x`` and "
"``print`` are :term:`free variables <free variable>`, but only ``x`` is a "
"*closure variable*::"
msgstr ""
"たとえば、次のコードの ``inner`` 関数では、``x`` と ``print`` はどちらも :"
"term:`自由変数 <free variable>` ですが、*クロージャ変数* は ``x`` だけで"
"す。 ::"

#: ../../glossary.rst:279
msgid ""
"def outer():\n"
"    x = 0\n"
"    def inner():\n"
"        nonlocal x\n"
"        x += 1\n"
"        print(x)\n"
"    return inner"
msgstr ""
"def outer():\n"
"    x = 0\n"
"    def inner():\n"
"        nonlocal x\n"
"        x += 1\n"
"        print(x)\n"
"    return inner"

msgid ""
"Due to the :attr:`codeobject.co_freevars` attribute (which, despite its "
"name, only includes the names of closure variables rather than listing all "
"referenced free variables), the more general :term:`free variable` term is "
"sometimes used even when the intended meaning is to refer specifically to "
"closure variables."
msgstr ""
":attr:`codeobject.co_freevars` 属性には、その名前に反して、参照されるすべての"
"自由変数ではなくクロージャ変数の名前だけが含まれます。\n"
"このため、クロージャ変数だけを指す意図で、より一般的な用語である :term:`自由"
"変数 <free variable>` が使われることもあります。"

#: ../../glossary.rst:291
msgid "complex number"
msgstr "complex number"

#: ../../glossary.rst:293
msgid ""
"An extension of the familiar real number system in which all numbers are "
"expressed as a sum of a real part and an imaginary part.  Imaginary numbers "
"are real multiples of the imaginary unit (the square root of ``-1``), often "
"written ``i`` in mathematics or ``j`` in engineering.  Python has built-in "
"support for complex numbers, which are written with this latter notation; "
"the imaginary part is written with a ``j`` suffix, e.g., ``3+1j``.  To get "
"access to complex equivalents of the :mod:`math` module, use :mod:`cmath`.  "
"Use of complex numbers is a fairly advanced mathematical feature.  If you're "
"not aware of a need for them, it's almost certain you can safely ignore them."
msgstr ""
"(複素数) よく知られている実数系を拡張したもので、すべての数は実部と虚部の和と"
"して表されます。虚数は虚数単位 (``-1`` の平方根) に実数を掛けたもので、一般に"
"数学では ``i`` と書かれ、工学では ``j`` と書かれます。Python は複素数に組み込"
"みで対応し、後者の表記を取っています。虚部は末尾に ``j`` をつけて書きます。例"
"えば ``3+1j`` です。 :mod:`math` モジュールの複素数版を利用するには、 :mod:"
"`cmath` を使います。複素数の使用はかなり高度な数学の機能です。必要性を感じな"
"ければ、ほぼ間違いなく無視してしまってよいでしょう。"

msgid "concurrency"
msgstr "concurrency"

msgid ""
"The ability of a computer program to perform multiple tasks at the same "
"time.  Python provides libraries for writing programs that make use of "
"different forms of concurrency.  :mod:`asyncio` is a library for dealing "
"with asynchronous tasks and coroutines.  :mod:`threading` provides access to "
"operating system threads and :mod:`multiprocessing` to operating system "
"processes. Multi-core processors can execute threads and processes on "
"different CPU cores at the same time (see :term:`parallelism`)."
msgstr ""
"(並行性) コンピュータプログラムが複数のタスクを同時に実行する能力です。\n"
"Python は、さまざまな形の並行性を利用するプログラムを書くためのライブラリを提"
"供します。\n"
":mod:`asyncio` は非同期タスクやコルーチンを扱うためのライブラリです。\n"
":mod:`threading` はオペレーティングシステムのスレッドへのアクセスを、:mod:"
"`multiprocessing` はオペレーティングシステムのプロセスへのアクセスを提供しま"
"す。\n"
"マルチコアプロセッサは、異なる CPU コアでスレッドやプロセスを同時に実行できま"
"す（:term:`並列性 <parallelism>` を参照）。"

msgid "concurrent modification"
msgstr "concurrent modification"

msgid ""
"When multiple threads modify shared data at the same time.  Concurrent "
"modification without proper synchronization can cause :term:`race conditions "
"<race condition>`, and might also trigger a :term:`data race <data race>`, "
"data corruption, or both."
msgstr ""
"(並行変更) 複数のスレッドが共有データを同時に変更することです。\n"
"適切な同期を行わずに並行変更すると、:term:`競合状態 <race condition>` を引き"
"起こすことがあり、さらに :term:`データ競合 <data race>`、データの破損、または"
"その両方を引き起こす可能性もあります。"

msgid "context"
msgstr "context"

msgid ""
"This term has different meanings depending on where and how it is used. Some "
"common meanings:"
msgstr ""
"(コンテキスト) この語は、使われる場所や使い方によって意味が異なります。\n"
"よく使われる意味には次のものがあります:"

msgid ""
"The temporary state or environment established by a :term:`context manager` "
"via a :keyword:`with` statement."
msgstr ""
":term:`コンテキストマネージャ <context manager>` が :keyword:`with` 文を通じ"
"て設定する、一時的な状態または環境。"

msgid ""
"The collection of key­value bindings associated with a particular :class:"
"`contextvars.Context` object and accessed via :class:`~contextvars."
"ContextVar` objects.  Also see :term:`context variable`."
msgstr ""
"特定の :class:`contextvars.Context` オブジェクトに関連付けられ、:class:"
"`~contextvars.ContextVar` オブジェクトを通じてアクセスされる、キーと値の束縛"
"の集まり。\n"
":term:`コンテキスト変数 <context variable>` も参照してください。"

msgid ""
"A :class:`contextvars.Context` object.  Also see :term:`current context`."
msgstr ""
":class:`contextvars.Context` オブジェクト。\n"
":term:`現在のコンテキスト <current context>` も参照してください。"

#: ../../glossary.rst:332
msgid "context management protocol"
msgstr "コンテキスト管理プロトコル"

msgid ""
"The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by "
"the :keyword:`with` statement.  See :pep:`343`."
msgstr ""
":keyword:`with` 文から呼び出される :meth:`~object.__enter__` メソッドと :"
"meth:`~object.__exit__` メソッドです。\n"
":pep:`343` を参照してください。"

#: ../../glossary.rst:336
msgid "context manager"
msgstr "context manager"

msgid ""
"An object which implements the :term:`context management protocol` and "
"controls the environment seen in a :keyword:`with` statement.  See :pep:"
"`343`."
msgstr ""
":term:`コンテキスト管理プロトコル <context management protocol>` を実装し、:"
"keyword:`with` 文内の環境を管理するオブジェクトです。\n"
":pep:`343` を参照してください。"

#: ../../glossary.rst:341
msgid "context variable"
msgstr "context variable"

msgid ""
"A variable whose value depends on which context is the :term:`current "
"context`.  Values are accessed via :class:`contextvars.ContextVar` objects.  "
"Context variables are primarily used to isolate state between concurrent "
"asynchronous tasks."
msgstr ""
"どのコンテキストが :term:`現在のコンテキスト <current context>` であるかに"
"よって値が変わる変数です。\n"
"値には :class:`contextvars.ContextVar` オブジェクトを通じてアクセスします。\n"
"コンテキスト変数は主に、並行する非同期タスク間で状態を分離するために使われま"
"す。"

#: ../../glossary.rst:347
msgid "contiguous"
msgstr "contiguous"

msgid ""
"A buffer is considered contiguous exactly if it is either *C-contiguous* or "
"*Fortran contiguous*.  Zero-dimensional buffers are C and Fortran "
"contiguous.  In one-dimensional arrays, the items must be laid out in memory "
"next to each other, in order of increasing indexes starting from zero.  In "
"multidimensional C-contiguous arrays, the last index varies the fastest when "
"visiting items in order of memory address.  However, in Fortran contiguous "
"arrays, the first index varies the fastest."
msgstr ""
"(隣接、連続) バッファが *C-連続* または *Fortran 連続* のいずれかである場合、"
"かつその場合に限り、そのバッファは連続しているとみなされます。\n"
"ゼロ次元バッファは C 連続であり、Fortran 連続でもあります。\n"
"一次元配列では、要素はメモリ上で互いに隣接し、ゼロから始まる添字の昇順で並ん"
"でいなければなりません。\n"
"多次元の C-連続配列では、メモリアドレス順に要素をたどると、最後の添字が最も速"
"く変化します。\n"
"一方、Fortran 連続配列では、最初の添字が最も速く変化します。"

#: ../../glossary.rst:359
msgid "coroutine"
msgstr "コルーチン"

#: ../../glossary.rst:361
msgid ""
"Coroutines are a more generalized form of subroutines. Subroutines are "
"entered at one point and exited at another point.  Coroutines can be "
"entered, exited, and resumed at many different points.  They can be "
"implemented with the :keyword:`async def` statement.  See also :pep:`492`."
msgstr ""
"(コルーチン) コルーチンはサブルーチンのより一般的な形式です。\n"
"サブルーチンには決められた地点から入り、別の決められた地点から出ます。\n"
"コルーチンには多くの様々な地点から入る、出る、再開することができます。\n"
"コルーチンは :keyword:`async def` 文で実装できます。\n"
":pep:`492` を参照してください。"

#: ../../glossary.rst:366
msgid "coroutine function"
msgstr "coroutine function"

#: ../../glossary.rst:368
msgid ""
"A function which returns a :term:`coroutine` object.  A coroutine function "
"may be defined with the :keyword:`async def` statement, and may contain :"
"keyword:`await`, :keyword:`async for`, and :keyword:`async with` keywords.  "
"These were introduced by :pep:`492`."
msgstr ""
"(コルーチン関数)\n"
":term:`coroutine` オブジェクトを返す関数です。\n"
"コルーチン関数は :keyword:`async def` 文で実装され、:keyword:`await`、:"
"keyword:`async for`、 および :keyword:`async with` キーワードを持つことが出来"
"ます。\n"
"これらは :pep:`492` で導入されました。"

#: ../../glossary.rst:373
msgid "CPython"
msgstr "CPython"

#: ../../glossary.rst:375
msgid ""
"The canonical implementation of the Python programming language, as "
"distributed on `python.org <https://www.python.org>`_.  The term \"CPython\" "
"is used when necessary to distinguish this implementation from others such "
"as Jython or IronPython."
msgstr ""
"`python.org <https://www.python.org>`_ で配布されている、Python プログラミン"
"グ言語の標準的な実装です。\"CPython\" という単語は、この実装を Jython や "
"IronPython といった他の実装と区別する必要が有る場合に利用されます。"

msgid "current context"
msgstr "current context"

msgid ""
"The :term:`context` (:class:`contextvars.Context` object) that is currently "
"used by :class:`~contextvars.ContextVar` objects to access (get or set) the "
"values of :term:`context variables <context variable>`.  Each thread has its "
"own current context.  Frameworks for executing asynchronous tasks (see :mod:"
"`asyncio`) associate each task with a context which becomes the current "
"context whenever the task starts or resumes execution."
msgstr ""
"(現在のコンテキスト) :class:`~contextvars.ContextVar` オブジェクトが :term:`"
"コンテキスト変数 <context variable>` の値にアクセス（取得や設定）するために現"
"在使っている :term:`コンテキスト <context>`（:class:`contextvars.Context` オ"
"ブジェクト）です。\n"
"各スレッドには、それぞれ現在のコンテキストがあります。\n"
"非同期タスクを実行するフレームワーク（:mod:`asyncio` を参照）は、各タスクにコ"
"ンテキストを関連付けます。\n"
"このコンテキストは、タスクが実行を開始または再開するたびに、現在のコンテキス"
"トになります。"

msgid "cyclic isolate"
msgstr "cyclic isolate"

msgid ""
"A subgroup of one or more objects that reference each other in a reference "
"cycle, but are not referenced by objects outside the group.  The goal of "
"the :term:`cyclic garbage collector <garbage collection>` is to identify "
"these groups and break the reference cycles so that the memory can be "
"reclaimed."
msgstr ""
"(孤立した循環参照群) 循環参照によって互いを参照している一つ以上のオブジェクト"
"からなる集まりで、外部のオブジェクトから参照されていないものです。\n"
":term:`循環ガベージコレクタ <garbage collection>` の目的は、こうした集まりを"
"特定し、循環参照を断ち切ってメモリを回収できるようにすることです。"

msgid "data race"
msgstr "data race"

msgid ""
"A situation where multiple threads access the same memory location "
"concurrently, at least one of the accesses is a write, and the threads do "
"not use any synchronization to control their access.  Data races lead to :"
"term:`non-deterministic` behavior and can cause data corruption. Proper use "
"of :term:`locks <lock>` and other :term:`synchronization primitives "
"<synchronization primitive>` prevents data races.  Note that data races can "
"only happen in native code, but that :term:`native code` might be exposed in "
"a Python API.  See also :term:`race condition` and :term:`thread-safe`."
msgstr ""
"(データ競合) 複数のスレッドが同じメモリ位置に並行してアクセスし、そのうち少な"
"くとも一つが書き込みであり、どのスレッドもアクセスを制御する同期を使っていな"
"い状況です。\n"
"データ競合は :term:`非決定的な <non-deterministic>` 動作につながり、データの"
"破損を引き起こすことがあります。\n"
":term:`ロック <lock>` やその他の :term:`同期プリミティブ <synchronization "
"primitive>` を適切に使うと、データ競合を防げます。\n"
"データ競合が起こり得るのはネイティブコード内だけですが、その :term:`ネイティ"
"ブコード <native code>` が Python API を通じて公開されている可能性があること"
"に注意してください。\n"
":term:`競合状態 <race condition>` と :term:`スレッドセーフ <thread-safe>` も"
"参照してください。"

msgid "deadlock"
msgstr "deadlock"

msgid ""
"A situation in which two or more tasks (threads, processes, or coroutines) "
"wait indefinitely for each other to release resources or complete actions, "
"preventing any from making progress.  For example, if thread A holds lock 1 "
"and waits for lock 2, while thread B holds lock 2 and waits for lock 1, both "
"threads will wait indefinitely.  In Python this often arises from acquiring "
"multiple locks in conflicting orders or from circular join/await "
"dependencies.  Deadlocks can be avoided by always acquiring multiple :term:"
"`locks <lock>` in a consistent order.  See also :term:`lock` and :term:"
"`reentrant`."
msgstr ""
"(デッドロック) 二つ以上のタスク（スレッド、プロセス、コルーチン）が、互いにリ"
"ソースを解放したり動作を完了したりするのを無期限に待ち、どのタスクも処理を進"
"められない状況です。\n"
"たとえば、スレッド A がロック 1 を保持したままロック 2 を待ち、スレッド B が"
"ロック 2 を保持したままロック 1 を待つと、両方のスレッドが無期限に待つことに"
"なります。\n"
"Python では、複数のロックを相反する順序で取得したり、join や await の依存関係"
"が循環したりすると、よくこの状況が発生します。\n"
"複数の :term:`ロック <lock>` を常に一貫した順序で取得すると、デッドロックを回"
"避できます。\n"
":term:`ロック <lock>` と :term:`再入可能 <reentrant>` も参照してください。"

#: ../../glossary.rst:415
msgid "decorator"
msgstr "decorator"

msgid ""
"A function returning another function, usually applied as a function "
"transformation using the ``@wrapper`` syntax.  Common examples for "
"decorators are :deco:`classmethod` and :deco:`staticmethod`."
msgstr ""
"(デコレータ) 別の関数を返す関数で、通常は ``@wrapper`` 構文を使って関数を変換"
"するために適用されます。\n"
"デコレータの代表的な例には、:deco:`classmethod` と :deco:`staticmethod` があ"
"ります。"

#: ../../glossary.rst:421
msgid ""
"The decorator syntax is merely syntactic sugar, the following two function "
"definitions are semantically equivalent::"
msgstr ""
"デコレータの文法はシンタックスシュガーです。次の2つの関数定義は意味的に同じも"
"のです::"

msgid ""
"def f(arg):\n"
"    ...\n"
"f = staticmethod(f)\n"
"\n"
"@staticmethod\n"
"def f(arg):\n"
"    ..."
msgstr ""
"def f(arg):\n"
"    ...\n"
"f = staticmethod(f)\n"
"\n"
"@staticmethod\n"
"def f(arg):\n"
"    ..."

#: ../../glossary.rst:432
msgid ""
"The same concept exists for classes, but is less commonly used there.  See "
"the documentation for :ref:`function definitions <function>` and :ref:`class "
"definitions <class>` for more about decorators."
msgstr ""
"同じ概念がクラスにも存在しますが、あまり使われません。デコレータについて詳し"
"くは、 :ref:`関数定義 <function>` および :ref:`クラス定義 <class>` のドキュメ"
"ントを参照してください。"

#: ../../glossary.rst:435
msgid "descriptor"
msgstr "descriptor"

msgid ""
"Any object which defines the methods :meth:`~object.__get__`, :meth:`~object."
"__set__`, or :meth:`~object.__delete__`. When a class attribute is a "
"descriptor, its special binding behavior is triggered upon attribute "
"lookup.  Normally, using *a.b* to get, set or delete an attribute looks up "
"the object named *b* in the class dictionary for *a*, but if *b* is a "
"descriptor, the respective descriptor method gets called.  Understanding "
"descriptors is a key to a deep understanding of Python because they are the "
"basis for many features including functions, methods, properties, class "
"methods, static methods, and reference to super classes."
msgstr ""
"(デスクリプタ) :meth:`~object.__get__`、:meth:`~object.__set__`、:meth:"
"`~object.__delete__` のいずれかのメソッドを定義したオブジェクトです。\n"
"クラス属性がデスクリプタの場合、属性の検索時に、デスクリプタ特有の束縛動作が"
"起動します。\n"
"通常、*a.b* を使って属性を取得、設定、削除すると、*a* のクラス辞書から *b* と"
"いう名前のオブジェクトを検索しますが、*b* がデスクリプタなら、対応するデスク"
"リプタのメソッドが呼び出されます。\n"
"デスクリプタは、関数、メソッド、プロパティ、クラスメソッド、静的メソッド、"
"スーパークラスへの参照など、多くの機能の基盤となっているため、これを理解する"
"ことは Python を深く理解する鍵となります。"

#: ../../glossary.rst:448
msgid ""
"For more information about descriptors' methods, see :ref:`descriptors` or "
"the :ref:`Descriptor How To Guide <descriptorhowto>`."
msgstr ""
"デスクリプタのメソッドに関しての詳細は、 :ref:`descriptors` や :ref:"
"`Descriptor How To Guide <descriptorhowto>` を参照してください。"

#: ../../glossary.rst:450
msgid "dictionary"
msgstr "dictionary"

msgid ""
"An associative array, where arbitrary keys are mapped to values.  The keys "
"can be any object with :meth:`~object.__hash__` and :meth:`~object.__eq__` "
"methods. Called a hash in Perl."
msgstr ""
"(辞書) 任意のキーが値に対応付けられる連想配列です。\n"
"キーには、:meth:`~object.__hash__` メソッドと :meth:`~object.__eq__` メソッド"
"を持つ任意のオブジェクトを使えます。\n"
"Perl ではハッシュと呼ばれます。"

#: ../../glossary.rst:456
msgid "dictionary comprehension"
msgstr "dictionary comprehension"

#: ../../glossary.rst:458
msgid ""
"A compact way to process all or part of the elements in an iterable and "
"return a dictionary with the results. ``results = {n: n ** 2 for n in "
"range(10)}`` generates a dictionary containing key ``n`` mapped to value ``n "
"** 2``. See :ref:`comprehensions`."
msgstr ""
"(辞書内包表記) iterable 内の全てあるいは一部の要素を処理して、その結果からな"
"る辞書を返すコンパクトな書き方です。 ``results = {n: n ** 2 for n in "
"range(10)}`` とすると、キー ``n`` を値 ``n ** 2`` に対応付ける辞書を生成しま"
"す。 :ref:`comprehensions` を参照してください。"

#: ../../glossary.rst:462
msgid "dictionary view"
msgstr "dictionary view"

msgid ""
"The objects returned from :meth:`dict.keys`, :meth:`dict.values`, and :meth:"
"`dict.items` are called dictionary views. They provide a dynamic view on the "
"dictionary’s entries, which means that when the dictionary changes, the view "
"reflects these changes. To force the dictionary view to become a full list "
"use ``list(dictview)``.  See :ref:`dict-views`."
msgstr ""
"(辞書ビュー)\n"
":meth:`dict.keys`、:meth:`dict.values`、:meth:`dict.items` が返すオブジェクト"
"です。\n"
"辞書の項目の動的なビューを提供します。\n"
"すなわち、辞書が変更されるとビューはそれを反映します。\n"
"辞書ビューを強制的に完全なリストにするには ``list(dictview)`` を使用してくだ"
"さい。\n"
":ref:`dict-views` を参照してください。"

#: ../../glossary.rst:470
msgid "docstring"
msgstr "docstring"

msgid ""
"A string literal which appears as the first expression in a class, function "
"or module.  While ignored when the suite is executed, it is recognized by "
"the compiler and put into the :attr:`~definition.__doc__` attribute of the "
"enclosing class, function or module.  Since it is available via "
"introspection, it is the canonical place for documentation of the object."
msgstr ""
"(ドキュメンテーション文字列) クラス、関数、モジュールの最初の式として現れる文"
"字列リテラルです。\n"
"スイートの実行時には無視されますが、コンパイラによって認識され、それを囲むク"
"ラス、関数、モジュールの :attr:`~definition.__doc__` 属性に格納されます。\n"
"イントロスペクションを通じて利用できるため、オブジェクトのドキュメントを書く"
"標準的な場所となっています。"

#: ../../glossary.rst:478
msgid "duck-typing"
msgstr "duck-typing"

#: ../../glossary.rst:480
msgid ""
"A programming style which does not look at an object's type to determine if "
"it has the right interface; instead, the method or attribute is simply "
"called or used (\"If it looks like a duck and quacks like a duck, it must be "
"a duck.\")  By emphasizing interfaces rather than specific types, well-"
"designed code improves its flexibility by allowing polymorphic "
"substitution.  Duck-typing avoids tests using :func:`type` or :func:"
"`isinstance`.  (Note, however, that duck-typing can be complemented with :"
"term:`abstract base classes <abstract base class>`.)  Instead, it typically "
"employs :func:`hasattr` tests or :term:`EAFP` programming."
msgstr ""
"あるオブジェクトが正しいインターフェースを持っているかを決定するのにオブジェ"
"クトの型を見ないプログラミングスタイルです。代わりに、単純にオブジェクトのメ"
"ソッドや属性が呼ばれたり使われたりします。（「アヒルのように見えて、アヒルの"
"ように鳴けば、それはアヒルである。」）インターフェースを型より重視すること"
"で、上手くデザインされたコードは、ポリモーフィックな代替を許して柔軟性を向上"
"させます。ダックタイピングは :func:`type` や :func:`isinstance` による判定を"
"避けます。 (ただし、ダックタイピングを :term:`抽象基底クラス <abstract base "
"class>` で補完することもできます。) その代わり、典型的に :func:`hasattr` 判定"
"や :term:`EAFP` プログラミングを利用します。"

msgid "dunder"
msgstr "dunder"

msgid ""
"An informal short-hand for \"double underscore\", used when talking about a :"
"term:`special method`. For example, ``__init__`` is often pronounced "
"\"dunder init\"."
msgstr ""
"「double underscore（二重アンダースコア）」を表す非公式な略語で、:term:`特殊"
"メソッド <special method>` について話すときに使います。\n"
"たとえば、``__init__`` はよく「dunder init」と発音されます。"

#: ../../glossary.rst:494
msgid "EAFP"
msgstr "EAFP"

msgid ""
"Easier to ask for forgiveness than permission.  This common Python coding "
"style assumes the existence of valid keys or attributes and catches "
"exceptions if the assumption proves false.  This clean and fast style is "
"characterized by the presence of many :keyword:`try` and :keyword:`except` "
"statements.  The technique contrasts with the :term:`LBYL` style common to "
"many other languages such as C."
msgstr ""
"許可を求めるより、許しを請うほうが容易（Easier to ask for forgiveness than "
"permission）の略です。\n"
"Python で一般的なこのコーディングスタイルでは、有効なキーや属性が存在すると仮"
"定し、その仮定が誤っていた場合に例外を捕捉します。\n"
"この簡潔で高速なスタイルは、:keyword:`try` 文と :keyword:`except` 文を多用す"
"ることを特徴とします。\n"
"この手法は、C などの多くの言語で一般的な :term:`LBYL` スタイルと対照的です。"

msgid "evaluate function"
msgstr "evaluate function"

msgid ""
"A function that can be called to evaluate a lazily evaluated attribute of an "
"object, such as the value of type aliases created with the :keyword:`type` "
"statement."
msgstr ""
"(評価関数) :keyword:`type` 文で作成された型エイリアスの値など、オブジェクトの"
"遅延評価される属性を評価するために呼び出せる関数です。"

msgid "exhausted"
msgstr "exhausted"

msgid ""
"An :term:`iterator` that has produced all of its values is said to be :dfn:"
"`exhausted`. Further attempts to get the next value (for example, calls to :"
"func:`next`) raise :exc:`StopIteration` (or :exc:`StopAsyncIteration` in the "
"case of an :term:`asynchronous iterator`)."
msgstr ""
"(枯渇した) すべての値を生成し終えた :term:`イテレータ <iterator>` を :dfn:`枯"
"渇した` といいます。\n"
"その後に次の値を取得しようとすると（たとえば :func:`next` を呼び出すと）、:"
"exc:`StopIteration`（:term:`非同期イテレータ <asynchronous iterator>` の場合"
"は :exc:`StopAsyncIteration`）が送出されます。"

#: ../../glossary.rst:515
msgid "expression"
msgstr "expression"

msgid ""
"A piece of syntax which can be evaluated to some value.  In other words, an "
"expression is an accumulation of expression elements like literals, names, "
"attribute access, operators or function calls which all return a value.  Not "
"all language constructs are expressions.  There are also :term:"
"`statement`\\s which cannot be used as expressions, such as :keyword:"
"`while`.  Assignments are also statements, not expressions."
msgstr ""
"(式) 評価すると何らかの値になる構文の一部です。\n"
"つまり、式は、リテラル、名前、属性アクセス、演算子、関数呼び出しなど、いずれ"
"も値を返す式の要素を組み合わせたものです。\n"
"言語のすべての構成要素が式というわけではありません。\n"
":keyword:`while` のように、式として使えない :term:`文 <statement>` もありま"
"す。\n"
"代入も式ではなく文です。"

#: ../../glossary.rst:524
msgid "extension module"
msgstr "extension module"

#: ../../glossary.rst:526
msgid ""
"A module written in C or C++, using Python's C API to interact with the core "
"and with user code."
msgstr ""
"(拡張モジュール) C や C++ で書かれたモジュールで、Python の C API を利用して "
"Python コアやユーザーコードとやりとりします。"

#: ../../glossary.rst:528
msgid "f-string"
msgstr "f-string"

msgid "f-strings"
msgstr "f-strings"

msgid ""
"String literals prefixed with ``f`` or ``F`` are commonly called \"f-"
"strings\" which is short for :ref:`formatted string literals <f-strings>`.  "
"See also :pep:`498`."
msgstr ""
"``f`` または ``F`` を接頭辞に持つ文字列リテラルは、一般に「f-string」と呼ばれ"
"ます。\n"
"これは :ref:`フォーマット済み文字列リテラル <f-strings>` の略です。\n"
":pep:`498` も参照してください。"

#: ../../glossary.rst:534
msgid "file object"
msgstr "file object"

msgid ""
"An object exposing a file-oriented API (with methods such as :meth:`!read` "
"or :meth:`!write`) to an underlying resource.  Depending on the way it was "
"created, a file object can mediate access to a real on-disk file or to "
"another type of storage or communication device (for example standard input/"
"output, in-memory buffers, sockets, pipes, etc.).  File objects are also "
"called :dfn:`file-like objects` or :dfn:`streams`."
msgstr ""
"(ファイルオブジェクト) 基になるリソースに対して、ファイル向けの API（:meth:`!"
"read` や :meth:`!write` などのメソッド）を提供するオブジェクトです。\n"
"作成方法に応じて、ディスク上の実際のファイル、または別の種類の記憶装置や通信"
"装置（標準入出力、メモリ内バッファ、ソケット、パイプなど）へのアクセスを仲介"
"できます。\n"
"ファイルオブジェクトは、:dfn:`file-like オブジェクト` や :dfn:`ストリーム` と"
"も呼ばれます。"

#: ../../glossary.rst:544
msgid ""
"There are actually three categories of file objects: raw :term:`binary files "
"<binary file>`, buffered :term:`binary files <binary file>` and :term:`text "
"files <text file>`. Their interfaces are defined in the :mod:`io` module.  "
"The canonical way to create a file object is by using the :func:`open` "
"function."
msgstr ""
"ファイルオブジェクトには実際には 3 種類あります: 生の :term:`バイナリーファイ"
"ル <binary file>`、バッファされた :term:`バイナリーファイル <binary file>`、"
"そして :term:`テキストファイル<text file>` です。インターフェイスは :mod:"
"`io` モジュールで定義されています。ファイルオブジェクトを作る標準的な方法は :"
"func:`open` 関数を使うことです。"

#: ../../glossary.rst:549
msgid "file-like object"
msgstr "file-like object"

#: ../../glossary.rst:551
msgid "A synonym for :term:`file object`."
msgstr ":term:`file object` と同義です。"

msgid "filesystem encoding and error handler"
msgstr "filesystem encoding and error handler"

msgid ""
"Encoding and error handler used by Python to decode bytes from the operating "
"system and encode Unicode to the operating system."
msgstr ""
"(ファイルシステムのエンコーディングとエラーハンドラ) オペレーティングシステム"
"から受け取ったバイト列のデコードと、オペレーティングシステムに渡す Unicode の"
"エンコードに Python が使用する、エンコーディングとエラーハンドラです。"

msgid ""
"The filesystem encoding must guarantee to successfully decode all bytes "
"below 128. If the file system encoding fails to provide this guarantee, API "
"functions can raise :exc:`UnicodeError`."
msgstr ""
"ファイルシステムのエンコーディングは、128 未満のすべてのバイト値を正常にデ"
"コードできることを保証しなければなりません。\n"
"ファイルシステムのエンコーディングがこれを保証しない場合、API 関数が :exc:"
"`UnicodeError` を送出することがあります。"

msgid ""
"The :func:`sys.getfilesystemencoding` and :func:`sys."
"getfilesystemencodeerrors` functions can be used to get the filesystem "
"encoding and error handler."
msgstr ""
":func:`sys.getfilesystemencoding` 関数と :func:`sys."
"getfilesystemencodeerrors` 関数を使うと、ファイルシステムのエンコーディングと"
"エラーハンドラを取得できます。"

msgid ""
"The :term:`filesystem encoding and error handler` are configured at Python "
"startup by the :c:func:`PyConfig_Read` function: see :c:member:`~PyConfig."
"filesystem_encoding` and :c:member:`~PyConfig.filesystem_errors` members of :"
"c:type:`PyConfig`."
msgstr ""
":term:`ファイルシステムのエンコーディングとエラーハンドラ <filesystem "
"encoding and error handler>` は、Python の開始時に :c:func:`PyConfig_Read` 関"
"数により設定されます。 :c:type:`PyConfig` のメンバー :c:member:`~PyConfig."
"filesystem_encoding` と :c:member:`~PyConfig.filesystem_errors` を参照してく"
"ださい。"

msgid "See also the :term:`locale encoding`."
msgstr ""
":term:`ロケールエンコーディング <locale encoding>` も参照してください。"

#: ../../glossary.rst:571
msgid "finder"
msgstr "finder"

#: ../../glossary.rst:573
msgid ""
"An object that tries to find the :term:`loader` for a module that is being "
"imported."
msgstr ""
"(ファインダ)\n"
"インポートされているモジュールの :term:`loader` の発見を試行するオブジェクト"
"です。"

msgid ""
"There are two types of finder: :term:`meta path finders <meta path finder>` "
"for use with :data:`sys.meta_path`, and :term:`path entry finders <path "
"entry finder>` for use with :data:`sys.path_hooks`."
msgstr ""
"ファインダには、:data:`sys.meta_path` で使用する :term:`メタパスファインダ "
"<meta path finder>` と、:data:`sys.path_hooks` で使用する :term:`パスエントリ"
"ファインダ <path entry finder>` の 2 種類があります。"

msgid ""
"See :ref:`finders-and-loaders` and :mod:`importlib` for much more detail."
msgstr ""
"詳しくは、:ref:`finders-and-loaders` と :mod:`importlib` を参照してください。"

#: ../../glossary.rst:581
msgid "floor division"
msgstr "floor division"

#: ../../glossary.rst:583
msgid ""
"Mathematical division that rounds down to nearest integer.  The floor "
"division operator is ``//``.  For example, the expression ``11 // 4`` "
"evaluates to ``2`` in contrast to the ``2.75`` returned by float true "
"division.  Note that ``(-11) // 4`` is ``-3`` because that is ``-2.75`` "
"rounded *downward*. See :pep:`238`."
msgstr ""
"(切り捨て除算) 一番近い整数に切り捨てる数学的除算。\n"
"切り捨て除算演算子は ``//`` です。\n"
"例えば、 ``11 // 4`` は ``2`` になり、それとは対称に浮動小数点数の真の除算で"
"は ``2.75`` が 返ってきます。\n"
"``(-11) // 4`` は ``-2.75`` を *小さい方に* 丸める (訳注: 負の無限大への丸め"
"を行う) ので ``-3`` になることに注意してください。\n"
":pep:`238` を参照してください。"

msgid "free threading"
msgstr "free threading"

msgid ""
"A threading model where multiple threads can run Python bytecode "
"simultaneously within the same interpreter.  This is in contrast to the :"
"term:`global interpreter lock` which allows only one thread to execute "
"Python bytecode at a time.  See :pep:`703`."
msgstr ""
"(フリースレッディング) 同じインタープリタ内で、複数のスレッドが Python バイト"
"コードを同時に実行できるスレッドモデルです。\n"
"一度に一つのスレッドだけが Python バイトコードを実行できる :term:`グローバル"
"インタープリタロック <global interpreter lock>` とは対照的です。\n"
":pep:`703` を参照してください。"

msgid "free-threaded build"
msgstr "free-threaded build"

msgid ""
"A build of :term:`CPython` that supports :term:`free threading`, configured "
"using the :option:`--disable-gil` option before compilation."
msgstr ""
"(フリースレッドビルド) コンパイル前に :option:`--disable-gil` オプションで構"
"成した、:term:`フリースレッディング <free threading>` に対応する :term:"
"`CPython` のビルドです。"

msgid "See :ref:`freethreading-python-howto`."
msgstr ":ref:`freethreading-python-howto` を参照してください。"

msgid "free variable"
msgstr "free variable"

msgid ""
"Formally, as defined in the :ref:`language execution model <bind_names>`, a "
"free variable is any variable used in a namespace which is not a local "
"variable in that namespace. See :term:`closure variable` for an example. "
"Pragmatically, due to the name of the :attr:`codeobject.co_freevars` "
"attribute, the term is also sometimes used as a synonym for :term:`closure "
"variable`."
msgstr ""
"(自由変数) :ref:`言語の実行モデル <bind_names>` における正式な定義では、ある"
"名前空間で使われる変数で、その名前空間のローカル変数ではないものを指しま"
"す。\n"
"例については :term:`クロージャ変数 <closure variable>` を参照してください。\n"
"実際の用法では、:attr:`codeobject.co_freevars` 属性の名前に由来して、:term:`"
"クロージャ変数 <closure variable>` の同義語として使われることもあります。"

#: ../../glossary.rst:608
msgid "function"
msgstr "関数"

#: ../../glossary.rst:610
msgid ""
"A series of statements which returns some value to a caller. It can also be "
"passed zero or more :term:`arguments <argument>` which may be used in the "
"execution of the body. See also :term:`parameter`, :term:`method`, and the :"
"ref:`function` section."
msgstr ""
"(関数) 呼び出し側に値を返す一連の文のことです。関数には0以上の :term:`実引数 "
"<argument>` を渡すことが出来ます。実体の実行時に引数を使用することが出来ま"
"す。 :term:`仮引数 <parameter>`、:term:`メソッド <method>`、:ref:`function` "
"を参照してください。"

#: ../../glossary.rst:614
msgid "function annotation"
msgstr "function annotation"

#: ../../glossary.rst:616
msgid "An :term:`annotation` of a function parameter or return value."
msgstr ""
"(関数アノテーション) 関数のパラメータや返り値の :term:`annotation` です。"

msgid ""
"Function annotations are usually used for :term:`type hints <type hint>`: "
"for example, this function is expected to take two :class:`int` arguments "
"and is also expected to have an :class:`int` return value::"
msgstr ""
"関数アノテーションは通常、:term:`型ヒント <type hint>` に使用されます。\n"
"たとえば、次の関数は二つの :class:`int` 型の引数を受け取り、:class:`int` 型の"
"値を返すことを想定しています。 ::"

msgid ""
"def sum_two_numbers(a: int, b: int) -> int:\n"
"   return a + b"
msgstr ""
"def sum_two_numbers(a: int, b: int) -> int:\n"
"   return a + b"

#: ../../glossary.rst:626
msgid "Function annotation syntax is explained in section :ref:`function`."
msgstr "関数アノテーションの文法は :ref:`function` の節で解説されています。"

#: ../../glossary.rst:628
msgid ""
"See :term:`variable annotation` and :pep:`484`, which describe this "
"functionality. Also see :ref:`annotations-howto` for best practices on "
"working with annotations."
msgstr ""
"機能の説明がある :term:`variable annotation`, :pep:`484`,を参照してください。"
"また、アノテーションを利用するベストプラクティスとして :ref:`annotations-"
"howto` も参照してください。"

#: ../../glossary.rst:632
msgid "__future__"
msgstr "__future__"

#: ../../glossary.rst:634
msgid ""
"A :ref:`future statement <future>`, ``from __future__ import <feature>``, "
"directs the compiler to compile the current module using syntax or semantics "
"that will become standard in a future release of Python. The :mod:"
"`__future__` module documents the possible values of *feature*.  By "
"importing this module and evaluating its variables, you can see when a new "
"feature was first added to the language and when it will (or did) become the "
"default::"
msgstr ""
"``from __future__ import <feature>`` という :ref:`future 文 <future>` は、コ"
"ンパイラーに将来の Python リリースで標準となる構文や意味を使用して現在のモ"
"ジュールをコンパイルするよう指示します。 :mod:`__future__` モジュールでは、 "
"*feature* のとりうる値をドキュメント化しています。このモジュールをインポート"
"し、その変数を評価することで、新機能が最初に言語に追加されたのはいつかや、い"
"つデフォルトになるか (またはなったか) を見ることができます::"

msgid ""
">>> import __future__\n"
">>> __future__.division\n"
"_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)"
msgstr ""
">>> import __future__\n"
">>> __future__.division\n"
"_Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)"

#: ../../glossary.rst:645
msgid "garbage collection"
msgstr "garbage collection"

#: ../../glossary.rst:647
msgid ""
"The process of freeing memory when it is not used anymore.  Python performs "
"garbage collection via reference counting and a cyclic garbage collector "
"that is able to detect and break reference cycles.  The garbage collector "
"can be controlled using the :mod:`gc` module."
msgstr ""
"(ガベージコレクション) これ以降使われることのないメモリを解放する処理です。\n"
"Pythonは、参照カウントと、循環参照を検出し破壊する循環ガベージコレクタを使っ"
"てガベージコレクションを行います。\n"
"ガベージコレクタは :mod:`gc` モジュールを使って操作できます。"

#: ../../glossary.rst:652 ../../glossary.rst:653
msgid "generator"
msgstr "ジェネレータ"

msgid ""
"Informally used to mean either a :term:`generator function` or a :term:"
"`generator iterator`, depending on context.  The formal terms :term:"
"`generator function` and :term:`generator iterator` are uncommon in "
"practice; \"generator\" alone is almost always sufficient."
msgstr ""
"文脈に応じて、:term:`ジェネレータ関数 <generator function>` または :term:`"
"ジェネレータイテレータ <generator iterator>` のどちらかを指すために非公式に使"
"われる語です。\n"
"正式な用語である :term:`ジェネレータ関数 <generator function>` と :term:`ジェ"
"ネレータイテレータ <generator iterator>` は、実際にはあまり使われません。\n"
"ほとんどの場合、「ジェネレータ」だけで十分です。"

msgid "generator function"
msgstr "generator function"

msgid ""
"A function which returns a :term:`generator` object.  It looks like a normal "
"function except that it contains :keyword:`yield` expressions for producing "
"a series of values usable in a :keyword:`for`\\-loop or that can be "
"retrieved one at a time with the :func:`next` function. See :ref:`yieldexpr`."
msgstr ""
"(ジェネレータ関数) :term:`ジェネレータ <generator>` オブジェクトを返す関数で"
"す。\n"
"通常の関数に似ていますが、:keyword:`for` ループで使用したり、:func:`next` 関"
"数で一つずつ取得したりできる一連の値を生成するための :keyword:`yield` 式を含"
"む点が異なります。\n"
":ref:`yieldexpr` を参照してください。"

#: ../../glossary.rst:668
msgid "generator iterator"
msgstr "generator iterator"

msgid ""
"An object created by a :term:`generator function` or a :term:`generator "
"expression`."
msgstr ""
":term:`ジェネレータ関数 <generator function>` または :term:`ジェネレータ式 "
"<generator expression>` によって作成されるオブジェクトです。"

msgid ""
"Each :keyword:`yield` temporarily suspends processing, remembering the "
"execution state (including local variables and pending try-statements). When "
"the *generator iterator* resumes, it picks up where it left off (in contrast "
"to functions which start fresh on every invocation)."
msgstr ""
"各 :keyword:`yield` は処理を一時的に中断し、実行状態（ローカル変数や保留中の "
"try 文を含む）を記憶します。\n"
"*ジェネレータイテレータ* は、実行を再開すると、中断した箇所から処理を続けます"
"（呼び出しのたびに最初から実行する関数とは異なります）。"

msgid ""
"Generator iterators also implement the :meth:`~generator.send` method to "
"send a value into the suspended generator, and the :meth:`~generator.throw` "
"method to raise an exception at the point where the generator was paused.  "
"See :ref:`generator-methods`."
msgstr ""
"ジェネレータイテレータは、中断したジェネレータに値を送る :meth:`~generator."
"send` メソッドと、ジェネレータが中断した箇所で例外を送出する :meth:"
"`~generator.throw` メソッドも実装します。\n"
":ref:`generator-methods` を参照してください。"

#: ../../glossary.rst:683 ../../glossary.rst:684
msgid "generator expression"
msgstr "generator expression"

msgid ""
"An :term:`expression` that returns an :term:`iterator`.  It looks like a "
"normal expression followed by a :keyword:`!for` clause defining a loop "
"variable, range, and an optional :keyword:`!if` clause.  The combined "
"expression generates values for an enclosing function::"
msgstr ""
"(ジェネレータ式) :term:`イテレータ <iterator>` を返す :term:`式 "
"<expression>` です。\n"
"通常の式の後に、ループ変数と範囲を定義する :keyword:`!for` 節、そして省略可能"
"な :keyword:`!if` 節が続く形をしています。\n"
"このように組み合わせた式は、外側の関数に渡す値を生成します。 ::"

msgid ""
">>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81\n"
"285"
msgstr ""
">>> sum(i*i for i in range(10))         # 平方数 0, 1, 4, ... 81 の合計\n"
"285"

#: ../../glossary.rst:693
msgid "generic function"
msgstr "generic function"

#: ../../glossary.rst:695
msgid ""
"A function composed of multiple functions implementing the same operation "
"for different types. Which implementation should be used during a call is "
"determined by the dispatch algorithm."
msgstr ""
"(ジェネリック関数) 異なる型に対し同じ操作をする関数群から構成される関数です。"
"呼び出し時にどの実装を用いるかはディスパッチアルゴリズムにより決定されます。"

msgid ""
"See also the :term:`single dispatch` glossary entry, the :deco:`functools."
"singledispatch` decorator, and :pep:`443`."
msgstr ""
"用語集の :term:`単一ディスパッチ <single dispatch>` の項目、:deco:`functools."
"singledispatch` デコレータ、および :pep:`443` も参照してください。"

msgid "generic type"
msgstr "generic type"

msgid ""
"A :term:`type` that can be parameterized; typically a :ref:`container "
"class<sequence-types>` such as :class:`list` or :class:`dict`. Used for :"
"term:`type hints <type hint>` and :term:`annotations <annotation>`."
msgstr ""
"(ジェネリック型) パラメータ化できる :term:`型 <type>` で、通常は :class:"
"`list` や :class:`dict` のような :ref:`コンテナクラス <sequence-types>` で"
"す。\n"
":term:`型ヒント <type hint>` や :term:`アノテーション <annotation>` に使用さ"
"れます。"

msgid ""
"For more details, see :ref:`generic alias types<types-genericalias>`, :pep:"
"`483`, :pep:`484`, :pep:`585`, and the :mod:`typing` module."
msgstr ""
"詳しくは、:ref:`ジェネリックエイリアス型 <types-genericalias>`、:pep:`483`、:"
"pep:`484`、:pep:`585`、:mod:`typing` モジュールを参照してください。"

#: ../../glossary.rst:710
msgid "GIL"
msgstr "GIL"

#: ../../glossary.rst:712
msgid "See :term:`global interpreter lock`."
msgstr ":term:`global interpreter lock` を参照してください。"

#: ../../glossary.rst:713
msgid "global interpreter lock"
msgstr "global interpreter lock"

msgid ""
"The mechanism used by the :term:`CPython` interpreter to assure that only "
"one thread executes Python :term:`bytecode` at a time. This simplifies the "
"CPython implementation by making the object model (including critical built-"
"in types such as :class:`dict`) implicitly safe against concurrent access.  "
"Locking the entire interpreter makes it easier for the interpreter to be "
"multi-threaded, at the expense of much of the parallelism afforded by multi-"
"processor machines."
msgstr ""
"(グローバルインタプリタロック) :term:`CPython` インタプリタが、一度に一つのス"
"レッドだけが Python の :term:`バイトコード <bytecode>` を実行することを保証す"
"るために使う仕組みです。\n"
"この仕組みは、:class:`dict` などの重要な組み込み型を含むオブジェクトモデル"
"を、並行アクセスに対して暗黙に安全にすることで、CPython の実装を単純にしま"
"す。\n"
"インタプリタ全体をロックすると、マルチプロセッサマシンが可能にする並列性の多"
"くを犠牲にする代わりに、インタプリタをマルチスレッド化しやすくなります。"

#: ../../glossary.rst:724
msgid ""
"However, some extension modules, either standard or third-party, are "
"designed so as to release the GIL when doing computationally intensive tasks "
"such as compression or hashing.  Also, the GIL is always released when doing "
"I/O."
msgstr ""
"ただし、標準あるいは外部のいくつかの拡張モジュールは、圧縮やハッシュ計算など"
"の計算の重い処理をするときに GIL を解除するように設計されています。また、I/O "
"処理をする場合 GIL は常に解除されます。"

msgid ""
"As of Python 3.13, the GIL can be disabled using the :option:`--disable-gil` "
"build configuration. After building Python with this option, code must be "
"run with :option:`-X gil=0 <-X>` or after setting the :envvar:`PYTHON_GIL=0 "
"<PYTHON_GIL>` environment variable. This feature enables improved "
"performance for multi-threaded applications and makes it easier to use multi-"
"core CPUs efficiently. For more details, see :pep:`703`."
msgstr ""
"Python 3.13 以降では、ビルド設定 :option:`--disable-gil` を使って GIL を無効"
"にできます。\n"
"このオプションで Python をビルドした後は、:option:`-X gil=0 <-X>` を指定する"
"か、環境変数 :envvar:`PYTHON_GIL=0 <PYTHON_GIL>` を設定してコードを実行する必"
"要があります。\n"
"この機能により、マルチスレッドアプリケーションの性能を改善でき、マルチコア "
"CPU を効率よく利用しやすくなります。\n"
"詳しくは :pep:`703` を参照してください。"

msgid ""
"In prior versions of Python's C API, a function might declare that it "
"requires the GIL to be held in order to use it. This refers to having an :"
"term:`attached thread state`."
msgstr ""
"以前の Python C API では、関数を使用するには GIL を保持する必要があると宣言さ"
"れていることがありました。\n"
"これは、:term:`スレッド状態がアタッチされている <attached thread state>` こと"
"を指します。"

msgid "global state"
msgstr "global state"

msgid ""
"Data that is accessible throughout a program, such as module-level "
"variables, class variables, or C static variables in :term:`extension "
"modules <extension module>`.  In multi-threaded programs, global state "
"shared between threads typically requires synchronization to avoid :term:"
"`race conditions <race condition>` and :term:`data races <data race>`."
msgstr ""
"(グローバル状態) モジュールレベルの変数、クラス変数、:term:`拡張モジュール "
"<extension module>` 内の C の静的変数など、プログラム全体からアクセスできる"
"データです。\n"
"マルチスレッドプログラムでは、スレッド間で共有されるグローバル状態には通常、:"
"term:`競合状態 <race condition>` や :term:`データ競合 <data race>` を避けるた"
"めの同期が必要です。"

#: ../../glossary.rst:747
msgid "hash-based pyc"
msgstr "hash-based pyc"

#: ../../glossary.rst:749
msgid ""
"A bytecode cache file that uses the hash rather than the last-modified time "
"of the corresponding source file to determine its validity. See :ref:`pyc-"
"invalidation`."
msgstr ""
"(ハッシュベース pyc ファイル) 正当性を判別するために、対応するソースファイル"
"の最終更新時刻ではなくハッシュ値を使用するバイトコードのキャッシュファイルで"
"す。:ref:`pyc-invalidation` を参照してください。"

#: ../../glossary.rst:752
msgid "hashable"
msgstr "hashable"

msgid ""
"An object is *hashable* if it has a hash value which never changes during "
"its lifetime (it needs a :meth:`~object.__hash__` method), and can be "
"compared to other objects (it needs an :meth:`~object.__eq__` method). "
"Hashable objects which compare equal must have the same hash value."
msgstr ""
"(ハッシュ可能) オブジェクトの生存期間を通して変わらないハッシュ値を持ち（:"
"meth:`~object.__hash__` メソッドが必要です）、ほかのオブジェクトと比較できる"
"（:meth:`~object.__eq__` メソッドが必要です）場合、そのオブジェクトは *ハッ"
"シュ可能* です。\n"
"比較で等しいと判定されるハッシュ可能オブジェクトは、同じハッシュ値を持たなけ"
"ればなりません。"

#: ../../glossary.rst:760
msgid ""
"Hashability makes an object usable as a dictionary key and a set member, "
"because these data structures use the hash value internally."
msgstr ""
"ハッシュ可能なオブジェクトは辞書のキーや集合のメンバーとして使えます。辞書や"
"集合のデータ構造は内部でハッシュ値を使っているからです。"

#: ../../glossary.rst:763
msgid ""
"Most of Python's immutable built-in objects are hashable; mutable containers "
"(such as lists or dictionaries) are not; immutable containers (such as "
"tuples and frozensets) are only hashable if their elements are hashable.  "
"Objects which are instances of user-defined classes are hashable by "
"default.  They all compare unequal (except with themselves), and their hash "
"value is derived from their :func:`id`."
msgstr ""
"Python のイミュータブルな組み込みオブジェクトは、ほとんどがハッシュ可能です。"
"(リストや辞書のような) ミュータブルなコンテナはハッシュ不可能です。(タプルや "
"frozenset のような) イミュータブルなコンテナは、要素がハッシュ可能であるとき"
"のみハッシュ可能です。\n"
"ユーザー定義のクラスのインスタンスであるようなオブジェクトはデフォルトでハッ"
"シュ可能です。\n"
"それらは全て (自身を除いて) 比較結果は非等価であり、ハッシュ値は :func:`id` "
"より得られます。"

#: ../../glossary.rst:770
msgid "IDLE"
msgstr "IDLE"

#: ../../glossary.rst:772
msgid ""
"An Integrated Development and Learning Environment for Python. :ref:`idle` "
"is a basic editor and interpreter environment which ships with the standard "
"distribution of Python."
msgstr ""
"Python の統合開発環境 (Integrated DeveLopment Environment)及び学習環境 "
"(Learning Environment) です。:ref:`idle` は Python の標準的な配布に同梱されて"
"いる基本的な機能のエディタとインタプリタ環境です。"

#: ../../glossary.rst:775
msgid "immortal"
msgstr "永続オブジェクト (immortal)"

msgid ""
"*Immortal objects* are a CPython implementation detail introduced in :pep:"
"`683`."
msgstr ""
"*永続オブジェクト* は、:pep:`683` で導入された CPython の実装の詳細です。"

msgid ""
"If an object is immortal, its :term:`reference count` is never modified, and "
"therefore it is never deallocated while the interpreter is running. For "
"example, :const:`True` and :const:`None` are immortal in CPython."
msgstr ""
"オブジェクトが永続である場合、その :term:`参照カウント <reference count>` は"
"決して変更されず、そのためインタープリタの実行中にメモリが解放されることはあ"
"りません。\n"
"たとえば、CPython では :const:`True` と :const:`None` が永続オブジェクトで"
"す。"

msgid ""
"Immortal objects can be identified via :func:`sys._is_immortal`, or via :c:"
"func:`PyUnstable_IsImmortal` in the C API."
msgstr ""
"永続オブジェクトは :func:`sys._is_immortal`、または C API の :c:func:"
"`PyUnstable_IsImmortal` によって識別できます。"

#: ../../glossary.rst:786
msgid "immutable"
msgstr "immutable"

msgid ""
"An object with a fixed value.  Immutable objects include numbers, strings "
"and tuples.  Such an object cannot be altered.  A new object has to be "
"created if a different value has to be stored.  They play an important role "
"in places where a constant hash value is needed, for example as a key in a "
"dictionary.  Immutable objects are inherently :term:`thread-safe` because "
"their state cannot be modified after creation, eliminating concerns about "
"improperly synchronized :term:`concurrent modification`."
msgstr ""
"(不変) 値が固定されたオブジェクトです。\n"
"不変オブジェクトには、数値、文字列、タプルがあります。\n"
"このようなオブジェクトは変更できません。\n"
"異なる値を格納するには、新しいオブジェクトを作成する必要があります。\n"
"不変オブジェクトは、辞書のキーなど、ハッシュ値が一定である必要のある場面で重"
"要な役割を果たします。\n"
"作成後に状態を変更できないため、不変オブジェクトは本質的に :term:`スレッド"
"セーフ <thread-safe>` であり、不適切な同期による :term:`並行変更 <concurrent "
"modification>` を心配する必要がありません。"

#: ../../glossary.rst:795
msgid "import path"
msgstr "import path"

#: ../../glossary.rst:797
msgid ""
"A list of locations (or :term:`path entries <path entry>`) that are searched "
"by the :term:`path based finder` for modules to import. During import, this "
"list of locations usually comes from :data:`sys.path`, but for subpackages "
"it may also come from the parent package's ``__path__`` attribute."
msgstr ""
":term:`path based finder` が import するモジュールを検索する場所 (または :"
"term:`path entry`) のリスト。 import 中、このリストは通常 :data:`sys.path` か"
"ら来ますが、サブパッケージの場合は親パッケージの ``__path__`` 属性からも来ま"
"す。"

#: ../../glossary.rst:802
msgid "importing"
msgstr "importing"

#: ../../glossary.rst:804
msgid ""
"The process by which Python code in one module is made available to Python "
"code in another module."
msgstr ""
"あるモジュールの Python コードが別のモジュールの Python コードで使えるように"
"する処理です。"

#: ../../glossary.rst:806
msgid "importer"
msgstr "importer"

#: ../../glossary.rst:808
msgid ""
"An object that both finds and loads a module; both a :term:`finder` and :"
"term:`loader` object."
msgstr ""
"モジュールを探してロードするオブジェクト。 :term:`finder` と :term:`loader` "
"のどちらでもあるオブジェクト。"

msgid "index"
msgstr "index"

msgid ""
"A numeric value that represents the position of an element in a :term:"
"`sequence`."
msgstr ""
"(インデックス) :term:`シーケンス <sequence>` 内の要素の位置を表す数値です。"

msgid ""
"In Python, indexing starts at zero. For example, ``things[0]`` names the "
"*first* element of ``things``; ``things[1]`` names the second one."
msgstr ""
"Python のインデックスはゼロから始まります。\n"
"たとえば、``things[0]`` は ``things`` の *最初* の要素を、``things[1]`` は 2 "
"番目の要素を表します。"

msgid ""
"In some contexts, Python allows negative indexes for counting from the end "
"of a sequence, and indexing using :term:`slices <slice>`."
msgstr ""
"文脈によっては、Python はシーケンスの末尾から数えるための負のインデックス"
"や、:term:`スライス <slice>` を使ったインデックス指定を許可しています。"

msgid "See also :term:`subscript`."
msgstr ":term:`添字 <subscript>` も参照してください。"

#: ../../glossary.rst:823
msgid "interactive"
msgstr "interactive"

msgid ""
"Python has an interactive interpreter which means you can enter statements "
"and expressions at the interpreter prompt, immediately execute them and see "
"their results.  Just launch ``python`` with no arguments (possibly by "
"selecting it from your computer's main menu). It is a very powerful way to "
"test out new ideas or inspect modules and packages (remember ``help(x)``). "
"For more on interactive mode, see :ref:`tut-interac`."
msgstr ""
"(対話型) Python には対話型インタープリタがあり、そのプロンプトで文や式を入力"
"して、すぐに実行し、結果を見ることができます。\n"
"``python`` を引数なしで起動するだけで利用できます（コンピュータのメインメ"
"ニューで選択して起動することもできます）。\n"
"新しいアイデアを試したり、モジュールやパッケージを調べたりするための、とても"
"強力な方法です（``help(x)`` を思い出してください）。\n"
"対話モードについて詳しくは、:ref:`tut-interac` を参照してください。"

#: ../../glossary.rst:832
msgid "interpreted"
msgstr "interpreted"

#: ../../glossary.rst:834
msgid ""
"Python is an interpreted language, as opposed to a compiled one, though the "
"distinction can be blurry because of the presence of the bytecode compiler.  "
"This means that source files can be run directly without explicitly creating "
"an executable which is then run. Interpreted languages typically have a "
"shorter development/debug cycle than compiled ones, though their programs "
"generally also run more slowly.  See also :term:`interactive`."
msgstr ""
"Python はインタプリタ形式の言語であり、コンパイラ言語の対極に位置します。 (バ"
"イトコードコンパイラがあるために、この区別は曖昧ですが。) ここでのインタプリ"
"タ言語とは、ソースコードのファイルを、まず実行可能形式にしてから実行させると"
"いった操作なしに、直接実行できることを意味します。インタプリタ形式の言語は通"
"常、コンパイラ形式の言語よりも開発／デバッグのサイクルは短いものの、プログラ"
"ムの実行は一般に遅いです。 :term:`対話的 <interactive>` も参照してください。"

#: ../../glossary.rst:841
msgid "interpreter shutdown"
msgstr "interpreter shutdown"

msgid ""
"When asked to shut down, the Python interpreter enters a special phase where "
"it gradually releases all allocated resources, such as modules and various "
"critical internal structures.  It also makes several calls to the :term:"
"`garbage collector <garbage collection>`. This can trigger the execution of "
"code in user-defined destructors or weakref callbacks. Code executed during "
"the shutdown phase can encounter various exceptions as the resources it "
"relies on may not function anymore (common examples are library modules or "
"the warnings machinery)."
msgstr ""
"Python インタープリタは、シャットダウンを要求されると、モジュールや各種の重要"
"な内部構造など、割り当てられたすべてのリソースを段階的に解放する特別な段階に"
"入ります。\n"
"また、:term:`ガベージコレクタ <garbage collection>` を複数回呼び出します。\n"
"これにより、ユーザー定義のデストラクタや weakref コールバックのコードが実行さ"
"れることがあります。\n"
"シャットダウン段階で実行されるコードでは、依存するリソースがすでに機能しなく"
"なっている場合があるため（よくある例はライブラリモジュールや warnings の仕組"
"みです）、さまざまな例外が発生することがあります。"

#: ../../glossary.rst:852
msgid ""
"The main reason for interpreter shutdown is that the ``__main__`` module or "
"the script being run has finished executing."
msgstr ""
"インタープリタがシャットダウンする主な理由は ``__main__`` モジュールや実行さ"
"れていたスクリプトの実行が終了したことです。"

#: ../../glossary.rst:854
msgid "iterable"
msgstr "iterable"

msgid ""
"An object capable of returning its members one at a time. Examples of "
"iterables include all sequence types (such as :class:`list`, :class:`str`, "
"and :class:`tuple`) and some non-sequence types like :class:`dict`, :term:"
"`file objects <file object>`, and objects of any classes you define with an :"
"meth:`~object.__iter__` method or with a :meth:`~object.__getitem__` method "
"that implements :term:`sequence` semantics."
msgstr ""
"(イテラブル) 要素を一つずつ返すことができるオブジェクトです。\n"
"例として、すべてのシーケンス型（:class:`list`、:class:`str`、:class:`tuple` "
"など）や、:class:`dict`、:term:`ファイルオブジェクト <file object>` のような"
"一部のシーケンスでない型があります。\n"
"また、:meth:`~object.__iter__` メソッド、または :term:`シーケンス "
"<sequence>` の意味論を実装する :meth:`~object.__getitem__` メソッドを定義した"
"任意のクラスのオブジェクトも該当します。"

msgid ""
"Iterables can be used in a :keyword:`for` loop and in many other places "
"where a sequence is needed (:func:`zip`, :func:`map`, ...).  When an "
"iterable object is passed as an argument to the built-in function :func:"
"`iter`, it returns an iterator for the object.  This iterator is good for "
"one pass over the set of values.  When using iterables, it is usually not "
"necessary to call :func:`iter` or deal with iterator objects yourself.  The :"
"keyword:`for` statement does that automatically for you, creating a "
"temporary unnamed variable to hold the iterator for the duration of the "
"loop.  See also :term:`iterator`, :term:`sequence`, and :term:`generator`."
msgstr ""
"イテラブルは :keyword:`for` ループや、シーケンスを必要とするほかの多くの場面"
"（:func:`zip`、:func:`map` など）で使えます（訳注: ここでのシーケンスは、シー"
"ケンス型ではなく、単なる列という意味です）。\n"
"組み込み関数 :func:`iter` にイテラブルオブジェクトを引数として渡すと、そのオ"
"ブジェクトのイテレータが返されます。\n"
"このイテレータで、一連の値を一度だけ走査できます。\n"
"イテラブルを使う際には通常、:func:`iter` を呼び出したり、イテレータオブジェク"
"トを自分で扱ったりする必要はありません。\n"
":keyword:`for` 文が自動的にこれを行い、一時的な無名の変数を作成して、ループの"
"実行中にイテレータを保持します。\n"
":term:`イテレータ <iterator>`、:term:`シーケンス <sequence>`、:term:`ジェネ"
"レータ <generator>` も参照してください。"

#: ../../glossary.rst:874
msgid "iterator"
msgstr "iterator"

msgid ""
"An object representing a stream of data.  Repeated calls to the iterator's :"
"meth:`~iterator.__next__` method (or passing it to the built-in function :"
"func:`next`) return successive items in the stream.  When no more data are "
"available a :exc:`StopIteration` exception is raised instead.  At this "
"point, the iterator object is :term:`exhausted` and any further calls to "
"its :meth:`!__next__` method just raise :exc:`StopIteration` again.  "
"Iterators are required to have an :meth:`~iterator.__iter__` method that "
"returns the iterator object itself so every iterator is also iterable and "
"may be used in most places where other iterables are accepted.  One notable "
"exception is code which attempts multiple iteration passes.  A container "
"object (such as a :class:`list`) produces a fresh new iterator each time you "
"pass it to the :func:`iter` function or use it in a :keyword:`for` loop.  "
"Attempting this with an iterator will just return the same exhausted "
"iterator object used in the previous iteration pass, making it appear like "
"an empty container."
msgstr ""
"(イテレータ) データのストリームを表すオブジェクトです。\n"
"イテレータの :meth:`~iterator.__next__` メソッドを繰り返し呼び出すと（または"
"組み込み関数 :func:`next` に渡すと）、ストリーム内の要素が順に返されます。\n"
"それ以上データがない場合、代わりに :exc:`StopIteration` 例外が送出されま"
"す。\n"
"この時点でイテレータオブジェクトは :term:`枯渇した <exhausted>` 状態となり、"
"その後 :meth:`!__next__` メソッドを呼び出しても、再び :exc:`StopIteration` が"
"送出されるだけです。\n"
"イテレータには、自身を返す :meth:`~iterator.__iter__` メソッドが必要です。\n"
"したがって、すべてのイテレータはイテラブルでもあり、ほかのイテラブルを受け付"
"けるほとんどの場面で使えます。\n"
"主な例外は、複数回の反復を試みるコードです。\n"
"コンテナオブジェクト（:class:`list` など）は、:func:`iter` 関数に渡したり、:"
"keyword:`for` ループで使ったりするたびに、新しいイテレータを生成します。\n"
"イテレータでこれを試みても、前の反復で使ったものと同じ枯渇したイテレータオブ"
"ジェクトが返されるだけなので、空のコンテナのように見えます。"

#: ../../glossary.rst:891
msgid "More information can be found in :ref:`typeiter`."
msgstr "詳細な情報は :ref:`typeiter` にあります。"

msgid ""
"CPython does not consistently apply the requirement that an iterator define :"
"meth:`~iterator.__iter__`. And also please note that :term:`free-threaded "
"<free threading>` CPython does not guarantee :term:`thread-safe` behavior of "
"iterator operations."
msgstr ""
"CPython は、イテレータが :meth:`~iterator.__iter__` を定義するという要件を、"
"一貫して適用しているわけではありません。\n"
"また、:term:`フリースレッドの <free threading>` CPython は、イテレータ操作"
"の :term:`スレッドセーフな <thread-safe>` 動作を保証しない点にも注意してくだ"
"さい。"

#: ../../glossary.rst:900
msgid "key"
msgstr "キー"

msgid ""
"A value that identifies an entry in a :term:`mapping`. See also :term:"
"`subscript`."
msgstr ""
":term:`マッピング <mapping>` 内の項目を識別する値です。\n"
":term:`添字 <subscript>` も参照してください。"

#: ../../glossary.rst:904
msgid "key function"
msgstr "key function"

#: ../../glossary.rst:906
msgid ""
"A key function or collation function is a callable that returns a value used "
"for sorting or ordering.  For example, :func:`locale.strxfrm` is used to "
"produce a sort key that is aware of locale specific sort conventions."
msgstr ""
"(キー関数) キー関数、あるいは照合関数とは、ソートや順序比較のための値を返す呼"
"び出し可能オブジェクト(callable)です。例えば、 :func:`locale.strxfrm` をキー"
"関数に使えば、ロケール依存のソートの慣習にのっとったソートキーを返します。"

#: ../../glossary.rst:911
msgid ""
"A number of tools in Python accept key functions to control how elements are "
"ordered or grouped.  They include :func:`min`, :func:`max`, :func:`sorted`, :"
"meth:`list.sort`, :func:`heapq.merge`, :func:`heapq.nsmallest`, :func:`heapq."
"nlargest`, and :func:`itertools.groupby`."
msgstr ""
"Python の多くのツールはキー関数を受け取り要素の並び順やグループ化を管理しま"
"す。\n"
":func:`min`, :func:`max`, :func:`sorted`, :meth:`list.sort`, :func:`heapq."
"merge`, :func:`heapq.nsmallest`, :func:`heapq.nlargest`, :func:`itertools."
"groupby` 等があります。"

msgid ""
"There are several ways to create a key function.  For example. the :meth:"
"`str.casefold` method can serve as a key function for case insensitive "
"sorts.  Alternatively, a key function can be built from a :keyword:`lambda` "
"expression such as ``lambda r: (r[0], r[2])``.  Also, :func:`operator."
"attrgetter`, :func:`operator.itemgetter`, and :func:`operator.methodcaller` "
"are three key function constructors.  See the :ref:`Sorting HOW TO "
"<sortinghowto>` for examples of how to create and use key functions."
msgstr ""
"キー関数を作成する方法はいくつかあります。\n"
"たとえば、:meth:`str.casefold` メソッドは、大文字と小文字を区別しないソートの"
"キー関数として使えます。\n"
"また、``lambda r: (r[0], r[2])`` のような :keyword:`lambda` 式からキー関数を"
"作成することもできます。\n"
"さらに、:func:`operator.attrgetter`、:func:`operator.itemgetter`、:func:"
"`operator.methodcaller` という三つのキー関数のコンストラクタがあります。\n"
"キー関数の作成と使用の例については、:ref:`ソート HOWTO <sortinghowto>` を参照"
"してください。"

#: ../../glossary.rst:924
msgid "keyword argument"
msgstr "keyword argument"

#: ../../glossary.rst:926 ../../glossary.rst:1313
msgid "See :term:`argument`."
msgstr ":term:`実引数 <argument>` を参照してください。"

#: ../../glossary.rst:927
msgid "lambda"
msgstr "lambda"

#: ../../glossary.rst:929
msgid ""
"An anonymous inline function consisting of a single :term:`expression` which "
"is evaluated when the function is called.  The syntax to create a lambda "
"function is ``lambda [parameters]: expression``"
msgstr ""
"(ラムダ) 無名のインライン関数で、関数が呼び出されたときに評価される 1 つの :"
"term:`式 <expression>` を含みます。ラムダ関数を作る構文は ``lambda "
"[parameters]: expression`` です。"

#: ../../glossary.rst:932
msgid "LBYL"
msgstr "LBYL"

#: ../../glossary.rst:934
msgid ""
"Look before you leap.  This coding style explicitly tests for pre-conditions "
"before making calls or lookups.  This style contrasts with the :term:`EAFP` "
"approach and is characterized by the presence of many :keyword:`if` "
"statements."
msgstr ""
"「ころばぬ先の杖 (look before you leap)」 の略です。このコーディングスタイル"
"では、呼び出しや検索を行う前に、明示的に前提条件 (pre-condition) 判定を行いま"
"す。 :term:`EAFP` アプローチと対照的で、 :keyword:`if` 文がたくさん使われるの"
"が特徴的です。"

msgid ""
"In a multi-threaded environment, the LBYL approach can risk introducing a :"
"term:`race condition` between \"the looking\" and \"the leaping\".  For "
"example, the code, ``if key in mapping: return mapping[key]`` can fail if "
"another thread removes *key* from *mapping* after the test, but before the "
"lookup. This issue can be solved with :term:`locks <lock>` or by using the :"
"term:`EAFP` approach.  See also :term:`thread-safe`."
msgstr ""
"マルチスレッド環境では、LBYL のアプローチは「確認」と「実行」の間に :term:`競"
"合状態 <race condition>` を生じさせる危険があります。\n"
"たとえば、``if key in mapping: return mapping[key]`` というコードでは、判定の"
"後、検索する前に、別のスレッドが *mapping* から *key* を削除すると、失敗する"
"ことがあります。\n"
"この問題は、:term:`ロック <lock>` または :term:`EAFP` のアプローチを使うと解"
"決できます。\n"
":term:`スレッドセーフ <thread-safe>` も参照してください。"

msgid "lexical analyzer"
msgstr "lexical analyzer"

msgid "Formal name for the *tokenizer*; see :term:`token`."
msgstr ""
"(字句解析器) *トークナイザ* の正式な名称です。\n"
":term:`トークン <token>` を参照してください。"

#: ../../glossary.rst:949
msgid "list"
msgstr "list"

msgid ""
"A built-in Python :term:`sequence`.  Despite its name it is more akin to an "
"array in other languages than to a linked list since access to elements is "
"*O*\\ (1).  See :ref:`time-complexity`."
msgstr ""
"Python の組み込み :term:`シーケンス <sequence>` です。\n"
"要素へのアクセスが *O*\\ (1) であるため、名前とは異なり、連結リストよりも、ほ"
"かの言語の配列に似ています。\n"
":ref:`time-complexity` を参照してください。"

#: ../../glossary.rst:954
msgid "list comprehension"
msgstr "list comprehension"

msgid ""
"A compact way to process all or part of the elements in a sequence and "
"return a list with the results.  ``result = ['{:#04x}'.format(x) for x in "
"range(256) if x % 2 == 0]`` generates a list of strings containing even hex "
"numbers (0x..) in the range from 0 to 255. The :keyword:`if` clause is "
"optional.  If omitted, all elements in ``range(256)`` are processed."
msgstr ""
"(リスト内包表記) シーケンス中の全てあるいは一部の要素を処理して、その結果から"
"なるリストを返す、コンパクトな方法です。 ``result = ['{:#04x}'.format(x) for "
"x in range(256) if x % 2 == 0]`` とすると、 0 から 255 までの偶数を 16進数表"
"記 (0x..) した文字列からなるリストを生成します。 :keyword:`if` 節はオプション"
"です。 ``if`` 節がない場合、 ``range(256)`` の全ての要素が処理されます。"

msgid "lock"
msgstr "lock"

msgid ""
"A :term:`synchronization primitive` that allows only one thread at a time to "
"access a shared resource.  A thread must acquire a lock before accessing the "
"protected resource and release it afterward.  If a thread attempts to "
"acquire a lock that is already held by another thread, it will block until "
"the lock becomes available.  Python's :mod:`threading` module provides :"
"class:`~threading.Lock` (a basic lock) and :class:`~threading.RLock` (a :"
"term:`reentrant` lock).  Locks are used to prevent :term:`race conditions "
"<race condition>` and ensure :term:`thread-safe` access to shared data.  "
"Alternative design patterns to locks exist such as queues, producer/consumer "
"patterns, and thread-local state. See also :term:`deadlock`, and :term:"
"`reentrant`."
msgstr ""
"(ロック) 一度に一つのスレッドだけが共有リソースにアクセスできるようにする :"
"term:`同期プリミティブ <synchronization primitive>` です。\n"
"スレッドは、保護されたリソースにアクセスする前にロックを取得し、アクセス後に"
"解放しなければなりません。\n"
"ほかのスレッドがすでに保持しているロックを取得しようとすると、ロックが利用可"
"能になるまでブロックします。\n"
"Python の :mod:`threading` モジュールは、:class:`~threading.Lock`（基本的な"
"ロック）と :class:`~threading.RLock`（:term:`再入可能な <reentrant>` ロック）"
"を提供します。\n"
"ロックは、:term:`競合状態 <race condition>` を防ぎ、共有データへの :term:`ス"
"レッドセーフな <thread-safe>` アクセスを保証するために使われます。\n"
"ロックの代わりに使える設計パターンとして、キュー、生産者と消費者のパターン、"
"スレッドローカルな状態などがあります。\n"
":term:`デッドロック <deadlock>` と :term:`再入可能 <reentrant>` も参照してく"
"ださい。"

msgid "lock-free"
msgstr "lock-free"

msgid ""
"An operation that does not acquire any :term:`lock` and uses atomic CPU "
"instructions to ensure correctness. Lock-free operations can execute "
"concurrently without blocking each other and cannot be blocked by operations "
"that hold locks. In :term:`free-threaded <free threading>` Python, built-in "
"types like :class:`dict` and :class:`list` provide lock-free read "
"operations, which means other threads may observe intermediate states during "
"multi-step modifications even when those modifications hold the :term:`per-"
"object lock`."
msgstr ""
"(ロックフリー) :term:`ロック <lock>` を取得せず、CPU のアトミック命令を使って"
"正しさを保証する操作です。\n"
"ロックフリーな操作は、互いをブロックせずに並行して実行でき、ロックを保持する"
"操作によってブロックされることもありません。\n"
":term:`フリースレッドの <free threading>` Python では、:class:`dict` や :"
"class:`list` のような組み込み型がロックフリーな読み取り操作を提供します。\n"
"そのため、複数のステップからなる変更が :term:`オブジェクトごとのロック <per-"
"object lock>` を保持していても、ほかのスレッドから途中の状態が観測されること"
"があります。"

#: ../../glossary.rst:985
msgid "loader"
msgstr "loader"

msgid ""
"An object that loads a module. It must define the :meth:`!exec_module` and :"
"meth:`!create_module` methods to implement the :class:`~importlib.abc."
"Loader` interface. A loader is typically returned by a :term:`finder`. See "
"also:"
msgstr ""
"(ローダー) モジュールをロードするオブジェクトです。\n"
":class:`~importlib.abc.Loader` インターフェースを実装するには、:meth:`!"
"exec_module` メソッドと :meth:`!create_module` メソッドを定義しなければなりま"
"せん。\n"
"ローダーは通常、:term:`ファインダ <finder>` から返されます。\n"
"次の項目も参照してください:"

msgid ":ref:`finders-and-loaders`"
msgstr ":ref:`finders-and-loaders`"

msgid ":class:`importlib.abc.Loader`"
msgstr ":class:`importlib.abc.Loader`"

#: ../../glossary.rst:995
msgid ":pep:`302`"
msgstr ":pep:`302`"

#: ../../glossary.rst:996
msgid "locale encoding"
msgstr "ロケールエンコーディング"

msgid ""
"On Unix, it is the encoding of the LC_CTYPE locale. It can be set with :func:"
"`locale.setlocale(locale.LC_CTYPE, new_locale) <locale.setlocale>`."
msgstr ""
"Unix では、LC_CTYPE ロケールのエンコーディングです。\n"
":func:`locale.setlocale(locale.LC_CTYPE, new_locale) <locale.setlocale>` で設"
"定できます。"

msgid "On Windows, it is the ANSI code page (ex: ``\"cp1252\"``)."
msgstr "Windows では、ANSI コードページ（例: ``\"cp1252\"``）です。"

msgid ""
"On Android and VxWorks, Python uses ``\"utf-8\"`` as the locale encoding."
msgstr ""
"Android と VxWorks では、Python はロケールエンコーディングとして "
"``\"utf-8\"`` を使用します。"

msgid ":func:`locale.getencoding` can be used to get the locale encoding."
msgstr ""
":func:`locale.getencoding` を使うと、ロケールエンコーディングを取得できます。"

msgid "See also the :term:`filesystem encoding and error handler`."
msgstr ""
":term:`ファイルシステムのエンコーディングとエラーハンドラ <filesystem "
"encoding and error handler>` も参照してください。"

#: ../../glossary.rst:1008
msgid "magic method"
msgstr "magic method"

#: ../../glossary.rst:1012
msgid "An informal synonym for :term:`special method`."
msgstr ":term:`special method` のくだけた同義語です。"

#: ../../glossary.rst:1013
msgid "mapping"
msgstr "mapping"

#: ../../glossary.rst:1015
msgid ""
"A container object that supports arbitrary key lookups and implements the "
"methods specified in the :class:`collections.abc.Mapping` or :class:"
"`collections.abc.MutableMapping` :ref:`abstract base classes <collections-"
"abstract-base-classes>`.  Examples include :class:`dict`, :class:"
"`collections.defaultdict`, :class:`collections.OrderedDict` and :class:"
"`collections.Counter`."
msgstr ""
"(マッピング) 任意のキー探索をサポートしていて、 :class:`collections.abc."
"Mapping` か :class:`collections.abc.MutableMapping` の :ref:`抽象基底クラス "
"<collections-abstract-base-classes>` で指定されたメソッドを実装しているコンテ"
"ナオブジェクトです。例えば、 :class:`dict`, :class:`collections."
"defaultdict`, :class:`collections.OrderedDict`, :class:`collections.Counter` "
"などです。"

#: ../../glossary.rst:1021
msgid "meta path finder"
msgstr "meta path finder"

#: ../../glossary.rst:1023
msgid ""
"A :term:`finder` returned by a search of :data:`sys.meta_path`.  Meta path "
"finders are related to, but different from :term:`path entry finders <path "
"entry finder>`."
msgstr ""
":data:`sys.meta_path` を検索して得られた :term:`finder`.\n"
"meta path finder は :term:`path entry finder` と関係はありますが、別物です。"

#: ../../glossary.rst:1027
msgid ""
"See :class:`importlib.abc.MetaPathFinder` for the methods that meta path "
"finders implement."
msgstr ""
"meta path finder が実装するメソッドについては :class:`importlib.abc."
"MetaPathFinder` を参照してください。"

#: ../../glossary.rst:1029
msgid "metaclass"
msgstr "metaclass"

#: ../../glossary.rst:1031
msgid ""
"The class of a class.  Class definitions create a class name, a class "
"dictionary, and a list of base classes.  The metaclass is responsible for "
"taking those three arguments and creating the class.  Most object oriented "
"programming languages provide a default implementation.  What makes Python "
"special is that it is possible to create custom metaclasses.  Most users "
"never need this tool, but when the need arises, metaclasses can provide "
"powerful, elegant solutions.  They have been used for logging attribute "
"access, adding thread-safety, tracking object creation, implementing "
"singletons, and many other tasks."
msgstr ""
"(メタクラス) クラスのクラスです。クラス定義は、クラス名、クラスの辞書と、基底"
"クラスのリストを作ります。メタクラスは、それら 3 つを引数として受け取り、クラ"
"スを作る責任を負います。ほとんどのオブジェクト指向言語は(訳注:メタクラスの)デ"
"フォルトの実装を提供しています。Python が特別なのはカスタムのメタクラスを作成"
"できる点です。ほとんどのユーザーに取って、メタクラスは全く必要のないもので"
"す。しかし、一部の場面では、メタクラスは強力でエレガントな方法を提供します。"
"たとえば属性アクセスのログを取ったり、スレッドセーフ性を追加したり、オブジェ"
"クトの生成を追跡したり、シングルトンを実装するなど、多くの場面で利用されま"
"す。"

#: ../../glossary.rst:1041
msgid "More information can be found in :ref:`metaclasses`."
msgstr "詳細は :ref:`metaclasses` を参照してください。"

#: ../../glossary.rst:1010 ../../glossary.rst:1042 ../../glossary.rst:1496
msgid "method"
msgstr "メソッド"

#: ../../glossary.rst:1044
msgid ""
"A function which is defined inside a class body.  If called as an attribute "
"of an instance of that class, the method will get the instance object as its "
"first :term:`argument` (which is usually called ``self``). See :term:"
"`function` and :term:`nested scope`."
msgstr ""
"(メソッド) クラス本体の中で定義された関数。そのクラスのインスタンスの属性とし"
"て呼び出された場合、メソッドはインスタンスオブジェクトを第一 :term:`引数 "
"<argument>` として受け取ります (この第一引数は通常 ``self`` と呼ばれます)。 :"
"term:`関数 <function>` と :term:`ネストされたスコープ <nested scope>` も参照"
"してください。"

#: ../../glossary.rst:1048
msgid "method resolution order"
msgstr "method resolution order"

msgid ""
"Method Resolution Order is the order in which base classes are searched for "
"a member during lookup. See :ref:`python_2.3_mro` for details of the "
"algorithm used by the Python interpreter since the 2.3 release."
msgstr ""
"(メソッド解決順序) メンバーの検索時に基底クラスを調べる順序です。\n"
"Python インタープリタがリリース 2.3 以降で使っているアルゴリズムの詳細につい"
"ては、:ref:`python_2.3_mro` を参照してください。"

#: ../../glossary.rst:1053
msgid "module"
msgstr "module"

#: ../../glossary.rst:1055
msgid ""
"An object that serves as an organizational unit of Python code.  Modules "
"have a namespace containing arbitrary Python objects.  Modules are loaded "
"into Python by the process of :term:`importing`."
msgstr ""
"(モジュール) Python コードの組織単位としてはたらくオブジェクトです。モジュー"
"ルは任意の Python オブジェクトを含む名前空間を持ちます。モジュールは :term:"
"`importing` の処理によって Python に読み込まれます。"

#: ../../glossary.rst:1059
msgid "See also :term:`package`."
msgstr ":term:`パッケージ <package>` を参照してください。"

#: ../../glossary.rst:1060
msgid "module spec"
msgstr "module spec"

#: ../../glossary.rst:1062
msgid ""
"A namespace containing the import-related information used to load a module. "
"An instance of :class:`importlib.machinery.ModuleSpec`."
msgstr ""
"モジュールをロードするのに使われるインポート関連の情報を含む名前空間です。\n"
":class:`importlib.machinery.ModuleSpec` のインスタンスです。"

msgid "See also :ref:`module-specs`."
msgstr ":ref:`module-specs` も参照してください。"

#: ../../glossary.rst:1066
msgid "MRO"
msgstr "MRO"

#: ../../glossary.rst:1068
msgid "See :term:`method resolution order`."
msgstr ":term:`method resolution order` を参照してください。"

#: ../../glossary.rst:1069
msgid "mutable"
msgstr "mutable"

msgid ""
"An :term:`object` with state that is allowed to change during the course of "
"the program.  In multi-threaded programs, mutable objects that are shared "
"between threads require careful synchronization to avoid :term:`race "
"conditions <race condition>`.  See also :term:`immutable`, :term:`thread-"
"safe`, and :term:`concurrent modification`."
msgstr ""
"(可変) プログラムの実行中に状態を変更できる :term:`オブジェクト <object>` で"
"す。\n"
"マルチスレッドプログラムでは、スレッド間で共有する可変オブジェクトには、:"
"term:`競合状態 <race condition>` を避けるための慎重な同期が必要です。\n"
":term:`不変 <immutable>`、:term:`スレッドセーフ <thread-safe>`、:term:`並行変"
"更 <concurrent modification>` も参照してください。"

#: ../../glossary.rst:1076
msgid "named tuple"
msgstr "named tuple"

#: ../../glossary.rst:1078
msgid ""
"The term \"named tuple\" applies to any type or class that inherits from "
"tuple and whose indexable elements are also accessible using named "
"attributes.  The type or class may have other features as well."
msgstr ""
"\"名前付きタプル\" という用語は、タプルを継承していて、インデックスが付く要素"
"に対し属性を使ってのアクセスもできる任意の型やクラスに応用されています。\n"
"その型やクラスは他の機能も持っていることもあります。"

#: ../../glossary.rst:1082
msgid ""
"Several built-in types are named tuples, including the values returned by :"
"func:`time.localtime` and :func:`os.stat`.  Another example is :data:`sys."
"float_info`::"
msgstr ""
":func:`time.localtime` や :func:`os.stat` の返り値を含むいくつかの組み込み型"
"は名前付きタプルです。\n"
"他の例は :data:`sys.float_info` です::"

msgid ""
">>> sys.float_info[1]                   # indexed access\n"
"1024\n"
">>> sys.float_info.max_exp              # named field access\n"
"1024\n"
">>> isinstance(sys.float_info, tuple)   # kind of tuple\n"
"True"
msgstr ""
">>> sys.float_info[1]                   # インデックスによるアクセス\n"
"1024\n"
">>> sys.float_info.max_exp              # 名前付きフィールドによるアクセス\n"
"1024\n"
">>> isinstance(sys.float_info, tuple)   # タプルの一種\n"
"True"

msgid ""
"Some named tuples are built-in types (such as the above examples). "
"Alternatively, a named tuple can be created from a regular class definition "
"that inherits from :class:`tuple` and that defines named fields.  Such a "
"class can be written by hand, or it can be created by inheriting :class:"
"`typing.NamedTuple`, or with the factory function :func:`collections."
"namedtuple`.  The latter techniques also add some extra methods that may not "
"be found in hand-written or built-in named tuples."
msgstr ""
"名前付きタプルの一部は、上の例のような組み込み型です。\n"
"また、:class:`tuple` を継承して名前付きフィールドを定義する、通常のクラス定義"
"からも名前付きタプルを作成できます。\n"
"このようなクラスは手作業で書くことも、:class:`typing.NamedTuple` を継承した"
"り、ファクトリ関数 :func:`collections.namedtuple` を使ったりして作成すること"
"もできます。\n"
"後者の方法では、手書きの名前付きタプルや組み込みの名前付きタプルにはない場合"
"がある、いくつかの追加メソッドも用意されます。"

#: ../../glossary.rst:1101
msgid "namespace"
msgstr "namespace"

#: ../../glossary.rst:1103
msgid ""
"The place where a variable is stored.  Namespaces are implemented as "
"dictionaries.  There are the local, global and built-in namespaces as well "
"as nested namespaces in objects (in methods).  Namespaces support modularity "
"by preventing naming conflicts.  For instance, the functions :func:`builtins."
"open <.open>` and :func:`os.open` are distinguished by their namespaces.  "
"Namespaces also aid readability and maintainability by making it clear which "
"module implements a function.  For instance, writing :func:`random.seed` or :"
"func:`itertools.islice` makes it clear that those functions are implemented "
"by the :mod:`random` and :mod:`itertools` modules, respectively."
msgstr ""
"(名前空間) 変数が格納される場所です。名前空間は辞書として実装されます。名前空"
"間にはオブジェクトの (メソッドの) 入れ子になったものだけでなく、局所的なも"
"の、大域的なもの、そして組み込みのものがあります。名前空間は名前の衝突を防ぐ"
"ことによってモジュール性をサポートする。例えば関数 :func:`builtins.open <."
"open>` と :func:`os.open` は名前空間で区別されています。また、どのモジュール"
"が関数を実装しているか明示することによって名前空間は可読性と保守性を支援しま"
"す。例えば、:func:`random.seed` や :func:`itertools.islice` と書くと、それぞ"
"れモジュール :mod:`random` や :mod:`itertools` で実装されていることが明らかで"
"す。"

#: ../../glossary.rst:1113
msgid "namespace package"
msgstr "namespace package"

msgid ""
"A :term:`package` which serves only as a container for subpackages. "
"Namespace packages may have no physical representation, and specifically are "
"not like a :term:`regular package` because they have no ``__init__.py`` file."
msgstr ""
"サブパッケージのコンテナとしてだけ機能する :term:`パッケージ <package>` で"
"す。\n"
"名前空間パッケージは物理的な実体を持たない場合があり、特に ``__init__.py`` "
"ファイルを持たない点で :term:`通常のパッケージ <regular package>` と異なりま"
"す。"

msgid ""
"Namespace packages allow several individually installable packages to have a "
"common parent package. Otherwise, it is recommended to use a :term:`regular "
"package`."
msgstr ""
"名前空間パッケージを使うと、個別にインストール可能な複数のパッケージが、共通"
"の親パッケージを持てます。\n"
"それ以外の場合は、:term:`通常のパッケージ <regular package>` の使用を推奨しま"
"す。"

msgid ""
"For more information, see :pep:`420` and :ref:`reference-namespace-package`."
msgstr ""
"詳しくは、:pep:`420` と :ref:`reference-namespace-package` を参照してくださ"
"い。"

#: ../../glossary.rst:1125
msgid "See also :term:`module`."
msgstr ":term:`module` を参照してください。"

msgid "native code"
msgstr "native code"

msgid ""
"Code that is compiled to machine instructions and runs directly on the "
"processor, as opposed to code that is interpreted or runs in a virtual "
"machine.  In the context of Python, native code typically refers to C, C++, "
"Rust or Fortran code in :term:`extension modules <extension module>` that "
"can be called from Python.  See also :term:`extension module`."
msgstr ""
"(ネイティブコード) 機械語命令にコンパイルされ、プロセッサ上で直接実行される"
"コードです。\n"
"インタープリタで解釈されたり、仮想マシン内で実行されたりするコードと対比され"
"ます。\n"
"Python の文脈では、ネイティブコードは通常、Python から呼び出せる :term:`拡張"
"モジュール <extension module>` 内の C、C++、Rust、Fortran のコードを指しま"
"す。\n"
":term:`拡張モジュール <extension module>` も参照してください。"

#: ../../glossary.rst:1133
msgid "nested scope"
msgstr "nested scope"

#: ../../glossary.rst:1135
msgid ""
"The ability to refer to a variable in an enclosing definition.  For "
"instance, a function defined inside another function can refer to variables "
"in the outer function.  Note that nested scopes by default work only for "
"reference and not for assignment.  Local variables both read and write in "
"the innermost scope.  Likewise, global variables read and write to the "
"global namespace.  The :keyword:`nonlocal` allows writing to outer scopes."
msgstr ""
"(ネストされたスコープ) 外側で定義されている変数を参照する機能です。例えば、あ"
"る関数が別の関数の中で定義されている場合、内側の関数は外側の関数中の変数を参"
"照できます。ネストされたスコープはデフォルトでは変数の参照だけができ、変数の"
"代入はできないので注意してください。ローカル変数は、最も内側のスコープで変数"
"を読み書きします。同様に、グローバル変数を使うとグローバル名前空間の値を読み"
"書きします。 :keyword:`nonlocal` で外側の変数に書き込めます。"

#: ../../glossary.rst:1142
msgid "new-style class"
msgstr "new-style class"

msgid ""
"Old name for the flavor of classes now used for all class objects.  In "
"earlier Python versions, only new-style classes could use Python's newer, "
"versatile features like :attr:`~object.__slots__`, descriptors, properties, :"
"meth:`~object.__getattribute__`, class methods, and static methods."
msgstr ""
"(新スタイルクラス) 現在すべてのクラスオブジェクトに使われている種類のクラス"
"の、以前の名称です。\n"
"古いバージョンの Python では、:attr:`~object.__slots__`、デスクリプタ、プロパ"
"ティ、:meth:`~object.__getattribute__`、クラスメソッド、静的メソッドといっ"
"た、Python の新しく多様な機能を使えるのは新スタイルクラスだけでした。"

msgid "non-deterministic"
msgstr "non-deterministic"

msgid ""
"Behavior where the outcome of a program can vary between executions with the "
"same inputs.  In multi-threaded programs, non-deterministic behavior often "
"results from :term:`race conditions <race condition>` where the relative "
"timing or interleaving of threads affects the result. Proper synchronization "
"using :term:`locks <lock>` and other :term:`synchronization primitives "
"<synchronization primitive>` helps ensure deterministic behavior."
msgstr ""
"(非決定的) 同じ入力でも、実行ごとにプログラムの結果が変わり得る動作です。\n"
"マルチスレッドプログラムでは、スレッドの相対的なタイミングや実行の入り交じり"
"方が結果に影響する :term:`競合状態 <race condition>` が原因で、非決定的な動作"
"になることがよくあります。\n"
":term:`ロック <lock>` やその他の :term:`同期プリミティブ <synchronization "
"primitive>` による適切な同期は、決定的な動作の保証に役立ちます。"

#: ../../glossary.rst:1158
msgid "object"
msgstr "object"

#: ../../glossary.rst:1160
msgid ""
"Any data with state (attributes or value) and defined behavior (methods).  "
"Also the ultimate base class of any :term:`new-style class`."
msgstr ""
"(オブジェクト) 状態 (属性や値) と定義された振る舞い (メソッド) をもつ全ての"
"データ。もしくは、全ての :term:`新スタイルクラス <new-style class>` の究極の"
"基底クラスのこと。"

msgid "optimized scope"
msgstr "optimized scope"

msgid ""
"A scope where target local variable names are reliably known to the compiler "
"when the code is compiled, allowing optimization of read and write access to "
"these names. The local namespaces for functions, generators, coroutines, "
"comprehensions, and generator expressions are optimized in this fashion. "
"Note: most interpreter optimizations are applied to all scopes, only those "
"relying on a known set of local and nonlocal variable names are restricted "
"to optimized scopes."
msgstr ""
"(最適化されたスコープ) コードのコンパイル時に、対象となるローカル変数名をコン"
"パイラが確実に把握できるスコープです。\n"
"これにより、その名前への読み書きを最適化できます。\n"
"関数、ジェネレータ、コルーチン、内包表記、ジェネレータ式のローカル名前空間"
"は、この方法で最適化されます。\n"
"注意: インタープリタの最適化の大部分は、すべてのスコープに適用されます。\n"
"最適化されたスコープだけに適用されるのは、ローカル変数名と非ローカル変数名の"
"集合が既知であることに依存する最適化だけです。"

msgid "optional module"
msgstr "optional module"

msgid ""
"An :term:`extension module` that is part of the :term:`standard library`, "
"but may be absent in some builds of :term:`CPython`, usually due to missing "
"third-party libraries or because the module is not available for a given "
"platform."
msgstr ""
"(オプションモジュール) :term:`標準ライブラリ <standard library>` の一部であ"
"る :term:`拡張モジュール <extension module>` のうち、一部の :term:`CPython` "
"ビルドでは含まれないことがあるものです。\n"
"通常は、サードパーティライブラリが不足しているか、そのプラットフォームでモ"
"ジュールを利用できないことが理由です。"

msgid ""
"See :ref:`optional-module-requirements` for a list of optional modules that "
"require third-party libraries."
msgstr ""
"サードパーティライブラリを必要とするオプションモジュールの一覧は、:ref:"
"`optional-module-requirements` を参照してください。"

#: ../../glossary.rst:1181
msgid "package"
msgstr "package"

msgid ""
"A Python :term:`module` which can contain submodules or recursively, "
"subpackages.  Technically, a package is a Python module with a ``__path__`` "
"attribute."
msgstr ""
"(パッケージ) サブモジュールや、再帰的にサブパッケージを含むことができる "
"Python の :term:`モジュール <module>` です。\n"
"厳密には、パッケージは ``__path__`` 属性を持つ Python モジュールです。"

#: ../../glossary.rst:1187
msgid "See also :term:`regular package` and :term:`namespace package`."
msgstr ""
":term:`regular package` と :term:`namespace package` を参照してください。"

msgid "parallelism"
msgstr "parallelism"

msgid ""
"Executing multiple operations at the same time (e.g. on multiple CPU "
"cores).  In Python builds with the :term:`global interpreter lock (GIL) "
"<global interpreter lock>`, only one thread runs Python bytecode at a time, "
"so taking advantage of multiple CPU cores typically involves multiple "
"processes (e.g. :mod:`multiprocessing`) or native extensions that release "
"the GIL. In :term:`free-threaded <free threading>` Python, multiple Python "
"threads can run Python code simultaneously on different cores."
msgstr ""
"(並列性) 複数の操作を（たとえば複数の CPU コアで）同時に実行することです。\n"
":term:`グローバルインタープリタロック（GIL） <global interpreter lock>` があ"
"る Python ビルドでは、一度に一つのスレッドだけが Python バイトコードを実行し"
"ます。\n"
"そのため、複数の CPU コアを活用するには通常、複数のプロセス（:mod:"
"`multiprocessing` など）や、GIL を解放するネイティブ拡張を使います。\n"
":term:`フリースレッドの <free threading>` Python では、複数の Python スレッド"
"が異なるコアで Python コードを同時に実行できます。"

#: ../../glossary.rst:1198
msgid "parameter"
msgstr "parameter"

msgid ""
"A named entity in a :term:`function` (or method) definition that specifies "
"an :term:`argument` (or in some cases, arguments) that the function can "
"accept.  There are five kinds of parameter:"
msgstr ""
"(仮引数) 名前付の実体で :term:`関数 <function>` (やメソッド ) の定義において"
"関数が受ける :term:`実引数 <argument>` を指定します。仮引数には5種類あります:"

#: ../../glossary.rst:1204
msgid ""
":dfn:`positional-or-keyword`: specifies an argument that can be passed "
"either :term:`positionally <argument>` or as a :term:`keyword argument "
"<argument>`.  This is the default kind of parameter, for example *foo* and "
"*bar* in the following::"
msgstr ""
":dfn:`位置またはキーワード`: :term:`位置 <argument>` であるいは :term:`キー"
"ワード引数 <argument>` として渡すことができる引数を指定します。\n"
"これはたとえば以下の *foo* や *bar* のように、デフォルトの仮引数の種類です::"

#: ../../glossary.rst:1209
msgid "def func(foo, bar=None): ..."
msgstr "def func(foo, bar=None): ..."

msgid ""
":dfn:`positional-only`: specifies an argument that can be supplied only by "
"position. Positional-only parameters can be defined by including a ``/`` "
"character in the parameter list of the function definition after them, for "
"example *posonly1* and *posonly2* in the following::"
msgstr ""
":dfn:`位置専用`: 位置によってのみ与えられる引数を指定します。位置専用の引数は"
"関数定義の引数のリストの中でそれらの後ろに ``/`` を含めることで定義できます。"
"例えば下記の *posonly1* と *posonly2* は位置専用引数になります::"

#: ../../glossary.rst:1218
msgid "def func(posonly1, posonly2, /, positional_or_keyword): ..."
msgstr "def func(posonly1, posonly2, /, positional_or_keyword): ..."

#: ../../glossary.rst:1222
msgid ""
":dfn:`keyword-only`: specifies an argument that can be supplied only by "
"keyword.  Keyword-only parameters can be defined by including a single var-"
"positional parameter or bare ``*`` in the parameter list of the function "
"definition before them, for example *kw_only1* and *kw_only2* in the "
"following::"
msgstr ""
":dfn:`キーワード専用`: キーワードによってのみ与えられる引数を指定します。キー"
"ワード専用の引数を定義できる場所は、例えば以下の *kw_only1* や *kw_only2* の"
"ように、関数定義の仮引数リストに含めた可変長位置引数または裸の ``*`` の後で"
"す::"

msgid "def func(arg, *, kw_only1, kw_only2): ..."
msgstr "def func(arg, *, kw_only1, kw_only2): ..."

#: ../../glossary.rst:1230
msgid ""
":dfn:`var-positional`: specifies that an arbitrary sequence of positional "
"arguments can be provided (in addition to any positional arguments already "
"accepted by other parameters).  Such a parameter can be defined by "
"prepending the parameter name with ``*``, for example *args* in the "
"following::"
msgstr ""
":dfn:`可変長位置`: (他の仮引数で既に受けられた任意の位置引数に加えて) 任意の"
"個数の位置引数が与えられることを指定します。このような仮引数は、以下の "
"*args* のように仮引数名の前に ``*`` をつけることで定義できます::"

msgid "def func(*args, **kwargs): ..."
msgstr "def func(*args, **kwargs): ..."

#: ../../glossary.rst:1238
msgid ""
":dfn:`var-keyword`: specifies that arbitrarily many keyword arguments can be "
"provided (in addition to any keyword arguments already accepted by other "
"parameters).  Such a parameter can be defined by prepending the parameter "
"name with ``**``, for example *kwargs* in the example above."
msgstr ""
":dfn:`可変長キーワード`: (他の仮引数で既に受けられた任意のキーワード引数に加"
"えて) 任意の個数のキーワード引数が与えられることを指定します。このような仮引"
"数は、上の例の *kwargs* のように仮引数名の前に ``**`` をつけることで定義でき"
"ます。"

#: ../../glossary.rst:1244
msgid ""
"Parameters can specify both optional and required arguments, as well as "
"default values for some optional arguments."
msgstr ""
"仮引数はオプションと必須の引数のどちらも指定でき、オプションの引数にはデフォ"
"ルト値も指定できます。"

msgid ""
"See also the :term:`argument` glossary entry, the FAQ question on :ref:`the "
"difference between arguments and parameters <faq-argument-vs-parameter>`, "
"the :class:`inspect.Parameter` class, the :ref:`function` section, and :pep:"
"`362`."
msgstr ""
"用語集の :term:`実引数 <argument>` の項目、FAQ の :ref:`実引数と仮引数の違い"
"は何ですか? <faq-argument-vs-parameter>`、:class:`inspect.Parameter` クラ"
"ス、:ref:`function` の節、および :pep:`362` も参照してください。"

msgid "per-object lock"
msgstr "per-object lock"

msgid ""
"A :term:`lock` associated with an individual object instance rather than a "
"global lock shared across all objects. In :term:`free-threaded <free "
"threading>` Python, built-in types like :class:`dict` and :class:`list` use "
"per-object locks to allow concurrent operations on different objects while "
"serializing operations on the same object. Operations that hold the per-"
"object lock prevent other locking operations on the same object from "
"proceeding, but do not block :term:`lock-free` operations."
msgstr ""
"(オブジェクトごとのロック) すべてのオブジェクトで共有されるグローバルなロック"
"ではなく、個別のオブジェクトインスタンスに関連付けられた :term:`ロック "
"<lock>` です。\n"
":term:`フリースレッドの <free threading>` Python では、:class:`dict` や :"
"class:`list` などの組み込み型はオブジェクトごとのロックを使い、同じオブジェク"
"トへの操作を直列化しながら、異なるオブジェクトへの操作を並行して実行できるよ"
"うにします。\n"
"オブジェクトごとのロックを保持する操作は、同じオブジェクトをロックするほかの"
"操作の進行を妨げますが、:term:`ロックフリーな <lock-free>` 操作はブロックしま"
"せん。"

#: ../../glossary.rst:1261
msgid "path entry"
msgstr "path entry"

#: ../../glossary.rst:1263
msgid ""
"A single location on the :term:`import path` which the :term:`path based "
"finder` consults to find modules for importing."
msgstr ""
":term:`path based finder` が import するモジュールを探す :term:`import path` "
"上の1つの場所です。"

#: ../../glossary.rst:1265
msgid "path entry finder"
msgstr "path entry finder"

#: ../../glossary.rst:1267
msgid ""
"A :term:`finder` returned by a callable on :data:`sys.path_hooks` (i.e. a :"
"term:`path entry hook`) which knows how to locate modules given a :term:"
"`path entry`."
msgstr ""
":data:`sys.path_hooks` にある callable (つまり :term:`path entry hook`) が返"
"した :term:`finder` です。与えられた :term:`path entry` にあるモジュールを見"
"つける方法を知っています。"

#: ../../glossary.rst:1271
msgid ""
"See :class:`importlib.abc.PathEntryFinder` for the methods that path entry "
"finders implement."
msgstr ""
"パスエントリーファインダが実装するメソッドについては :class:`importlib.abc."
"PathEntryFinder` を参照してください。"

#: ../../glossary.rst:1273
msgid "path entry hook"
msgstr "path entry hook"

msgid ""
"A callable on the :data:`sys.path_hooks` list which returns a :term:`path "
"entry finder` if it knows how to find modules on a specific :term:`path "
"entry`."
msgstr ""
":data:`sys.path_hooks` リスト内の呼び出し可能オブジェクトで、特定の :term:`パ"
"スエントリ <path entry>` 上でモジュールを見つける方法を知っている場合に、:"
"term:`パスエントリファインダ <path entry finder>` を返すものです。"

#: ../../glossary.rst:1278
msgid "path based finder"
msgstr "path based finder"

msgid ""
"One of the default :term:`meta path finders <meta path finder>` which "
"searches an :term:`import path` for modules."
msgstr ""
"モジュールを探すために :term:`インポートパス <import path>` を検索する、デ"
"フォルトの :term:`メタパスファインダ <meta path finder>` の一つです。"

#: ../../glossary.rst:1282
msgid "path-like object"
msgstr "path-like object"

#: ../../glossary.rst:1284
msgid ""
"An object representing a file system path. A path-like object is either a :"
"class:`str` or :class:`bytes` object representing a path, or an object "
"implementing the :class:`os.PathLike` protocol. An object that supports the :"
"class:`os.PathLike` protocol can be converted to a :class:`str` or :class:"
"`bytes` file system path by calling the :func:`os.fspath` function; :func:"
"`os.fsdecode` and :func:`os.fsencode` can be used to guarantee a :class:"
"`str` or :class:`bytes` result instead, respectively. Introduced by :pep:"
"`519`."
msgstr ""
"(path-like オブジェクト) ファイルシステムパスを表します。\n"
"path-like オブジェクトは、パスを表す :class:`str` オブジェクトや :class:"
"`bytes` オブジェクト、または :class:`os.PathLike` プロトコルを実装したオブ"
"ジェクトのどれかです。\n"
":class:`os.PathLike` プロトコルをサポートしているオブジェクトは :func:`os."
"fspath` を呼び出すことで :class:`str` または :class:`bytes` のファイルシステ"
"ムパスに変換できます。 :func:`os.fsdecode` と :func:`os.fsencode` はそれぞ"
"れ :class:`str` あるいは :class:`bytes` になるのを保証するのに使えます。\n"
":pep:`519` で導入されました。"

#: ../../glossary.rst:1292
msgid "PEP"
msgstr "PEP"

#: ../../glossary.rst:1294
msgid ""
"Python Enhancement Proposal. A PEP is a design document providing "
"information to the Python community, or describing a new feature for Python "
"or its processes or environment. PEPs should provide a concise technical "
"specification and a rationale for proposed features."
msgstr ""
"Python Enhancement Proposal。PEP は、Python コミュニティに対して情報を提供す"
"る、あるいは Python の新機能やその過程や環境について記述する設計文書です。\n"
"PEP は、機能についての簡潔な技術的仕様と提案する機能の論拠 (理論) を伝えるべ"
"きです。"

msgid ""
"PEPs are intended to be the primary mechanisms for proposing major new "
"features, for collecting community input on an issue, and for documenting "
"the design decisions that have gone into Python. The PEP author is "
"responsible for building consensus within the community and documenting "
"dissenting opinions."
msgstr ""
"PEP は、主要な新機能を提案し、ある問題に対するコミュニティの意見を集め、"
"Python に採用された設計上の決定を文書化するための、主要な仕組みとなることを意"
"図しています。\n"
"PEP の著者には、コミュニティ内で合意を形成し、反対意見を文書化する責任があり"
"ます。"

#: ../../glossary.rst:1306
msgid "See :pep:`1`."
msgstr ":pep:`1` を参照してください。"

#: ../../glossary.rst:1307
msgid "portion"
msgstr "portion"

#: ../../glossary.rst:1309
msgid ""
"A set of files in a single directory (possibly stored in a zip file) that "
"contribute to a namespace package, as defined in :pep:`420`."
msgstr ""
":pep:`420` で定義されている、namespace package に属する、複数のファイルが "
"(zipファイルに格納されている場合もある) 1つのディレクトリに格納されたもの。"

#: ../../glossary.rst:1311
msgid "positional argument"
msgstr "位置引数 (positional argument)"

#: ../../glossary.rst:1314
msgid "provisional API"
msgstr "provisional API"

#: ../../glossary.rst:1316
msgid ""
"A provisional API is one which has been deliberately excluded from the "
"standard library's backwards compatibility guarantees.  While major changes "
"to such interfaces are not expected, as long as they are marked provisional, "
"backwards incompatible changes (up to and including removal of the "
"interface) may occur if deemed necessary by core developers.  Such changes "
"will not be made gratuitously -- they will occur only if serious fundamental "
"flaws are uncovered that were missed prior to the inclusion of the API."
msgstr ""
"(暫定 API) 標準ライブラリの後方互換性保証から計画的に除外されたものです。その"
"ようなインターフェースへの大きな変更は、暫定であるとされている間は期待されて"
"いませんが、コア開発者によって必要とみなされれば、後方非互換な変更 (インター"
"フェースの削除まで含まれる) が行われえます。このような変更はむやみに行われる"
"ものではありません -- これは API を組み込む前には見落とされていた重大な欠陥が"
"露呈したときにのみ行われます。"

msgid ""
"Even for provisional APIs, backwards incompatible changes are seen as a "
"\"solution of last resort\" - every attempt will still be made to find a "
"backwards compatible resolution to any identified problems."
msgstr ""
"暫定 API であっても、後方互換性のない変更は「最終手段」とみなされます。\n"
"特定された問題に対しては、引き続き、後方互換性のある解決策を見つけるためにあ"
"らゆる努力を行います。"

#: ../../glossary.rst:1329
msgid ""
"This process allows the standard library to continue to evolve over time, "
"without locking in problematic design errors for extended periods of time.  "
"See :pep:`411` for more details."
msgstr ""
"このプロセスにより、標準ライブラリは問題となるデザインエラーに長い間閉じ込め"
"られることなく、時代を超えて進化を続けられます。詳細は :pep:`411` を参照して"
"ください。"

#: ../../glossary.rst:1332
msgid "provisional package"
msgstr "provisional package"

#: ../../glossary.rst:1334
msgid "See :term:`provisional API`."
msgstr ":term:`provisional API` を参照してください。"

#: ../../glossary.rst:1335
msgid "Python 3000"
msgstr "Python 3000"

#: ../../glossary.rst:1337
msgid ""
"Nickname for the Python 3.x release line (coined long ago when the release "
"of version 3 was something in the distant future.)  This is also abbreviated "
"\"Py3k\"."
msgstr ""
"Python 3.x リリースラインのニックネームです。(Python 3 が遠い将来の話だった頃"
"に作られた言葉です。) \"Py3k\" と略されることもあります。"

#: ../../glossary.rst:1340
msgid "Pythonic"
msgstr "Pythonic"

#: ../../glossary.rst:1342
msgid ""
"An idea or piece of code which closely follows the most common idioms of the "
"Python language, rather than implementing code using concepts common to "
"other languages.  For example, a common idiom in Python is to loop over all "
"elements of an iterable using a :keyword:`for` statement.  Many other "
"languages don't have this type of construct, so people unfamiliar with "
"Python sometimes use a numerical counter instead::"
msgstr ""
"他の言語で一般的な考え方で書かれたコードではなく、Python の特に一般的なイディ"
"オムに従った考え方やコード片。例えば、Python の一般的なイディオムでは :"
"keyword:`for` 文を使ってイテラブルのすべての要素に渡ってループします。他の多"
"くの言語にはこの仕組みはないので、Python に慣れていない人は代わりに数値のカウ"
"ンターを使うかもしれません::"

msgid ""
"for i in range(len(food)):\n"
"    print(food[i])"
msgstr ""
"for i in range(len(food)):\n"
"    print(food[i])"

#: ../../glossary.rst:1352
msgid "As opposed to the cleaner, Pythonic method::"
msgstr "これに対し、きれいな Pythonic な方法は::"

msgid ""
"for piece in food:\n"
"    print(piece)"
msgstr ""
"for piece in food:\n"
"    print(piece)"

#: ../../glossary.rst:1356
msgid "qualified name"
msgstr "qualified name"

#: ../../glossary.rst:1358
msgid ""
"A dotted name showing the \"path\" from a module's global scope to a class, "
"function or method defined in that module, as defined in :pep:`3155`.  For "
"top-level functions and classes, the qualified name is the same as the "
"object's name::"
msgstr ""
"(修飾名) モジュールのグローバルスコープから、そのモジュールで定義されたクラ"
"ス、関数、メソッドへの、 \"パス\" を表すドット名表記です。 :pep:`3155` で定義"
"されています。トップレベルの関数やクラスでは、修飾名はオブジェクトの名前と同"
"じです::"

msgid ""
">>> class C:\n"
"...     class D:\n"
"...         def meth(self):\n"
"...             pass\n"
"...\n"
">>> C.__qualname__\n"
"'C'\n"
">>> C.D.__qualname__\n"
"'C.D'\n"
">>> C.D.meth.__qualname__\n"
"'C.D.meth'"
msgstr ""
">>> class C:\n"
"...     class D:\n"
"...         def meth(self):\n"
"...             pass\n"
"...\n"
">>> C.__qualname__\n"
"'C'\n"
">>> C.D.__qualname__\n"
"'C.D'\n"
">>> C.D.meth.__qualname__\n"
"'C.D.meth'"

#: ../../glossary.rst:1375
msgid ""
"When used to refer to modules, the *fully qualified name* means the entire "
"dotted path to the module, including any parent packages, e.g. ``email.mime."
"text``::"
msgstr ""
"モジュールへの参照で使われると、*完全修飾名 (fully qualified name)* はすべて"
"の親パッケージを含む全体のドット名表記、例えば ``email.mime.text`` を意味しま"
"す::"

msgid ""
">>> import email.mime.text\n"
">>> email.mime.text.__name__\n"
"'email.mime.text'"
msgstr ""
">>> import email.mime.text\n"
">>> email.mime.text.__name__\n"
"'email.mime.text'"

msgid "race condition"
msgstr "race condition"

msgid ""
"A condition of a program where the behavior depends on the relative timing "
"or ordering of events, particularly in multi-threaded programs.  Race "
"conditions can lead to :term:`non-deterministic` behavior and bugs that are "
"difficult to reproduce.  A :term:`data race` is a specific type of race "
"condition involving unsynchronized access to shared memory.  The :term:"
"`LBYL` coding style is particularly susceptible to race conditions in multi-"
"threaded code.  Using :term:`locks <lock>` and other :term:`synchronization "
"primitives <synchronization primitive>` helps prevent race conditions."
msgstr ""
"(競合状態) 特にマルチスレッドプログラムにおいて、イベントの相対的なタイミング"
"や順序によって動作が変わる、プログラムの状態です。\n"
"競合状態は、:term:`非決定的な <non-deterministic>` 動作や、再現が難しいバグに"
"つながることがあります。\n"
":term:`データ競合 <data race>` は、共有メモリへの同期されていないアクセスが関"
"わる、競合状態の一種です。\n"
":term:`LBYL` コーディングスタイルは、マルチスレッドコードで特に競合状態が起こ"
"りやすいものです。\n"
":term:`ロック <lock>` やその他の :term:`同期プリミティブ <synchronization "
"primitive>` を使うと、競合状態を防ぐのに役立ちます。"

#: ../../glossary.rst:1394
msgid "reference count"
msgstr "reference count"

#: ../../glossary.rst:1396
msgid ""
"The number of references to an object.  When the reference count of an "
"object drops to zero, it is deallocated.  Some objects are :term:`immortal` "
"and have reference counts that are never modified, and therefore the objects "
"are never deallocated.  Reference counting is generally not visible to "
"Python code, but it is a key element of the :term:`CPython` implementation.  "
"Programmers can call the :func:`sys.getrefcount` function to return the "
"reference count for a particular object."
msgstr ""
"(参照カウント) あるオブジェクトに対する参照の数。参照カウントが0になったと"
"き、そのオブジェクトは破棄されます。 :term:`永続 <immortal>` であり、参照カウ"
"ントが決して変更されないために割り当てが解除されないオブジェクトもあります。"
"参照カウントは通常は Python のコード上には現れませんが、 :term:`CPython` 実装"
"の重要な要素です。プログラマーは、 任意のオブジェクトの参照カウントを知るため"
"に :func:`sys.getrefcount` 関数を呼び出すことが出来ます。"

msgid ""
"In :term:`CPython`, reference counts are not considered to be stable or well-"
"defined values; the number of references to an object, and how that number "
"is affected by Python code, may be different between versions."
msgstr ""
":term:`CPython` では、参照カウントは安定した値や明確に定義された値とはみなさ"
"れません。\n"
"オブジェクトへの参照の数や、Python コードがその数に与える影響は、バージョンに"
"よって異なる場合があります。"

#: ../../glossary.rst:1409
msgid "regular package"
msgstr "regular package"

#: ../../glossary.rst:1411
msgid ""
"A traditional :term:`package`, such as a directory containing an ``__init__."
"py`` file."
msgstr ""
"伝統的な、 ``__init__.py`` ファイルを含むディレクトリとしての :term:"
"`package`。"

#: ../../glossary.rst:1414
msgid "See also :term:`namespace package`."
msgstr ":term:`namespace package` を参照してください。"

msgid "reentrant"
msgstr "reentrant"

msgid ""
"A property of a function or :term:`lock` that allows it to be called or "
"acquired multiple times by the same thread without causing errors or a :term:"
"`deadlock`."
msgstr ""
"(再入可能) 同じスレッドが複数回呼び出したり取得したりしても、エラーや :term:`"
"デッドロック <deadlock>` を引き起こさない、関数や :term:`ロック <lock>` の性"
"質です。"

msgid ""
"For functions, reentrancy means the function can be safely called again "
"before a previous invocation has completed, which is important when "
"functions may be called recursively or from signal handlers. Thread-unsafe "
"functions may be :term:`non-deterministic` if they're called reentrantly in "
"a multithreaded program."
msgstr ""
"関数の再入可能性は、前の呼び出しが完了する前に、安全にもう一度呼び出せること"
"を意味します。\n"
"関数が再帰的に、またはシグナルハンドラから呼び出される可能性がある場合に重要"
"です。\n"
"スレッドセーフでない関数は、マルチスレッドプログラムで再入的に呼び出すと、:"
"term:`非決定的 <non-deterministic>` になる場合があります。"

msgid ""
"For locks, Python's :class:`threading.RLock` (reentrant lock) is reentrant, "
"meaning a thread that already holds the lock can acquire it again without "
"blocking.  In contrast, :class:`threading.Lock` is not reentrant - "
"attempting to acquire it twice from the same thread will cause a deadlock."
msgstr ""
"ロックでは、Python の :class:`threading.RLock`（再入可能なロック）が再入可能"
"です。\n"
"これは、すでにロックを保持しているスレッドが、ブロックせずにもう一度そのロッ"
"クを取得できることを意味します。\n"
"一方、:class:`threading.Lock` は再入可能ではなく、同じスレッドから二度取得し"
"ようとすると、デッドロックになります。"

msgid "See also :term:`lock` and :term:`deadlock`."
msgstr ""
":term:`ロック <lock>` と :term:`デッドロック <deadlock>` も参照してください。"

#: ../../glossary.rst:1434
msgid "REPL"
msgstr "REPL"

#: ../../glossary.rst:1436
msgid ""
"An acronym for the \"read–eval–print loop\", another name for the :term:"
"`interactive` interpreter shell."
msgstr ""
"\"read–eval–print loop\" の頭字語で、 :term:`対話型 <interactive>` インタープ"
"リターシェルの別名。"

#: ../../glossary.rst:1438
msgid "__slots__"
msgstr "__slots__"

#: ../../glossary.rst:1440
msgid ""
"A declaration inside a class that saves memory by pre-declaring space for "
"instance attributes and eliminating instance dictionaries.  Though popular, "
"the technique is somewhat tricky to get right and is best reserved for rare "
"cases where there are large numbers of instances in a memory-critical "
"application."
msgstr ""
"クラス内での宣言で、インスタンス属性の領域をあらかじめ定義しておき、インスタ"
"ンス辞書を排除することで、メモリを節約します。これはよく使われるテクニックで"
"すが、正しく扱うには少しトリッキーなので、稀なケース、例えばメモリが死活問題"
"となるアプリケーションでインスタンスが大量に存在する、といったときを除き、使"
"わないのがベストです。"

#: ../../glossary.rst:1445
msgid "sequence"
msgstr "sequence"

msgid ""
"An :term:`iterable` which supports efficient element access using integer "
"indices via the :meth:`~object.__getitem__` special method and defines a :"
"meth:`~object.__len__` method that returns the length of the sequence. Some "
"built-in sequence types are :class:`list`, :class:`str`, :class:`tuple`, "
"and :class:`bytes`. Note that :class:`dict` also supports :meth:`~object."
"__getitem__` and :meth:`!__len__`, but is considered a mapping rather than a "
"sequence because the lookups use arbitrary :term:`hashable` keys rather than "
"integers."
msgstr ""
"(シーケンス) 整数インデックスを使った効率的な要素アクセスを :meth:`~object."
"__getitem__` 特殊メソッドでサポートし、シーケンスの長さを返す :meth:`~object."
"__len__` メソッドを定義する :term:`イテラブル <iterable>` です。\n"
"組み込みのシーケンス型には、:class:`list`、:class:`str`、:class:`tuple`、:"
"class:`bytes` などがあります。\n"
":class:`dict` も :meth:`~object.__getitem__` と :meth:`!__len__` をサポートし"
"ますが、検索には整数ではなく任意の :term:`ハッシュ可能な <hashable>` キーを使"
"うため、シーケンスではなくマッピングとみなされます。"

msgid ""
"The :class:`collections.abc.Sequence` abstract base class defines a much "
"richer interface that goes beyond just :meth:`~object.__getitem__` and :meth:"
"`~object.__len__`, adding :meth:`~sequence.count`, :meth:`~sequence.index`, :"
"meth:`~object.__contains__`, and :meth:`~object.__reversed__`. Types that "
"implement this expanded interface can be registered explicitly using :func:"
"`~abc.ABCMeta.register`. For more documentation on sequence methods "
"generally, see :ref:`Common Sequence Operations <typesseq-common>`."
msgstr ""
":class:`collections.abc.Sequence` 抽象基底クラスは、:meth:`~object."
"__getitem__` と :meth:`~object.__len__` に加え、:meth:`~sequence.count`、:"
"meth:`~sequence.index`、:meth:`~object.__contains__`、:meth:`~object."
"__reversed__` を含む、さらに豊富なインターフェースを定義します。\n"
"この拡張されたインターフェースを実装する型は、:func:`~abc.ABCMeta.register` "
"で明示的に登録できます。\n"
"シーケンスのメソッド全般について詳しくは、:ref:`共通のシーケンス演算 "
"<typesseq-common>` を参照してください。"

msgid "set comprehension"
msgstr "set comprehension"

msgid ""
"A compact way to process all or part of the elements in an iterable and "
"return a set with the results. ``results = {c for c in 'abracadabra' if c "
"not in 'abc'}`` generates the set of strings ``{'r', 'd'}``.  See :ref:"
"`comprehensions`."
msgstr ""
"(集合内包表記) イテラブルのすべて、または一部の要素を処理し、その結果からなる"
"集合を返す簡潔な書き方です。\n"
"``results = {c for c in 'abracadabra' if c not in 'abc'}`` は、文字列の集合 "
"``{'r', 'd'}`` を生成します。\n"
":ref:`comprehensions` を参照してください。"

#: ../../glossary.rst:1472
msgid "single dispatch"
msgstr "single dispatch"

msgid ""
"A form of :term:`generic function` dispatch where the implementation is "
"chosen based on the type of a single argument."
msgstr ""
"(単一ディスパッチ) :term:`ジェネリック関数 <generic function>` のディスパッチ"
"の一形態で、一つの引数の型に基づいて実装を選びます。"

#: ../../glossary.rst:1476
msgid "slice"
msgstr "slice"

msgid ""
"An object of type :class:`slice`, used to describe a portion of a :term:"
"`sequence`. A slice object is created when using the :ref:`slicing "
"<slicings>` form of :ref:`subscript notation <subscriptions>`, with colons "
"inside square brackets, such as in ``variable_name[1:3:5]``."
msgstr ""
"(スライス) :term:`シーケンス <sequence>` の一部を表すために使う、:class:"
"`slice` 型のオブジェクトです。\n"
"``variable_name[1:3:5]`` のように、角括弧内にコロンを含む :ref:`添字表記 "
"<subscriptions>` の :ref:`スライス形式 <slicings>` を使うと、スライスオブジェ"
"クトが作成されます。"

msgid "soft deprecated"
msgstr "soft deprecated"

msgid ""
"A soft deprecated API should not be used in new code, but it is safe for "
"already existing code to use it. The API remains documented and tested, but "
"will not be enhanced further."
msgstr ""
"(ソフト非推奨) ソフト非推奨の API は、新しいコードでは使うべきではありません"
"が、既存のコードで使い続けても安全です。\n"
"その API のドキュメントの掲載とテストは続けられますが、それ以上の機能拡張は行"
"われません。"

msgid ""
"Soft deprecation, unlike normal deprecation, does not plan on removing the "
"API and will not emit warnings."
msgstr ""
"通常の非推奨とは異なり、ソフト非推奨では API の削除は予定されておらず、警告も"
"出力されません。"

msgid ""
"See `PEP 387: Soft Deprecation <https://peps.python.org/pep-0387/#soft-"
"deprecation>`_."
msgstr ""
"`PEP 387: Soft Deprecation <https://peps.python.org/pep-0387/#soft-"
"deprecation>`_ を参照してください。"

#: ../../glossary.rst:1494
msgid "special method"
msgstr "special method"

#: ../../glossary.rst:1498
msgid ""
"A method that is called implicitly by Python to execute a certain operation "
"on a type, such as addition.  Such methods have names starting and ending "
"with double underscores.  Special methods are documented in :ref:"
"`specialnames`."
msgstr ""
"(特殊メソッド) ある型に特定の操作、例えば加算をするために Python から暗黙に呼"
"び出されるメソッド。この種類のメソッドは、メソッド名の最初と最後にアンダース"
"コア 2 つがついています。特殊メソッドについては :ref:`specialnames` で解説さ"
"れています。"

msgid "standard library"
msgstr "standard library"

msgid ""
"The collection of :term:`packages <package>`, :term:`modules <module>` and :"
"term:`extension modules <extension module>` distributed as a part of the "
"official Python interpreter package.  The exact membership of the collection "
"may vary based on platform, available system libraries, or other criteria.  "
"Documentation can be found at :ref:`library-index`."
msgstr ""
"(標準ライブラリ) 公式の Python インタープリタパッケージの一部として配布され"
"る、:term:`パッケージ <package>`、:term:`モジュール <module>`、:term:`拡張モ"
"ジュール <extension module>` の集まりです。\n"
"具体的に何が含まれるかは、プラットフォーム、利用可能なシステムライブラリ、そ"
"の他の条件によって変わる場合があります。\n"
"ドキュメントは :ref:`library-index` にあります。"

msgid ""
"See also :data:`sys.stdlib_module_names` for a list of all possible standard "
"library module names."
msgstr ""
"標準ライブラリのモジュール名として考えられるものすべての一覧については、:"
"data:`sys.stdlib_module_names` も参照してください。"

#: ../../glossary.rst:1512
msgid "statement"
msgstr "statement"

#: ../../glossary.rst:1514
msgid ""
"A statement is part of a suite (a \"block\" of code).  A statement is either "
"an :term:`expression` or one of several constructs with a keyword, such as :"
"keyword:`if`, :keyword:`while` or :keyword:`for`."
msgstr ""
"(文) 文はスイート (コードの\"ブロック\") に不可欠な要素です。文は :term:`式 "
"<expression>` かキーワードから構成されるもののどちらかです。後者には :"
"keyword:`if`、:keyword:`while`、:keyword:`for` があります。"

msgid "static type checker"
msgstr "static type checker"

msgid ""
"An external tool that reads Python code and analyzes it, looking for issues "
"such as incorrect types. See also :term:`type hints <type hint>` and the :"
"mod:`typing` module."
msgstr ""
"(静的型チェッカー) Python コードを読み込んで解析し、型の誤りなどの問題を探す"
"外部ツールです。\n"
":term:`型ヒント <type hint>` と :mod:`typing` モジュールも参照してください。"

msgid "stdlib"
msgstr "stdlib"

msgid "An abbreviation of :term:`standard library`."
msgstr ":term:`標準ライブラリ <standard library>` の略です。"

msgid "steal"
msgstr "steal"

msgid ""
"In Python's C API, \"*stealing*\" an argument means that ownership of the "
"argument is transferred to the called function. The caller must not use that "
"reference after the call. Generally, functions that \"steal\" an argument do "
"so even if they fail."
msgstr ""
"(参照を盗む) Python の C API で実引数を「*盗む*」とは、実引数の所有権が呼び出"
"された関数に移ることを意味します。\n"
"呼び出し元は、呼び出し後にその参照を使ってはなりません。\n"
"一般に、実引数を「盗む」関数は、失敗した場合でも所有権を受け取ります。"

msgid "See :ref:`api-refcountdetails` for a full explanation."
msgstr "詳しい説明は、:ref:`api-refcountdetails` を参照してください。"

msgid "strong reference"
msgstr "strong reference"

msgid ""
"In Python's C API, a strong reference is a reference to an object which is "
"owned by the code holding the reference.  The strong reference is taken by "
"calling :c:func:`Py_INCREF` when the reference is created and released with :"
"c:func:`Py_DECREF` when the reference is deleted."
msgstr ""
"(強参照) Python の C API で、オブジェクトへの参照のうち、それを保持するコード"
"が所有するものです。\n"
"強参照は、参照を作成するときに :c:func:`Py_INCREF` を呼び出すことで取得され、"
"参照を削除するときに :c:func:`Py_DECREF` で解放されます。"

msgid ""
"The :c:func:`Py_NewRef` function can be used to create a strong reference to "
"an object. Usually, the :c:func:`Py_DECREF` function must be called on the "
"strong reference before exiting the scope of the strong reference, to avoid "
"leaking one reference."
msgstr ""
":c:func:`Py_NewRef` 関数を使うと、オブジェクトへの強参照を作成できます。\n"
"通常は、参照が一つリークするのを避けるために、強参照のスコープを抜ける前に、"
"その強参照に対して :c:func:`Py_DECREF` 関数を呼び出さなければなりません。"

msgid "See also :term:`borrowed reference`."
msgstr ":term:`借用参照 <borrowed reference>` も参照してください。"

#: ../../glossary.rst:1547
msgid "subscript"
msgstr "添字"

msgid ""
"The expression in square brackets of a :ref:`subscription expression "
"<subscriptions>`, for example, the ``3`` in ``items[3]``. Usually used to "
"select an element of a container. Also called a :term:`key` when "
"subscripting a :term:`mapping`, or an :term:`index` when subscripting a :"
"term:`sequence`."
msgstr ""
":ref:`添字式 <subscriptions>` の角括弧内の式です。\n"
"たとえば、``items[3]`` の ``3`` が該当します。\n"
"通常、コンテナの要素を選ぶために使います。\n"
":term:`マッピング <mapping>` に添字を指定する場合は :term:`キー <key>`、:"
"term:`シーケンス <sequence>` に添字を指定する場合は :term:`インデックス "
"<index>` とも呼ばれます。"

msgid "synchronization primitive"
msgstr "synchronization primitive"

msgid ""
"A basic building block for coordinating (synchronizing) the execution of "
"multiple threads to ensure :term:`thread-safe` access to shared resources. "
"Python's :mod:`threading` module provides several synchronization primitives "
"including :class:`~threading.Lock`, :class:`~threading.RLock`, :class:"
"`~threading.Semaphore`, :class:`~threading.Condition`, :class:`~threading."
"Event`, and :class:`~threading.Barrier`.  Additionally, the :mod:`queue` "
"module provides multi-producer, multi-consumer queues that are especially "
"useful in multithreaded programs. These primitives help prevent :term:`race "
"conditions <race condition>` and coordinate thread execution.  See also :"
"term:`lock`."
msgstr ""
"(同期プリミティブ) 複数のスレッドの実行を調整（同期）し、共有リソースへの :"
"term:`スレッドセーフな <thread-safe>` アクセスを保証するための基本的な構成要"
"素です。\n"
"Python の :mod:`threading` モジュールは、:class:`~threading.Lock`、:class:"
"`~threading.RLock`、:class:`~threading.Semaphore`、:class:`~threading."
"Condition`、:class:`~threading.Event`、:class:`~threading.Barrier` など、いく"
"つかの同期プリミティブを提供します。\n"
"さらに、:mod:`queue` モジュールは、複数の生産者と複数の消費者をサポートする"
"キューを提供し、マルチスレッドプログラムで特に役立ちます。\n"
"これらのプリミティブは、:term:`競合状態 <race condition>` を防いだり、スレッ"
"ドの実行を調整したりするのに役立ちます。\n"
":term:`ロック <lock>` も参照してください。"

msgid "t-string"
msgstr "t-string"

msgid "t-strings"
msgstr "t-strings"

msgid ""
"String literals prefixed with ``t`` or ``T`` are commonly called \"t-"
"strings\" which is short for :ref:`template string literals <t-strings>`."
msgstr ""
"``t`` または ``T`` を接頭辞に持つ文字列リテラルは、一般に「t-string」と呼ばれ"
"ます。\n"
"これは :ref:`テンプレート文字列リテラル <t-strings>` の略です。"

#: ../../glossary.rst:1573
msgid "text encoding"
msgstr "text encoding"

msgid ""
"A string in Python is a sequence of Unicode code points (in range "
"``U+0000``--``U+10FFFF``). To store or transfer a string, it needs to be "
"serialized as a sequence of bytes."
msgstr ""
"Python の文字列は、Unicode コードポイントの列（``U+0000``--``U+10FFFF`` の範"
"囲）です。\n"
"文字列を保存または転送するには、バイト列としてシリアライズする必要がありま"
"す。"

msgid ""
"Serializing a string into a sequence of bytes is known as \"encoding\", and "
"recreating the string from the sequence of bytes is known as \"decoding\"."
msgstr ""
"文字列をバイト列にシリアライズすることを「エンコード」、バイト列から文字列を"
"復元することを「デコード」といいます。"

msgid ""
"There are a variety of different text serialization :ref:`codecs <standard-"
"encodings>`, which are collectively referred to as \"text encodings\"."
msgstr ""
"文字列をシリアライズするための :ref:`コーデック <standard-encodings>` はさま"
"ざまあり、総称して「テキストエンコーディング」と呼ばれます。"

#: ../../glossary.rst:1585
msgid "text file"
msgstr "text file"

msgid ""
"A :term:`file object` able to read and write :class:`str` objects. Often, a "
"text file actually accesses a byte-oriented datastream and handles the :term:"
"`text encoding` automatically. Examples of text files are files opened in "
"text mode (``'r'`` or ``'w'``), :data:`sys.stdin`, :data:`sys.stdout`, and "
"instances of :class:`io.StringIO`."
msgstr ""
"(テキストファイル) :class:`str` オブジェクトを読み書きできる :term:`ファイル"
"オブジェクト <file object>` です。\n"
"テキストファイルは、多くの場合、実際にはバイト指向のデータストリームにアクセ"
"スし、:term:`テキストエンコーディング <text encoding>` を自動的に処理しま"
"す。\n"
"例として、テキストモード（``'r'`` または ``'w'``）で開いたファイル、:data:"
"`sys.stdin`、:data:`sys.stdout`、:class:`io.StringIO` のインスタンスがありま"
"す。"

#: ../../glossary.rst:1594
msgid ""
"See also :term:`binary file` for a file object able to read and write :term:"
"`bytes-like objects <bytes-like object>`."
msgstr ""
":term:`bytes-like オブジェクト <bytes-like object>` を読み書きできるファイル"
"オブジェクトについては、 :term:`バイナリファイル <binary file>` も参照してく"
"ださい。"

msgid "thread state"
msgstr "thread state"

msgid ""
"The information used by the :term:`CPython` runtime to run in an OS thread. "
"For example, this includes the current exception, if any, and the state of "
"the bytecode interpreter."
msgstr ""
"(スレッド状態) :term:`CPython` ランタイムが OS スレッド内で実行するために使う"
"情報です。\n"
"たとえば、現在の例外（あれば）や、バイトコードインタープリタの状態が含まれま"
"す。"

msgid ""
"Each thread state is bound to a single OS thread, but threads may have many "
"thread states available.  At most, one of them may be :term:`attached "
"<attached thread state>` at once."
msgstr ""
"各スレッド状態は、一つの OS スレッドに結び付けられますが、スレッドには複数の"
"スレッド状態が用意されている場合があります。\n"
"一度に :term:`アタッチされる <attached thread state>` のは、そのうち最大一つ"
"です。"

msgid ""
"An :term:`attached thread state` is required to call most of Python's C API, "
"unless a function explicitly documents otherwise. The bytecode interpreter "
"only runs under an attached thread state."
msgstr ""
"関数のドキュメントに明示的な例外の記載がない限り、Python の C API の大部分を"
"呼び出すには :term:`アタッチされたスレッド状態 <attached thread state>` が必"
"要です。\n"
"バイトコードインタープリタは、スレッド状態がアタッチされている場合だけ動作し"
"ます。"

msgid ""
"Each thread state belongs to a single interpreter, but each interpreter may "
"have many thread states, including multiple for the same OS thread. Thread "
"states from multiple interpreters may be bound to the same thread, but only "
"one can be :term:`attached <attached thread state>` in that thread at any "
"given moment."
msgstr ""
"各スレッド状態は一つのインタープリタに属しますが、各インタープリタは、同じ "
"OS スレッドに対応する複数の状態も含めて、多数のスレッド状態を持つことができま"
"す。\n"
"複数のインタープリタのスレッド状態を同じスレッドに結び付けられますが、ある時"
"点でそのスレッドに :term:`アタッチできる <attached thread state>` のは一つだ"
"けです。"

msgid ""
"See :ref:`Thread State and the Global Interpreter Lock <threads>` for more "
"information."
msgstr ""
"詳しくは、:ref:`スレッド状態とグローバルインタープリタロック <threads>` を参"
"照してください。"

msgid "thread-safe"
msgstr "thread-safe"

msgid ""
"A module, function, or class that behaves correctly when used by multiple "
"threads concurrently.  Thread-safe code uses appropriate :term:"
"`synchronization primitives <synchronization primitive>` like :term:`locks "
"<lock>` to protect shared mutable state, or is designed to avoid shared "
"mutable state entirely.  In the :term:`free-threaded <free threading>` "
"build, built-in types like :class:`dict`, :class:`list`, and :class:`set` "
"use internal locking to make many operations thread-safe, although thread "
"safety is not necessarily guaranteed.  Code that is not thread-safe may "
"experience :term:`race conditions <race condition>` and :term:`data races "
"<data race>` when used in multi-threaded programs."
msgstr ""
"(スレッドセーフ) 複数のスレッドから並行して使っても正しく動作するモジュール、"
"関数、クラスです。\n"
"スレッドセーフなコードは、:term:`ロック <lock>` のような適切な :term:`同期プ"
"リミティブ <synchronization primitive>` を使って共有される可変状態を保護する"
"か、共有される可変状態をまったく持たないように設計されています。\n"
":term:`フリースレッドの <free threading>` ビルドでは、:class:`dict`、:class:"
"`list`、:class:`set` のような組み込み型は、内部でロックを使って多くの操作をス"
"レッドセーフにしていますが、スレッドセーフであることが必ずしも保証されている"
"わけではありません。\n"
"スレッドセーフでないコードをマルチスレッドプログラムで使うと、:term:`競合状"
"態 <race condition>` や :term:`データ競合 <data race>` が発生することがありま"
"す。"

#: ../../glossary.rst:1632
msgid "token"
msgstr "トークン"

msgid ""
"A small unit of source code, generated by the :ref:`lexical analyzer "
"<lexical>` (also called the *tokenizer*). Names, numbers, strings, "
"operators, newlines and similar are represented by tokens."
msgstr ""
":ref:`字句解析器 <lexical>` （*トークナイザ* とも呼ばれます）が生成する、ソー"
"スコードの小さな単位です。\n"
"名前、数値、文字列、演算子、改行などは、トークンで表されます。"

msgid ""
"The :mod:`tokenize` module exposes Python's lexical analyzer. The :mod:"
"`token` module contains information on the various types of tokens."
msgstr ""
":mod:`tokenize` モジュールは、Python の字句解析器を公開します。\n"
":mod:`token` モジュールは、さまざまな種類のトークンについての情報を含みます。"

#: ../../glossary.rst:1643
msgid "triple-quoted string"
msgstr "triple-quoted string"

msgid ""
"A string which is bound by three instances of either a quotation mark (\") "
"or an apostrophe (').  While they don't provide any functionality not "
"available with single-quoted strings, they are useful for a number of "
"reasons.  They allow you to include unescaped single and double quotes "
"within a string and they can span multiple lines without the use of the "
"continuation character, making them especially useful when writing "
"docstrings."
msgstr ""
"(三重クォート文字列) クォート記号（\"）またはアポストロフィー（'）を三つ並べ"
"て囲んだ文字列です。\n"
"一重クォート文字列にない機能を提供するわけではありませんが、いくつかの理由で"
"便利です。\n"
"文字列の中にシングルクォートやダブルクォートをエスケープせずに含めることがで"
"き、行継続文字を使わずに複数行にまたがることもできるため、ドキュメンテーショ"
"ン文字列を書く際に特に役立ちます。"

#: ../../glossary.rst:1652
msgid "type"
msgstr "type"

msgid ""
"The type of a Python object determines what kind of object it is; every "
"object has a type.  An object's type is accessible as its :attr:`~object."
"__class__` attribute or can be retrieved with ``type(obj)``."
msgstr ""
"(型) Python オブジェクトの型は、それがどのような種類のオブジェクトかを決めま"
"す。\n"
"すべてのオブジェクトには型があります。\n"
"オブジェクトの型には :attr:`~object.__class__` 属性としてアクセスでき、"
"``type(obj)`` でも取得できます。"

#: ../../glossary.rst:1658
msgid "type alias"
msgstr "type alias"

#: ../../glossary.rst:1660
msgid "A synonym for a type, created by assigning the type to an identifier."
msgstr "(型エイリアス) 型の別名で、型を識別子に代入して作成します。"

#: ../../glossary.rst:1662
msgid ""
"Type aliases are useful for simplifying :term:`type hints <type hint>`. For "
"example::"
msgstr ""
"型エイリアスは :term:`型ヒント <type hint>` を単純化するのに有用です。例え"
"ば::"

msgid ""
"def remove_gray_shades(\n"
"        colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:\n"
"    pass"
msgstr ""
"def remove_gray_shades(\n"
"        colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:\n"
"    pass"

#: ../../glossary.rst:1669
msgid "could be made more readable like this::"
msgstr "これは次のようにより読みやすくできます::"

msgid ""
"Color = tuple[int, int, int]\n"
"\n"
"def remove_gray_shades(colors: list[Color]) -> list[Color]:\n"
"    pass"
msgstr ""
"Color = tuple[int, int, int]\n"
"\n"
"def remove_gray_shades(colors: list[Color]) -> list[Color]:\n"
"    pass"

#: ../../glossary.rst:1676 ../../glossary.rst:1690
msgid "See :mod:`typing` and :pep:`484`, which describe this functionality."
msgstr "機能の説明がある :mod:`typing` と :pep:`484` を参照してください。"

#: ../../glossary.rst:1677
msgid "type hint"
msgstr "type hint"

#: ../../glossary.rst:1679
msgid ""
"An :term:`annotation` that specifies the expected type for a variable, a "
"class attribute, or a function parameter or return value."
msgstr ""
"(型ヒント) 変数、クラス属性、関数のパラメータや返り値の期待される型を指定す"
"る :term:`annotation` です。"

msgid ""
"Type hints are optional and are not enforced by Python but they are useful "
"to :term:`static type checkers <static type checker>`. They can also aid "
"IDEs with code completion and refactoring."
msgstr ""
"型ヒントは省略可能で、Python によって強制されませんが、:term:`静的型チェッ"
"カー <static type checker>` に役立ちます。\n"
"IDE によるコード補完やリファクタリングにも役立ちます。"

#: ../../glossary.rst:1686
msgid ""
"Type hints of global variables, class attributes, and functions, but not "
"local variables, can be accessed using :func:`typing.get_type_hints`."
msgstr ""
"グローバル変数、クラス属性、関数で、ローカル変数でないものの型ヒントは :func:"
"`typing.get_type_hints` で取得できます。"

#: ../../glossary.rst:1691
msgid "universal newlines"
msgstr "universal newlines"

#: ../../glossary.rst:1693
msgid ""
"A manner of interpreting text streams in which all of the following are "
"recognized as ending a line: the Unix end-of-line convention ``'\\n'``, the "
"Windows convention ``'\\r\\n'``, and the old Macintosh convention "
"``'\\r'``.  See :pep:`278` and :pep:`3116`, as well as :func:`bytes."
"splitlines` for an additional use."
msgstr ""
"テキストストリームの解釈法の一つで、以下のすべてを行末と認識します: Unix の行"
"末規定 ``'\\n'``、Windows の規定 ``'\\r\\n'``、古い Macintosh の規定 "
"``'\\r'``。利用法について詳しくは、 :pep:`278` と :pep:`3116` 、さらに :func:"
"`bytes.splitlines` も参照してください。"

#: ../../glossary.rst:1698
msgid "variable annotation"
msgstr "variable annotation"

#: ../../glossary.rst:1700
msgid "An :term:`annotation` of a variable or a class attribute."
msgstr "(変数アノテーション) 変数あるいはクラス属性の :term:`annotation` 。"

#: ../../glossary.rst:1702
msgid ""
"When annotating a variable or a class attribute, assignment is optional::"
msgstr "変数あるいはクラス属性に注釈を付けたときは、代入部分は任意です::"

msgid ""
"class C:\n"
"    field: 'annotation'"
msgstr ""
"class C:\n"
"    field: 'annotation'"

#: ../../glossary.rst:1707
msgid ""
"Variable annotations are usually used for :term:`type hints <type hint>`: "
"for example this variable is expected to take :class:`int` values::"
msgstr ""
"変数アノテーションは通常は :term:`型ヒント<type hint>` のために使われます: 例"
"えば、この変数は :class:`int` の値を取ることを期待されています::"

msgid "count: int = 0"
msgstr "count: int = 0"

#: ../../glossary.rst:1713
msgid "Variable annotation syntax is explained in section :ref:`annassign`."
msgstr ""
"変数アノテーションの構文については :ref:`annassign` 節で解説しています。"

#: ../../glossary.rst:1715
msgid ""
"See :term:`function annotation`, :pep:`484` and :pep:`526`, which describe "
"this functionality. Also see :ref:`annotations-howto` for best practices on "
"working with annotations."
msgstr ""
"機能の説明がある :term:`function annotation`,  :pep:`484` , :pep:`526` を参照"
"してください。また、アノテーションを利用するベストプラクティスとして :ref:"
"`annotations-howto` も参照してください。"

#: ../../glossary.rst:1719
msgid "virtual environment"
msgstr "virtual environment"

#: ../../glossary.rst:1721
msgid ""
"A cooperatively isolated runtime environment that allows Python users and "
"applications to install and upgrade Python distribution packages without "
"interfering with the behaviour of other Python applications running on the "
"same system."
msgstr ""
"(仮想環境) 協調的に切り離された実行環境です。これにより Python ユーザとアプリ"
"ケーションは同じシステム上で動いている他の Python アプリケーションの挙動に干"
"渉することなく Python パッケージのインストールと更新を行うことができます。"

#: ../../glossary.rst:1726
msgid "See also :mod:`venv`."
msgstr ":mod:`venv` を参照してください。"

#: ../../glossary.rst:1727
msgid "virtual machine"
msgstr "virtual machine"

#: ../../glossary.rst:1729
msgid ""
"A computer defined entirely in software.  Python's virtual machine executes "
"the :term:`bytecode` emitted by the bytecode compiler."
msgstr ""
"(仮想マシン) 完全にソフトウェアにより定義されたコンピュータ。 Python の仮想マ"
"シンは、バイトコードコンパイラが出力した :term:`バイトコード <bytecode>` を実"
"行します。"

msgid "walrus operator"
msgstr "walrus operator"

msgid ""
"A light-hearted way to refer to the :ref:`assignment expression <assignment-"
"expressions>` operator ``:=`` because it looks a bit like a walrus if you "
"turn your head."
msgstr ""
"(セイウチ演算子) :ref:`代入式 <assignment-expressions>` の演算子 ``:=`` を指"
"すユーモラスな呼び方です。\n"
"頭を傾けると、少しセイウチに似て見えることに由来します。"

#: ../../glossary.rst:1736
msgid "Zen of Python"
msgstr "Zen of Python"

#: ../../glossary.rst:1738
msgid ""
"Listing of Python design principles and philosophies that are helpful in "
"understanding and using the language.  The listing can be found by typing "
"\"``import this``\" at the interactive prompt."
msgstr ""
"(Pythonの悟り) Python を理解し利用する上での導きとなる、Python の設計原則と哲"
"学をリストにしたものです。対話プロンプトで \"``import this``\" とするとこのリ"
"ストを読めます。"

#: ../../glossary.rst:24
msgid "..."
msgstr "..."

#: ../../glossary.rst:24
msgid "ellipsis literal"
msgstr "ellipsisリテラル"

msgid "C-contiguous"
msgstr "C-contiguous"

msgid "Fortran contiguous"
msgstr "Fortran contiguous"

msgid "magic"
msgstr "magic"

#: ../../glossary.rst:1496
msgid "special"
msgstr "特殊"