# 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-10-27 14:15+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 "attached thread state"

msgstr ""

#: ../../glossary.rst:139

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

msgstr ""

#: ../../glossary.rst:141

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

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

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

msgid "attribute"

msgstr "属性"

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

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

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

msgid "awaitable"

msgstr "awaitable"

#: ../../glossary.rst:172

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

msgid "BDFL"

msgstr "BDFL"

#: ../../glossary.rst:177

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

msgid "binary file"

msgstr "binary file"

#: ../../glossary.rst:181

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

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

msgid "borrowed reference"

msgstr ""

#: ../../glossary.rst:192

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

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

msgid "bytes-like object"

msgstr "bytes-like object"

#: ../../glossary.rst:205

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

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

msgid "bytecode"

msgstr "bytecode"

#: ../../glossary.rst:222

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

msgid ""

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

"`the dis module <bytecodes>`."

msgstr ""

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

#: ../../glossary.rst:234

msgid "callable"

msgstr "callable"

#: ../../glossary.rst:236

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

msgid "callable(argument1, argument2, argumentN)"

msgstr ""

#: ../../glossary.rst:241

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

msgid "callback"

msgstr "callback"

#: ../../glossary.rst:246

msgid ""

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

"point in the future."

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

#: ../../glossary.rst:248

msgid "class"

msgstr "クラス"

#: ../../glossary.rst:250

msgid ""

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

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

msgstr ""

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

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

#: ../../glossary.rst:253

msgid "class variable"

msgstr "class variable"

#: ../../glossary.rst:255

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

msgid "closure variable"

msgstr ""

#: ../../glossary.rst:259

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

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

msgid ""

"def outer():\n"

" x = 0\n"

" def inner():\n"

" nonlocal x\n"

" x += 1\n"

" print(x)\n"

" return inner"

msgstr ""

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

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

msgid "complex number"

msgstr "complex number"

#: ../../glossary.rst:281

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

msgid "context"

msgstr ""

#: ../../glossary.rst:293

msgid ""

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

"common meanings:"

msgstr ""

#: ../../glossary.rst:296

msgid ""

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

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

msgstr ""

#: ../../glossary.rst:298

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

msgid ""

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

msgstr ""

#: ../../glossary.rst:304

msgid "context management protocol"

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

#: ../../glossary.rst:306

msgid ""

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

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

msgstr ""

#: ../../glossary.rst:308

msgid "context manager"

msgstr "context manager"

#: ../../glossary.rst:310

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

msgid "context variable"

msgstr "context variable"

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

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

msgid "contiguous"

msgstr "contiguous"

#: ../../glossary.rst:323

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

msgid "coroutine"

msgstr "コルーチン"

#: ../../glossary.rst:333

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

msgid "coroutine function"

msgstr "coroutine function"

#: ../../glossary.rst:340

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

msgid "CPython"

msgstr "CPython"

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

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

msgid "current context"

msgstr ""

#: ../../glossary.rst:353

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

msgid "cyclic isolate"

msgstr ""

#: ../../glossary.rst:361

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

msgid "decorator"

msgstr "decorator"

#: ../../glossary.rst:367

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

msgid ""

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

"definitions are semantically equivalent::"

msgstr ""

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

"のです::"

#: ../../glossary.rst:374

msgid ""

"def f(arg):\n"

" ...\n"

"f = staticmethod(f)\n"

"\n"

"@staticmethod\n"

"def f(arg):\n"

" ..."

msgstr ""

#: ../../glossary.rst:382

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

msgid "descriptor"

msgstr "descriptor"

#: ../../glossary.rst:387

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

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

msgid "dictionary"

msgstr "dictionary"

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

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

msgid "dictionary comprehension"

msgstr "dictionary comprehension"

#: ../../glossary.rst:408

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

msgid "dictionary view"

msgstr "dictionary view"

#: ../../glossary.rst:414

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

msgid "docstring"

msgstr "docstring"

#: ../../glossary.rst:422

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

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

msgid "duck-typing"

msgstr "duck-typing"

#: ../../glossary.rst:430

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` プログラミングを利用します。"

#: ../../glossary.rst:439

msgid "dunder"

msgstr ""

#: ../../glossary.rst:441

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

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

msgid "EAFP"

msgstr "EAFP"

#: ../../glossary.rst:446

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、マーフィーの法則)」の略です。この Python で広く使われているコー"

"ディングスタイルでは、通常は有効なキーや属性が存在するものと仮定し、その仮定"

"が誤っていた場合に例外を捕捉します。この簡潔で手早く書けるコーディングスタイ"

"ルには、 :keyword:`try` 文および :keyword:`except` 文がたくさんあるのが特徴で"

"す。このテクニックは、C のような言語でよく使われている :term:`LBYL` スタイル"

"と対照的なものです。"

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

msgid "evaluate function"

msgstr ""

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

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