# 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:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-12-17 14:16+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: python-doc bot, 2025\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 プロンプ"

"トです。"

#: ../../glossary.rst:26

msgid ""

"The three dots form of the :ref:`Ellipsis <bltin-ellipsis-object>` object."

msgstr ""

#: ../../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 を作成でき"

"ます。"

#: ../../glossary.rst:40

msgid "annotate function"

msgstr ""

#: ../../glossary.rst:42

msgid ""

"A function that can be called to retrieve the :term:`annotations "

"<annotation>` of an object. This function is accessible as the :attr:"

"`~object.__annotate__` attribute of functions, classes, and modules. "

"Annotate functions are a subset of :term:`evaluate functions <evaluate "

"function>`."

msgstr ""

#: ../../glossary.rst:46

msgid "annotation"

msgstr "annotation"

#: ../../glossary.rst:48

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` として使われています。"

#: ../../glossary.rst:52

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 ""

#: ../../glossary.rst:57

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 ""

#: ../../glossary.rst:61

msgid "argument"

msgstr "引数 (argument)"

#: ../../glossary.rst:63

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:66

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:71

msgid ""

"complex(real=3, imag=5)\n"

"complex(**{'real': 3, 'imag': 5})"

msgstr ""

#: ../../glossary.rst:74

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:80

msgid ""

"complex(3, 5)\n"

"complex(*(3, 5))"

msgstr ""

#: ../../glossary.rst:83

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:88

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:91

msgid "asynchronous context manager"

msgstr "asynchronous context manager"

#: ../../glossary.rst:93

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:96

msgid "asynchronous generator"

msgstr "asynchronous generator"

#: ../../glossary.rst:98

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."

msgstr ""

"(非同期ジェネレータ)\n"

":term:`asynchronous generator iterator` を返す関数です。\n"

":keyword:`async def` で定義されたコルーチン関数に似ていますが、 :keyword:"

"`yield` 式を持つ点で異なります。\n"

":keyword:`yield` 式は :keyword:`async for` ループで使用できる値の並びを生成す"

"るのに使用されます。"

#: ../../glossary.rst:103

msgid ""

"Usually refers to an asynchronous generator function, but may refer to an "

"*asynchronous generator iterator* in some contexts. In cases where the "

"intended meaning isn't clear, using the full terms avoids ambiguity."

msgstr ""

"通常は非同期ジェネレータ関数を指しますが、文脈によっては *非同期ジェネレータ"

"イテレータ* を指す場合があります。\n"

"意図された意味が明らかでない場合、 明瞭化のために完全な単語を使用します。"

#: ../../glossary.rst:107

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:110

msgid "asynchronous generator iterator"

msgstr "asynchronous generator iterator"

#: ../../glossary.rst:112

msgid "An object created by an :term:`asynchronous generator` function."

msgstr ""

#: ../../glossary.rst:114

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` 式まで非同期ジェネレータ関数の本体を実行し"

"ます。"

#: ../../glossary.rst:119

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 ""

#: ../../glossary.rst:124

msgid "asynchronous iterable"

msgstr "asynchronous iterable"

#: ../../glossary.rst:126

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:129

msgid "asynchronous iterator"

msgstr "asynchronous iterator"

#: ../../glossary.rst:131

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` で導入されました。"

#: ../../glossary.rst:136

msgid "atomic operation"

msgstr ""

#: ../../glossary.rst:138

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 ""

#: ../../glossary.rst:144

msgid "attached thread state"

msgstr ""

#: ../../glossary.rst:147

msgid "A :term:`thread state` that is active for the current OS thread."

msgstr ""

#: ../../glossary.rst:149

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 ""

#: ../../glossary.rst:153

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 ""

#: ../../glossary.rst:160

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 <free threading>` builds of Python, threads can concurrently hold "

"an attached thread state, allowing for true parallelism of the bytecode "

"interpreter."

msgstr ""

#: ../../glossary.rst:166

msgid "attribute"

msgstr "属性"

#: ../../glossary.rst:168

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:173

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:178

msgid "awaitable"

msgstr "awaitable"

#: ../../glossary.rst:180

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:183

msgid "BDFL"

msgstr "BDFL"

#: ../../glossary.rst:185

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:187

msgid "binary file"

msgstr "binary file"

#: ../../glossary.rst:189

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:196

msgid ""

"See also :term:`text file` for a file object able to read and write :class:"

"`str` objects."

msgstr ""

":class:`str` オブジェクトの読み書きができるファイルオブジェクトについては、 :"

"term:`text file` も参照してください。"

#: ../../glossary.rst:198

msgid "borrowed reference"

msgstr ""

#: ../../glossary.rst:200

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 ""

#: ../../glossary.rst:206

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 ""

#: ../../glossary.rst:211

msgid "bytes-like object"

msgstr "bytes-like object"

#: ../../glossary.rst:213

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 オブジェクトは、データ圧縮、バイナリファイルへの保存、ソケットを経"

"由した送信など、バイナリデータを要求するいろいろな操作に利用することができま"

"す。"

#: ../../glossary.rst:220

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 オブジェクト\") を必要します。それには :class:`bytes` と :"

"class:`bytes` の :class:`memoryview` オブジェクトが含まれます。"

#: ../../glossary.rst:228

msgid "bytecode"

msgstr "bytecode"

#: ../../glossary.rst:230

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:240

msgid ""

"A list of bytecode instructions can be found in the documentation for :ref:"

"`the dis module <bytecodes>`."

msgstr ""

"バイトコードの命令一覧は :ref:`dis モジュール <bytecodes>` にあります。"

#: ../../glossary.rst:242

msgid "callable"

msgstr "callable"

#: ../../glossary.rst:244

msgid ""

"A callable is an object that can be called, possibly with a set of arguments "

"(see :term:`argument`), with the following syntax::"

msgstr ""

#: ../../glossary.rst:247

msgid "callable(argument1, argument2, argumentN)"

msgstr ""

#: ../../glossary.rst:249

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 ""

#: ../../glossary.rst:252

msgid "callback"

msgstr "callback"

#: ../../glossary.rst:254

msgid ""

"A subroutine function which is passed as an argument to be executed at some "

"point in the future."

msgstr "(コールバック) 将来のある時点で実行されるために引数として渡される関数"

#: ../../glossary.rst:256

msgid "class"

msgstr "クラス"

#: ../../glossary.rst:258

msgid ""

"A template for creating user-defined objects. Class definitions normally "

"contain method definitions which operate on instances of the class."

msgstr ""

"(クラス) ユーザー定義オブジェクトを作成するためのテンプレートです。クラス定義"

"は普通、そのクラスのインスタンス上の操作をするメソッドの定義を含みます。"

#: ../../glossary.rst:261

msgid "class variable"

msgstr "class variable"

#: ../../glossary.rst:263

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 ""

"(クラス変数) クラス上に定義され、クラスレベルで (つまり、クラスのインスタンス"

"上ではなしに) 変更されることを目的としている変数です。"

#: ../../glossary.rst:265

msgid "closure variable"

msgstr ""

#: ../../glossary.rst:267

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 ""

#: ../../glossary.rst:272

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 ""

#: ../../glossary.rst:275

msgid ""

"def outer():\n"

" x = 0\n"

" def inner():\n"

" nonlocal x\n"

" x += 1\n"

" print(x)\n"

" return inner"

msgstr ""

#: ../../glossary.rst:283

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 ""

#: ../../glossary.rst:287

msgid "complex number"

msgstr "complex number"

#: ../../glossary.rst:289

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` を使います。複素数の使用はかなり高度な数学の機能です。必要性を感じな"

"ければ、ほぼ間違いなく無視してしまってよいでしょう。"

#: ../../glossary.rst:299

msgid "concurrency"

msgstr ""

#: ../../glossary.rst:301

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 ""

#: ../../glossary.rst:309

msgid "concurrent modification"

msgstr ""

#: ../../glossary.rst:311

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 ""

#: ../../glossary.rst:315

msgid "context"

msgstr ""

#: ../../glossary.rst:317

msgid ""

"This term has different meanings depending on where and how it is used. Some "

"common meanings:"

msgstr ""

#: ../../glossary.rst:320

msgid ""

"The temporary state or environment established by a :term:`context manager` "

"via a :keyword:`with` statement."

msgstr ""

#: ../../glossary.rst:322

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 ""

#: ../../glossary.rst:326

msgid ""

"A :class:`contextvars.Context` object. Also see :term:`current context`."

msgstr ""

#: ../../glossary.rst:328

msgid "context management protocol"

msgstr "コンテキスト管理プロトコル"

#: ../../glossary.rst:330

msgid ""

"The :meth:`~object.__enter__` and :meth:`~object.__exit__` methods called by "

"the :keyword:`with` statement. See :pep:`343`."

msgstr ""

#: ../../glossary.rst:332

msgid "context manager"

msgstr "context manager"

#: ../../glossary.rst:334

msgid ""

"An object which implements the :term:`context management protocol` and "

"controls the environment seen in a :keyword:`with` statement. See :pep:"

"`343`."

msgstr ""

#: ../../glossary.rst:337

msgid "context variable"

msgstr "context variable"

#: ../../glossary.rst:339

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 ""

#: ../../glossary.rst:343

msgid "contiguous"

msgstr "contiguous"

#: ../../glossary.rst:347

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-連続な配列では、メモリアドレス順に要素を巡る際には最後の添え字が最"

"初に変わるのに対し、 Fortran 連続な配列では最初の添え字が最初に動きます。"

#: ../../glossary.rst:355

msgid "coroutine"

msgstr "コルーチン"

#: ../../glossary.rst:357

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:362

msgid "coroutine function"

msgstr "coroutine function"

#: ../../glossary.rst:364

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:369

msgid "CPython"

msgstr "CPython"

#: ../../glossary.rst:371

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 といった他の実装と区別する必要が有る場合に利用されます。"

#: ../../glossary.rst:375

msgid "current context"

msgstr ""

#: ../../glossary.rst:377

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 ""

#: ../../glossary.rst:383

msgid "cyclic isolate"

msgstr ""

#: ../../glossary.rst:385

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 ""

#: ../../glossary.rst:389

msgid "data race"

msgstr ""

#: ../../glossary.rst:391

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 ""

#: ../../glossary.rst:400

msgid "deadlock"

msgstr ""

#: ../../glossary.rst:402

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 ""

#: ../../glossary.rst:411

msgid "decorator"

msgstr "decorator"

#: ../../glossary.rst:413

msgid ""

"A function returning another function, usually applied as a function "

"transformation using the ``@wrapper`` syntax. Common examples for "

"decorators are :func:`classmethod` and :func:`staticmethod`."

msgstr ""

"(デコレータ) 別の関数を返す関数で、通常、 ``@wrapper`` 構文で関数変換として適"

"用されます。デコレータの一般的な利用例は、 :func:`classmethod` と :func:"

"`staticmethod` です。"

#: ../../glossary.rst:417

msgid ""

"The decorator syntax is merely syntactic sugar, the following two function "

"definitions are semantically equivalent::"

msgstr ""

"デコレータの文法はシンタックスシュガーです。次の2つの関数定義は意味的に同じも"

"のです::"

#: ../../glossary.rst:420

msgid ""

"def f(arg):\n"

" ...\n"

"f = staticmethod(f)\n"

"\n"

"@staticmethod\n"

"def f(arg):\n"

" ..."

msgstr ""

#: ../../glossary.rst:428

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:431

msgid "descriptor"

msgstr "descriptor"

#: ../../glossary.rst:433

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 ""

#: ../../glossary.rst:444

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:446

msgid "dictionary"

msgstr "dictionary"

#: ../../glossary.rst:448

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 ""

#: ../../glossary.rst:452

msgid "dictionary comprehension"

msgstr "dictionary comprehension"

#: ../../glossary.rst:454

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:458

msgid "dictionary view"

msgstr "dictionary view"

#: ../../glossary.rst:460

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:466

msgid "docstring"

msgstr "docstring"

#: ../../glossary.rst:468

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 "