# 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-25 14:12+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"

#: ../../c-api/arg.rst:6
msgid "Parsing arguments and building values"
msgstr "引数の解釈と値の構築"

#: ../../c-api/arg.rst:8
msgid ""
"These functions are useful when creating your own extension functions and "
"methods.  Additional information and examples are available in :ref:"
"`extending-index`."
msgstr ""

#: ../../c-api/arg.rst:12
msgid ""
"The first three of these functions described, :c:func:`PyArg_ParseTuple`, :c:"
"func:`PyArg_ParseTupleAndKeywords`, and :c:func:`PyArg_Parse`, all use "
"*format strings* which are used to tell the function about the expected "
"arguments.  The format strings use the same syntax for each of these "
"functions."
msgstr ""
"最初に説明する 3 つの関数、 :c:func:`PyArg_ParseTuple`, :c:func:"
"`PyArg_ParseTupleAndKeywords`,および :c:func:`PyArg_Parse` はいずれも *書式文"
"字列 (format string)* を使います。書式文字列は、関数が受け取るはずの引数に関"
"する情報を伝えるのに用いられます。いずれの関数における書式文字列も、同じ書式"
"を使っています。"

#: ../../c-api/arg.rst:19
msgid "Parsing arguments"
msgstr "引数を解析する"

#: ../../c-api/arg.rst:21
msgid ""
"A format string consists of zero or more \"format units.\"  A format unit "
"describes one Python object; it is usually a single character or a "
"parenthesized sequence of format units.  With a few exceptions, a format "
"unit that is not a parenthesized sequence normally corresponds to a single "
"address argument to these functions.  In the following description, the "
"quoted form is the format unit; the entry in (round) parentheses is the "
"Python object type that matches the format unit; and the entry in [square] "
"brackets is the type of the C variable(s) whose address should be passed."
msgstr ""
"書式文字列は、ゼロ個またはそれ以上の \"書式単位 (format unit)\" から成り立ち"
"ます。 1つの書式単位は1つの Python オブジェクトを表します; 通常は単一の文字"
"か、書式単位からなる文字列を括弧で囲ったものになります。例外として、括弧で囲"
"われていない書式単位文字列が単一のアドレス引数に対応する場合がいくつかありま"
"す。以下の説明では、引用符のついた形式は書式単位です; (丸)括弧で囲った部分は"
"書式単位に対応する Python のオブジェクト型です; [角] 括弧は値をアドレス渡しす"
"る際に使う C の変数型です。"

#: ../../c-api/arg.rst:33
msgid "Strings and buffers"
msgstr "文字列とバッファ"

#: ../../c-api/arg.rst:37
msgid ""
"On Python 3.12 and older, the macro :c:macro:`!PY_SSIZE_T_CLEAN` must be "
"defined before including :file:`Python.h` to use all ``#`` variants of "
"formats (``s#``, ``y#``, etc.) explained below. This is not necessary on "
"Python 3.13 and later."
msgstr ""
"Python 3.12 以前では、以下で説明された全ての ``#`` の種類 (``s#``, ``y#`` な"
"ど) を使用するために :c:macro:`!PY_SSIZE_T_CLEAN` マクロを :file:`Python.h` "
"のインクルードの前に定義しなければなりません。これは Python 3.13 以降では不要"
"です。"

#: ../../c-api/arg.rst:42
msgid ""
"These formats allow accessing an object as a contiguous chunk of memory. You "
"don't have to provide raw storage for the returned unicode or bytes area."
msgstr ""
"以下のフォーマットはオブジェクトに連続したメモリチャンクとしてアクセスするた"
"めのものです。返される unicode や bytes のために生のストレージを用意する必要"
"はありません。"

#: ../../c-api/arg.rst:46
msgid "Unless otherwise stated, buffers are not NUL-terminated."
msgstr "特に言及されていない場合、バッファーは NUL 終端されていません。"

#: ../../c-api/arg.rst:48
msgid "There are three ways strings and buffers can be converted to C:"
msgstr "文字列とバッファをCに変換する方法は3つあります："

#: ../../c-api/arg.rst:50
msgid ""
"Formats such as ``y*`` and ``s*`` fill a :c:type:`Py_buffer` structure. This "
"locks the underlying buffer so that the caller can subsequently use the "
"buffer even inside a :c:type:`Py_BEGIN_ALLOW_THREADS` block without the risk "
"of mutable data being resized or destroyed. As a result, **you have to "
"call** :c:func:`PyBuffer_Release` after you have finished processing the "
"data (or in any early abort case)."
msgstr ""
"形式としては ``y*`` そして ``s*`` 埋める :c:type:`Py_buffer` 構造体。これは"
"ロックします 根底 バッファ これにより、呼び出し元はその後、バッファを内部でも"
"使用できるようになります:c:type:`Py_BEGIN_ALLOW_THREADS`  ブロック リスクなし"
"に 可変 データが再サイズ化または破壊される。その結果、**電話をかけなければな"
"らない** :c:func:`PyBuffer_Release` データ処理が完了した後（または早期終了の"
"場合）。"

#: ../../c-api/arg.rst:57
msgid ""
"The ``es``, ``es#``, ``et`` and ``et#`` formats allocate the result buffer. "
"**You have to call** :c:func:`PyMem_Free` after you have finished processing "
"the data (or in any early abort case)."
msgstr ""
"その ``es``, ``es#``, ``et`` そして ``et#`` フォーマットは結果を割り当てます "
"バッファ. **必ず電話をかけてください** :c:func:`PyMem_Free` データ処理が完了"
"した後（または早期終了の場合）。"

#: ../../c-api/arg.rst:63
msgid ""
"Other formats take a :class:`str` or a read-only :term:`bytes-like object`, "
"such as :class:`bytes`, and provide a ``const char *`` pointer to its "
"buffer. In this case the buffer is \"borrowed\": it is managed by the "
"corresponding Python object, and shares the lifetime of this object. You "
"won't have to release any memory yourself."
msgstr ""
"他の形式では :class:`str`または 読み出し専用 :term:`bytes-like オブジェクト"
"`、例えば   :class:`bytes`, および提供する ``const char *`` ポインタ その "
"バッファ. この場合 バッファ「借用」されています：これは対応するPythonオブジェ"
"クトによって管理され、このオブジェクトのライフサイクルを共有します。メモリを"
"自分で解放する必要はありません。 "

#: ../../c-api/arg.rst:70
msgid ""
"To ensure that the underlying buffer may be safely borrowed, the object's :c:"
"member:`PyBufferProcs.bf_releasebuffer` field must be ``NULL``. This "
"disallows common mutable objects such as :class:`bytearray`, but also some "
"read-only objects such as :class:`memoryview` of :class:`bytes`."
msgstr ""
"以下のことを確実にするため 根底 バッファ 安全に借りることができます, 対象の :"
"c:member:`PyBufferProcs.bf_releasebuffer` フィールドは必須です。 ``NULL``. こ"
"れは一般的な 可変 次のようなオブジェクト :class:`bytearray`, また、いくつか"
"の 読み出し専用 次のようなオブジェクト :class:`memoryview` の :class:`bytes`."

#: ../../c-api/arg.rst:76
msgid ""
"Besides this ``bf_releasebuffer`` requirement, there is no check to verify "
"whether the input object is immutable (e.g. whether it would honor a request "
"for a writable buffer, or whether another thread can mutate the data)."
msgstr ""
"これに加えて ``bf_releasebuffer``  要件として、入力が有効かどうかを確認する"
"チェックはありません 対象は 不変 （例：請求に応じるかどうか 書き込み可能 バッ"
"ファ,  または、別のスレッドがデータを変更できるかどうか)。"

#: ../../c-api/arg.rst:80
msgid "``s`` (:class:`str`) [const char \\*]"
msgstr "``s`` (:class:`str`) [const char \\*]"

#: ../../c-api/arg.rst:81
msgid ""
"Convert a Unicode object to a C pointer to a character string. A pointer to "
"an existing string is stored in the character pointer variable whose address "
"you pass.  The C string is NUL-terminated. The Python string must not "
"contain embedded null code points; if it does, a :exc:`ValueError` exception "
"is raised. Unicode objects are converted to C strings using ``'utf-8'`` "
"encoding. If this conversion fails, a :exc:`UnicodeError` is raised."
msgstr ""
"Unicode オブジェクトを、キャラクタ文字列を指す C のポインタに変換します。キャ"
"ラクタ型ポインタ変数のアドレスを渡すと、すでに存在している文字列へのポインタ"
"をその変数に記録します。C 文字列は NUL で終端されています。Python の文字列型"
"は、 null コードポイントが途中に埋め込まれていてはなりません; もし埋め込まれ"
"ていれば :exc:`ValueError` 例外を送出します。Unicode オブジェクトは "
"``'utf-8'`` を使って C 文字列に変換されます。変換に失敗すると :exc:"
"`UnicodeError` を送出します。"

#: ../../c-api/arg.rst:90
msgid ""
"This format does not accept :term:`bytes-like objects <bytes-like object>`.  "
"If you want to accept filesystem paths and convert them to C character "
"strings, it is preferable to use the ``O&`` format with :c:func:"
"`PyUnicode_FSConverter` as *converter*."
msgstr ""
"このフォーマットは :term:`bytes-like objects <bytes-like object>` をサポート"
"しません。\n"
"ファイルシステムパスを受け取って C 言語の文字列に変換したい場合は、 ``O&`` "
"フォーマットを、\n"
"*converter* に :c:func:`PyUnicode_FSConverter` を指定して利用すると良いです。"

#: ../../c-api/arg.rst:96
msgid ""
"Previously, :exc:`TypeError` was raised when embedded null code points were "
"encountered in the Python string."
msgstr ""
"以前は Python 文字列に null コードポイントが埋め込まれていたときに :exc:"
"`TypeError` を送出していました。"

#: ../../c-api/arg.rst:100
msgid "``s*`` (:class:`str` or :term:`bytes-like object`) [Py_buffer]"
msgstr "``s*`` (:class:`str` または :term:`bytes-like object`) [Py_buffer]"

#: ../../c-api/arg.rst:101
msgid ""
"This format accepts Unicode objects as well as bytes-like objects. It fills "
"a :c:type:`Py_buffer` structure provided by the caller. In this case the "
"resulting C string may contain embedded NUL bytes. Unicode objects are "
"converted to C strings using ``'utf-8'`` encoding."
msgstr ""
"このフォーマットは Unicode オブジェクトと bytes-like object を受け付けて、呼"
"び出し元から渡された :c:type:`Py_buffer` 構造体に値を格納します。\n"
"結果の C 文字列は NUL バイトを含むかもしれません。\n"
"Unicode オブジェクトは ``'utf-8'`` エンコーディングで C 文字列に変換されま"
"す。"

#: ../../c-api/arg.rst:106
msgid ""
"``s#`` (:class:`str`, read-only :term:`bytes-like object`) [const char \\*, :"
"c:type:`Py_ssize_t`]"
msgstr ""
"``s#`` (:class:`str`, 読み取り専用の :term:`bytes-like object`) [const char "
"\\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:107
msgid ""
"Like ``s*``, except that it provides a :ref:`borrowed buffer <c-arg-borrowed-"
"buffer>`. The result is stored into two C variables, the first one a pointer "
"to a C string, the second one its length. The string may contain embedded "
"null bytes. Unicode objects are converted to C strings using ``'utf-8'`` "
"encoding."
msgstr ""
"のように ``s*``, ただし、それは :ref:`借用された バッファ <c-arg-borrowed-"
"buffer>`. 結果は2つのC変数に格納されます。最初の変数はC文字列へのポインター、"
"2つ目の変数はその長さです。文字列には埋め込まれたヌルバイトが含まれる可能性が"
"あります。Unicodeオブジェクトは、C文字列に変換されます ``'utf-8'`` エンコー"
"ド。"

#: ../../c-api/arg.rst:113 ../../c-api/arg.rst:614
msgid "``z`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``z`` (:class:`str` または ``None``) [const char \\*]"

#: ../../c-api/arg.rst:114
msgid ""
"Like ``s``, but the Python object may also be ``None``, in which case the C "
"pointer is set to ``NULL``."
msgstr ""
"``s`` に似ていますが、Python オブジェクトは ``None`` でもよく、その場合には "
"C のポインタは ``NULL`` にセットされます。"

#: ../../c-api/arg.rst:117
msgid ""
"``z*`` (:class:`str`, :term:`bytes-like object` or ``None``) [Py_buffer]"
msgstr ""
"``z*`` (:class:`str`, :term:`bytes-like object` または ``None``) [Py_buffer]"

#: ../../c-api/arg.rst:118
msgid ""
"Like ``s*``, but the Python object may also be ``None``, in which case the "
"``buf`` member of the :c:type:`Py_buffer` structure is set to ``NULL``."
msgstr ""
"``s*`` と同じですが、 Python の ``None`` オブジェクトを受け取ることができま"
"す。その場合、 :c:type:`Py_buffer` 構造体の ``buf`` メンバーは ``NULL`` にな"
"ります。"

#: ../../c-api/arg.rst:121
msgid ""
"``z#`` (:class:`str`, read-only :term:`bytes-like object` or ``None``) "
"[const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``z#`` (:class:`str`, 読み出し専用の :term:`bytes-like object` または "
"``None``) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:122
msgid ""
"Like ``s#``, but the Python object may also be ``None``, in which case the C "
"pointer is set to ``NULL``."
msgstr ""
"``s#`` に似ていますが、Python オブジェクトは ``None`` でもよく、その場合には "
"C のポインタは ``NULL`` にセットされます。"

#: ../../c-api/arg.rst:125
msgid "``y`` (read-only :term:`bytes-like object`) [const char \\*]"
msgstr "``y`` (読み出し専用の :term:`bytes-like object`) [const char \\*]"

#: ../../c-api/arg.rst:126
msgid ""
"This format converts a bytes-like object to a C pointer to a :ref:`borrowed "
"<c-arg-borrowed-buffer>` character string; it does not accept Unicode "
"objects.  The bytes buffer must not contain embedded null bytes; if it does, "
"a :exc:`ValueError` exception is raised."
msgstr ""
"この形式は bytes-like Cポインタへのオブジェクトへの参照を拒否する :ref:"
"`borrowed <c-arg-borrowed-buffer>` 文字列; Unicode オブジェクトは受け付けませ"
"ん。 バイトバッファには埋め込みのヌルバイトを含んではいけません。もし含まれて"
"いる場合 :exc:`ValueError` 例外が発生します。"

#: ../../c-api/arg.rst:132
msgid ""
"Previously, :exc:`TypeError` was raised when embedded null bytes were "
"encountered in the bytes buffer."
msgstr ""
"以前は bytes バッファにヌルバイトが埋め込まれていたときに :exc:`TypeError` を"
"送出していました。"

#: ../../c-api/arg.rst:136
msgid "``y*`` (:term:`bytes-like object`) [Py_buffer]"
msgstr "``y*`` (:term:`bytes-like object`) [Py_buffer]"

#: ../../c-api/arg.rst:137
msgid ""
"This variant on ``s*`` doesn't accept Unicode objects, only bytes-like "
"objects.  **This is the recommended way to accept binary data.**"
msgstr ""
"``s*`` の変形で、 Unicode オブジェクトを受け付けず、 bytes-like object のみを"
"受け付けます。\n"
"**バイナリデータを受け付ける目的には、このフォーマットを使うことを推奨しま"
"す。**"

#: ../../c-api/arg.rst:141
msgid ""
"``y#`` (read-only :term:`bytes-like object`) [const char \\*, :c:type:"
"`Py_ssize_t`]"
msgstr ""
"``y#`` (読み出し専用の :term:`bytes-like object`) [const char \\*, :c:type:"
"`Py_ssize_t`]"

#: ../../c-api/arg.rst:142
msgid ""
"This variant on ``s#`` doesn't accept Unicode objects, only bytes-like "
"objects."
msgstr ""
"``s#`` の変形で、 Unicode オブジェクトを受け付けず、bytes-like object だけを"
"受け付けます。"

#: ../../c-api/arg.rst:145
msgid "``S`` (:class:`bytes`) [PyBytesObject \\*]"
msgstr "``S`` (:class:`bytes`) [PyBytesObject \\*]"

#: ../../c-api/arg.rst:146
msgid ""
"Requires that the Python object is a :class:`bytes` object, without "
"attempting any conversion.  Raises :exc:`TypeError` if the object is not a "
"bytes object.  The C variable may also be declared as :c:expr:`PyObject*`."
msgstr ""
"Pythonオブジェクトとして、 :class:`bytes` オブジェクトを要求し、いかなる変換"
"も行いません。オブジェクトが bytes オブジェクトでなければ、 :exc:`TypeError` "
"を送出します。C 変数は :c:expr:`PyObject*` と宣言しても構いません。"

#: ../../c-api/arg.rst:150
msgid "``Y`` (:class:`bytearray`) [PyByteArrayObject \\*]"
msgstr "``Y`` (:class:`bytearray`) [PyByteArrayObject \\*]"

#: ../../c-api/arg.rst:151
msgid ""
"Requires that the Python object is a :class:`bytearray` object, without "
"attempting any conversion.  Raises :exc:`TypeError` if the object is not a :"
"class:`bytearray` object. The C variable may also be declared as :c:expr:"
"`PyObject*`."
msgstr ""
"Python オブジェクトとして :class:`bytearray` オブジェクトを要求し、いかなる変"
"換もおこないません。 もしオブジェクトが :class:`bytearray` でなければ、 :exc:"
"`TypeError` を送出します。C 変数は :c:expr:`PyObject*` として宣言しても構いま"
"せん。"

#: ../../c-api/arg.rst:155
msgid "``U`` (:class:`str`) [PyObject \\*]"
msgstr "``U`` (:class:`str`) [PyObject \\*]"

#: ../../c-api/arg.rst:156
msgid ""
"Requires that the Python object is a Unicode object, without attempting any "
"conversion.  Raises :exc:`TypeError` if the object is not a Unicode object.  "
"The C variable may also be declared as :c:expr:`PyObject*`."
msgstr ""
"Python オブジェクトとして Unicode オブジェクトを要求し、いかなる変換も行いま"
"せん。オブジェクトが Unicode オブジェクトではない場合、 :exc:`TypeError` が送"
"出されます。C変数は :c:expr:`PyObject*` として宣言しても構いません。"

#: ../../c-api/arg.rst:160
msgid "``w*`` (read-write :term:`bytes-like object`) [Py_buffer]"
msgstr "``w*`` (読み書き可能な :term:`bytes-like object`) [Py_buffer]"

#: ../../c-api/arg.rst:161
msgid ""
"This format accepts any object which implements the read-write buffer "
"interface. It fills a :c:type:`Py_buffer` structure provided by the caller. "
"The buffer may contain embedded null bytes. The caller has to call :c:func:"
"`PyBuffer_Release` when it is done with the buffer."
msgstr ""

#: ../../c-api/arg.rst:166
msgid "``es`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer]"
msgstr "``es`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer]"

#: ../../c-api/arg.rst:167
msgid ""
"This variant on ``s`` is used for encoding Unicode into a character buffer. "
"It only works for encoded data without embedded NUL bytes."
msgstr ""
"これは ``s`` の変化形で、Unicodeをキャラクタ型バッファにエンコードするために"
"用いられます。NULバイトが埋め込まれていないデータでのみ動作します。"

#: ../../c-api/arg.rst:170
msgid ""
"This format requires two arguments.  The first is only used as input, and "
"must be a :c:expr:`const char*` which points to the name of an encoding as a "
"NUL-terminated string, or ``NULL``, in which case ``'utf-8'`` encoding is "
"used. An exception is raised if the named encoding is not known to Python.  "
"The second argument must be a :c:expr:`char**`; the value of the pointer it "
"references will be set to a buffer with the contents of the argument text. "
"The text will be encoded in the encoding specified by the first argument."
msgstr ""
"この書式には二つの引数が必要です。一つ目は入力にのみ用いられ、 NUL で終端され"
"たエンコード名文字列を指す :c:expr:`const char*` 型または、 ``'utf-8'`` が使"
"われることを表す ``NULL`` でなければなりません。指定したエンコード名を "
"Python が理解できない場合には例外を送出します。第二の引数は :c:expr:`char**` "
"でなければなりません; この引数が参照しているポインタの値は、引数に指定したテ"
"キストの内容が入ったバッファへのポインタになります。テキストは最初の引数に指"
"定したエンコード方式でエンコードされます。"

#: ../../c-api/arg.rst:178
msgid ""
":c:func:`PyArg_ParseTuple` will allocate a buffer of the needed size, copy "
"the encoded data into this buffer and adjust *\\*buffer* to reference the "
"newly allocated storage.  The caller is responsible for calling :c:func:"
"`PyMem_Free` to free the allocated buffer after use."
msgstr ""
":c:func:`PyArg_ParseTuple` を使うと、必要なサイズのバッファを確保し、そのバッ"
"ファにエンコード後のデータをコピーして、 *\\*buffer* がこの新たに確保された記"
"憶領域を指すように変更します。呼び出し側には、確保されたバッファを使い終わっ"
"た後に :c:func:`PyMem_Free` で解放する責任があります。"

#: ../../c-api/arg.rst:183
msgid ""
"``et`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer]"
msgstr ""
"``et`` (:class:`str`, :class:`bytes` または :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer]"

#: ../../c-api/arg.rst:184
msgid ""
"Same as ``es`` except that byte string objects are passed through without "
"recoding them.  Instead, the implementation assumes that the byte string "
"object uses the encoding passed in as parameter."
msgstr ""
"``es`` と同じです。ただし、バイト文字列オブジェクトをエンコードし直さずに渡し"
"ます。その代わり、実装ではバイト文字列オブジェクトがパラメタに渡したエンコー"
"ドを使っているものと仮定します。"

#: ../../c-api/arg.rst:188
msgid ""
"``es#`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer, :c:type:"
"`Py_ssize_t` \\*buffer_length]"
msgstr ""
"``es#`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer, :c:type:"
"`Py_ssize_t` \\*buffer_length]"

#: ../../c-api/arg.rst:189
msgid ""
"This variant on ``s#`` is used for encoding Unicode into a character buffer. "
"Unlike the ``es`` format, this variant allows input data which contains NUL "
"characters."
msgstr ""
"``s#`` の変化形で、Unicode をキャラクタ型バッファにエンコードするために用いら"
"れます。``es`` 書式違って、この変化形はバイトが埋め込まれていてもかまいませ"
"ん。"

#: ../../c-api/arg.rst:193
msgid ""
"It requires three arguments.  The first is only used as input, and must be "
"a :c:expr:`const char*` which points to the name of an encoding as a NUL-"
"terminated string, or ``NULL``, in which case ``'utf-8'`` encoding is used. "
"An exception is raised if the named encoding is not known to Python.  The "
"second argument must be a :c:expr:`char**`; the value of the pointer it "
"references will be set to a buffer with the contents of the argument text. "
"The text will be encoded in the encoding specified by the first argument. "
"The third argument must be a pointer to an integer; the referenced integer "
"will be set to the number of bytes in the output buffer."
msgstr ""
"この書式には三つの引数が必要です。一つ目は入力にのみ用いられ、 NUL で終端され"
"たエンコード名文字列を指す :c:expr:`const char*` 型か ``NULL`` でなければなり"
"ません。 ``NULL`` の場合には ``'utf-8'`` を使います。指定したエンコード名を "
"Python が理解できない場合には例外を送出します。第二の引数は :c:expr:`char**` "
"でなければなりません; この引数が参照しているポインタの値は、引数に指定したテ"
"キストの内容が入ったバッファへのポインタになります。テキストは最初の引数に指"
"定したエンコード方式でエンコードされます。第三の引数は整数へのポインタでなけ"
"ればなりません; ポインタが参照している整数の値は出力バッファ内のバイト数に"
"セットされます。"

#: ../../c-api/arg.rst:203
msgid "There are two modes of operation:"
msgstr "この書式の処理には二つのモードがあります:"

#: ../../c-api/arg.rst:205
msgid ""
"If *\\*buffer* points a ``NULL`` pointer, the function will allocate a "
"buffer of the needed size, copy the encoded data into this buffer and set "
"*\\*buffer* to reference the newly allocated storage.  The caller is "
"responsible for calling :c:func:`PyMem_Free` to free the allocated buffer "
"after usage."
msgstr ""
"*\\*buffer* が ``NULL`` ポインタを指している場合、関数は必要なサイズのバッ"
"ファを確保し、そのバッファにエンコード後のデータをコピーして、 *\\*buffer* が"
"この新たに確保された記憶領域を指すように変更します。呼び出し側には、確保され"
"たバッファを使い終わった後に :c:func:`PyMem_Free` で解放する責任があります。"

#: ../../c-api/arg.rst:210
msgid ""
"If *\\*buffer* points to a non-``NULL`` pointer (an already allocated "
"buffer), :c:func:`PyArg_ParseTuple` will use this location as the buffer and "
"interpret the initial value of *\\*buffer_length* as the buffer size.  It "
"will then copy the encoded data into the buffer and NUL-terminate it.  If "
"the buffer is not large enough, a :exc:`ValueError` will be set."
msgstr ""
"*\\*buffer* が非 ``NULL`` のポインタ (すでにメモリ確保済みのバッファ) を指し"
"ている場合、 :c:func:`PyArg_ParseTuple` はこのメモリ位置をバッファとして用"
"い、 *\\*buffer_length* の初期値をバッファサイズとして用います。 "
"PyArg_ParseTuple は次にエンコード済みのデータをバッファにコピーして、NUL で終"
"端します。バッファの大きさが足りなければ :exc:`ValueError` がセットされます。"

#: ../../c-api/arg.rst:216
msgid ""
"In both cases, *\\*buffer_length* is set to the length of the encoded data "
"without the trailing NUL byte."
msgstr ""
"どちらの場合も、 *\\*buffer_length* は終端の NUL バイトを含まないエンコード済"
"みデータの長さにセットされます。"

#: ../../c-api/arg.rst:219
msgid ""
"``et#`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer, :c:type:`Py_ssize_t` \\*buffer_length]"
msgstr ""
"``et#`` (:class:`str`, :class:`bytes` または :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer, :c:type:`Py_ssize_t` \\*buffer_length]"

#: ../../c-api/arg.rst:220
msgid ""
"Same as ``es#`` except that byte string objects are passed through without "
"recoding them. Instead, the implementation assumes that the byte string "
"object uses the encoding passed in as parameter."
msgstr ""
"``es#`` と同じです。ただし、バイト文字列オブジェクトをエンコードし直さずに渡"
"します。その代わり、実装ではバイト文字列オブジェクトがパラメタに渡したエン"
"コードを使っているものと仮定します。"

#: ../../c-api/arg.rst:224
msgid ""
"``u``, ``u#``, ``Z``, and ``Z#`` are removed because they used a legacy "
"``Py_UNICODE*`` representation."
msgstr ""

#: ../../c-api/arg.rst:230
msgid "Numbers"
msgstr "数"

#: ../../c-api/arg.rst:232
msgid ""
"These formats allow representing Python numbers or single characters as C "
"numbers. Formats that require :class:`int`, :class:`float` or :class:"
"`complex` can also use the corresponding special methods :meth:`~object."
"__index__`, :meth:`~object.__float__` or :meth:`~object.__complex__` to "
"convert the Python object to the required type."
msgstr ""

#: ../../c-api/arg.rst:238
msgid ""
"For signed integer formats, :exc:`OverflowError` is raised if the value is "
"out of range for the C type. For unsigned integer formats, no range checking "
"is done --- the most significant bits are silently truncated when the "
"receiving field is too small to receive the value."
msgstr ""

#: ../../c-api/arg.rst:244
msgid "``b`` (:class:`int`) [unsigned char]"
msgstr "``b`` (:class:`int`) [unsigned char]"

#: ../../c-api/arg.rst:245
msgid ""
"Convert a nonnegative Python integer to an unsigned tiny integer, stored in "
"a C :c:expr:`unsigned char`."
msgstr ""

#: ../../c-api/arg.rst:248 ../../c-api/arg.rst:648
msgid "``B`` (:class:`int`) [unsigned char]"
msgstr "``B`` (:class:`int`) [unsigned char]"

#: ../../c-api/arg.rst:249
msgid ""
"Convert a Python integer to a tiny integer without overflow checking, stored "
"in a C :c:expr:`unsigned char`."
msgstr ""

#: ../../c-api/arg.rst:252 ../../c-api/arg.rst:642
msgid "``h`` (:class:`int`) [short int]"
msgstr "``h`` (:class:`int`) [short int]"

#: ../../c-api/arg.rst:253
msgid "Convert a Python integer to a C :c:expr:`short int`."
msgstr "Python の整数を、 C の :c:expr:`short int` 型に変換します。"

#: ../../c-api/arg.rst:255 ../../c-api/arg.rst:651
msgid "``H`` (:class:`int`) [unsigned short int]"
msgstr "``H`` (:class:`int`) [unsigned short int]"

#: ../../c-api/arg.rst:256
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned short int`, without "
"overflow checking."
msgstr ""
"Python の整数を、オーバフローチェックを行わずに、 C の :c:expr:`unsigned "
"short int` 型に変換します。"

#: ../../c-api/arg.rst:259 ../../c-api/arg.rst:636
msgid "``i`` (:class:`int`) [int]"
msgstr "``i`` (:class:`int`) [int]"

#: ../../c-api/arg.rst:260
msgid "Convert a Python integer to a plain C :c:expr:`int`."
msgstr "Python の整数を、 C の :c:expr:`int` 型に変換します。"

#: ../../c-api/arg.rst:262 ../../c-api/arg.rst:654
msgid "``I`` (:class:`int`) [unsigned int]"
msgstr "``I`` (:class:`int`) [unsigned int]"

#: ../../c-api/arg.rst:263
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned int`, without overflow "
"checking."
msgstr ""
"Python の整数を、オーバフローチェックを行わずに、 C の :c:expr:`unsigned "
"int` 型に変換します。"

#: ../../c-api/arg.rst:266 ../../c-api/arg.rst:645
msgid "``l`` (:class:`int`) [long int]"
msgstr "``l`` (:class:`int`) [long int]"

#: ../../c-api/arg.rst:267
msgid "Convert a Python integer to a C :c:expr:`long int`."
msgstr "Python の整数を、 C の :c:expr:`long int` 型に変換します。"

#: ../../c-api/arg.rst:269 ../../c-api/arg.rst:657
msgid "``k`` (:class:`int`) [unsigned long]"
msgstr "``k`` (:class:`int`) [unsigned long]"

#: ../../c-api/arg.rst:270
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned long` without overflow "
"checking."
msgstr ""
"Python の整数を、オーバフローチェックを行わずに、 C の :c:expr:`unsigned "
"long` 型に変換します。"

#: ../../c-api/arg.rst:273 ../../c-api/arg.rst:283
msgid "Use :meth:`~object.__index__` if available."
msgstr "可能であれば :meth:`~object.__index__` を使うようになりました。"

#: ../../c-api/arg.rst:276 ../../c-api/arg.rst:660
msgid "``L`` (:class:`int`) [long long]"
msgstr "``L`` (:class:`int`) [long long]"

#: ../../c-api/arg.rst:277
msgid "Convert a Python integer to a C :c:expr:`long long`."
msgstr "Python の整数を、 C の :c:expr:`long long` 型に変換します。"

#: ../../c-api/arg.rst:279 ../../c-api/arg.rst:665
msgid "``K`` (:class:`int`) [unsigned long long]"
msgstr "``K`` (:class:`int`) [unsigned long long]"

#: ../../c-api/arg.rst:280
msgid ""
"Convert a Python integer to a C :c:expr:`unsigned long long` without "
"overflow checking."
msgstr ""
"PythonのintをC :c:expr:`unsigned long long` へオーバーフローの確認をせず変換"
"する"

#: ../../c-api/arg.rst:286 ../../c-api/arg.rst:668
msgid "``n`` (:class:`int`) [:c:type:`Py_ssize_t`]"
msgstr "``n`` (:class:`int`) [:c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:287
msgid "Convert a Python integer to a C :c:type:`Py_ssize_t`."
msgstr "Python の整数をCの :c:type:`Py_ssize_t` 型に変換します。"

#: ../../c-api/arg.rst:289
msgid "``c`` (:class:`bytes` or :class:`bytearray` of length 1) [char]"
msgstr "``c`` (長さ 1 の、 :class:`bytes` または :class:`bytearray`) [char]"

#: ../../c-api/arg.rst:290
msgid ""
"Convert a Python byte, represented as a :class:`bytes` or :class:`bytearray` "
"object of length 1, to a C :c:expr:`char`."
msgstr ""
"長さ 1 の :class:`bytes` または :class:`bytearray` オブジェクトとして表現され"
"ている Python バイトを C の :c:expr:`char` 型に変換します。"

#: ../../c-api/arg.rst:293
msgid "Allow :class:`bytearray` objects."
msgstr ":class:`bytearray` を受け付けるようになりました。"

#: ../../c-api/arg.rst:296 ../../c-api/arg.rst:686
msgid "``C`` (:class:`str` of length 1) [int]"
msgstr "``C`` (長さ 1 の :class:`str`) [int]"

#: ../../c-api/arg.rst:297
msgid ""
"Convert a Python character, represented as a :class:`str` object of length "
"1, to a C :c:expr:`int`."
msgstr ""
"長さ 1 の :class:`str` オブジェクトとして表現されている Python キャラクタを "
"C の :c:expr:`int` 型に変換します。"

#: ../../c-api/arg.rst:300 ../../c-api/arg.rst:693
msgid "``f`` (:class:`float`) [float]"
msgstr "``f`` (:class:`float`) [float]"

#: ../../c-api/arg.rst:301
msgid "Convert a Python floating-point number to a C :c:expr:`float`."
msgstr ""

#: ../../c-api/arg.rst:303 ../../c-api/arg.rst:690
msgid "``d`` (:class:`float`) [double]"
msgstr "``d`` (:class:`float`) [double]"

#: ../../c-api/arg.rst:304
msgid "Convert a Python floating-point number to a C :c:expr:`double`."
msgstr ""

#: ../../c-api/arg.rst:306
msgid "``D`` (:class:`complex`) [Py_complex]"
msgstr "``D`` (:class:`complex`) [Py_complex]"

#: ../../c-api/arg.rst:307
msgid "Convert a Python complex number to a C :c:type:`Py_complex` structure."
msgstr "Python の複素数型を、 C の :c:type:`Py_complex` 構造体に変換します。"

#: ../../c-api/arg.rst:310
msgid "Other objects"
msgstr "その他のオブジェクト"

#: ../../c-api/arg.rst:312 ../../c-api/arg.rst:699
msgid "``O`` (object) [PyObject \\*]"
msgstr "``O`` (object) [PyObject \\*]"

#: ../../c-api/arg.rst:313
msgid ""
"Store a Python object (without any conversion) in a C object pointer.  The C "
"program thus receives the actual object that was passed.  A new :term:"
"`strong reference` to the object is not created (i.e. its reference count is "
"not increased). The pointer stored is not ``NULL``."
msgstr ""
"Python オブジェクトを（変換なしで）C オブジェクトのポインターに格納します。 "
"これにより、C プログラムは渡された実際のオブジェクトを受け取ります。新しい :"
"term: 強参照 オブジェクトが作成されていません （すなわち、その参照カウント 増"
"加しません)。その ポインタ 保存されていない ``NULL``."

#: ../../c-api/arg.rst:319
msgid "``O!`` (object) [*typeobject*, PyObject \\*]"
msgstr "``O!`` (object) [*typeobject*, PyObject \\*]"

#: ../../c-api/arg.rst:320
msgid ""
"Store a Python object in a C object pointer.  This is similar to ``O``, but "
"takes two C arguments: the first is the address of a Python type object, the "
"second is the address of the C variable (of type :c:expr:`PyObject*`) into "
"which the object pointer is stored.  If the Python object does not have the "
"required type, :exc:`TypeError` is raised."
msgstr ""
"Python オブジェクトを C の Python オブジェクト型ポインタに保存します。 ``O`` "
"に似ていますが、二つの C の引数をとります: 一つ目の引数は Python の型オブジェ"
"クトへのアドレスで、二つ目の引数はオブジェクトへのポインタが保存されている (:"
"c:expr:`PyObject*` の) C の変数へのアドレスです。Python オブジェクトが指定し"
"た型ではない場合、 :exc:`TypeError` を送出します。"

#: ../../c-api/arg.rst:328
msgid "``O&`` (object) [*converter*, *address*]"
msgstr ""

#: ../../c-api/arg.rst:329
msgid ""
"Convert a Python object to a C variable through a *converter* function.  "
"This takes two arguments: the first is a function, the second is the address "
"of a C variable (of arbitrary type), converted to :c:expr:`void *`.  The "
"*converter* function in turn is called as follows::"
msgstr ""
"Python オブジェクトを *converter* 関数を介して C の変数に変換します。二つの引"
"数をとります: 一つ目は関数で、二つ目は (任意の型の) C 変数へのアドレスを :c:"
"expr:`void *` 型に変換したものです。 *converter* は以下のようにして呼び出され"
"ます::"

#: ../../c-api/arg.rst:334
msgid "status = converter(object, address);"
msgstr ""

#: ../../c-api/arg.rst:336
msgid ""
"where *object* is the Python object to be converted and *address* is the :c:"
"expr:`void*` argument that was passed to the ``PyArg_Parse*`` function. The "
"returned *status* should be ``1`` for a successful conversion and ``0`` if "
"the conversion has failed.  When the conversion fails, the *converter* "
"function should raise an exception and leave the content of *address* "
"unmodified."
msgstr ""
"ここで *object* は変換対象の Python オブジェクトで、 *address* は "
"``PyArg_Parse*`` に渡した :c:expr:`void*`  型の引数です。戻り値 *status* は変"
"換に成功した際に ``1``,失敗した場合には ``0`` になります。変換に失敗した場"
"合、 *converter* 関数は *address* の内容を変更せずに例外を送出しなくてはなり"
"ません。"

#: ../../c-api/arg.rst:345
msgid ""
"If the *converter* returns :c:macro:`!Py_CLEANUP_SUPPORTED`, it may get "
"called a second time if the argument parsing eventually fails, giving the "
"converter a chance to release any memory that it had already allocated. In "
"this second call, the *object* parameter will be ``NULL``; *address* will "
"have the same value as in the original call."
msgstr ""

#: ../../c-api/arg.rst:351
msgid ""
"Examples of converters: :c:func:`PyUnicode_FSConverter` and :c:func:"
"`PyUnicode_FSDecoder`."
msgstr ""

#: ../../c-api/arg.rst:354
msgid ":c:macro:`!Py_CLEANUP_SUPPORTED` was added."
msgstr ""

#: ../../c-api/arg.rst:357 ../../c-api/arg.rst:671
msgid "``p`` (:class:`bool`) [int]"
msgstr "``p`` (:class:`bool`) [int]"

#: ../../c-api/arg.rst:358
msgid ""
"Tests the value passed in for truth (a boolean **p**\\ redicate) and "
"converts the result to its equivalent C true/false integer value. Sets the "
"int to ``1`` if the expression was true and ``0`` if it was false. This "
"accepts any valid Python value.  See :ref:`truth` for more information about "
"how Python tests values for truth."
msgstr ""
"真偽値が求められる箇所 (a boolean **p**\\ redicate) に渡された値を判定し、そ"
"の結果を等価な C の true/false 整数値に変換します。\n"
"もし式が真なら int には ``1`` が、偽なら ``0`` が設定されます。この関数は任意"
"の有効なPython値を受け付けます。\n"
"Pythonが値の真偽をどのように判定するかを知りたければ、 :ref:`truth` を参照し"
"てください。"

#: ../../c-api/arg.rst:366
msgid "``(items)`` (sequence) [*matching-items*]"
msgstr ""

#: ../../c-api/arg.rst:367
msgid ""
"The object must be a Python sequence (except :class:`str`, :class:`bytes` "
"or :class:`bytearray`) whose length is the number of format units in "
"*items*.  The C arguments must correspond to the individual format units in "
"*items*.  Format units for sequences may be nested."
msgstr ""

#: ../../c-api/arg.rst:372
msgid ""
"If *items* contains format units which store a :ref:`borrowed buffer <c-arg-"
"borrowed-buffer>` (``s``, ``s#``, ``z``, ``z#``, ``y``, or ``y#``) or a :"
"term:`borrowed reference` (``S``, ``Y``, ``U``, ``O``, or ``O!``), the "
"object must be a Python tuple. The *converter* for the ``O&`` format unit in "
"*items* must not store a borrowed buffer or a borrowed reference."
msgstr ""

#: ../../c-api/arg.rst:379
msgid ""
":class:`str` and :class:`bytearray` objects no longer accepted as a sequence."
msgstr ""

#: ../../c-api/arg.rst:382
msgid ""
"Non-tuple sequences are deprecated if *items* contains format units which "
"store a borrowed buffer or a borrowed reference."
msgstr ""

#: ../../c-api/arg.rst:386
msgid ""
"A few other characters have a meaning in a format string.  These may not "
"occur inside nested parentheses.  They are:"
msgstr ""
"その他、書式文字列において意味を持つ文字がいくつかあります。それらの文字は括"
"弧による入れ子内には使えません。以下に文字を示します:"

#: ../../c-api/arg.rst:389
msgid "``|``"
msgstr "``|``"

#: ../../c-api/arg.rst:390
msgid ""
"Indicates that the remaining arguments in the Python argument list are "
"optional. The C variables corresponding to optional arguments should be "
"initialized to their default value --- when an optional argument is not "
"specified, :c:func:`PyArg_ParseTuple` does not touch the contents of the "
"corresponding C variable(s)."
msgstr ""
"Python 引数リスト中で、この文字以降の引数がオプションであることを示します。オ"
"プションの引数に対応する C の変数はデフォルトの値で初期化しておかなければなり"
"ません --- オプションの引数が省略された場合、 :c:func:`PyArg_ParseTuple` は対"
"応する C 変数の内容に手を加えません。"

#: ../../c-api/arg.rst:396
msgid "``$``"
msgstr "``$``"

#: ../../c-api/arg.rst:397
msgid ""
":c:func:`PyArg_ParseTupleAndKeywords` only: Indicates that the remaining "
"arguments in the Python argument list are keyword-only.  Currently, all "
"keyword-only arguments must also be optional arguments, so ``|`` must always "
"be specified before ``$`` in the format string."
msgstr ""
":c:func:`PyArg_ParseTupleAndKeywords` でのみ使用可能: 後続のPython引数がキー"
"ワード専用であることを示します。\n"
"現在、すべてのキーワード専用引数は任意の引数でなければならず、そのため フォー"
"マット文字列中の ``|`` は常に ``$`` より前に指定されなければなりません。"

#: ../../c-api/arg.rst:405
msgid "``:``"
msgstr "``:``"

#: ../../c-api/arg.rst:406
msgid ""
"The list of format units ends here; the string after the colon is used as "
"the function name in error messages (the \"associated value\" of the "
"exception that :c:func:`PyArg_ParseTuple` raises)."
msgstr ""
"この文字があると、書式単位の記述はそこで終わります; コロン以降の文字列は、エ"
"ラーメッセージにおける関数名 (:c:func:`PyArg_ParseTuple` が送出する例外の "
"\"付属値 (associated value)\") として使われます。"

#: ../../c-api/arg.rst:410
msgid "``;``"
msgstr "``;``"

#: ../../c-api/arg.rst:411
msgid ""
"The list of format units ends here; the string after the semicolon is used "
"as the error message *instead* of the default error message.  ``:`` and ``;"
"`` mutually exclude each other."
msgstr ""
"この文字があると、書式単位の記述はそこで終わります; セミコロン以降の文字列"
"は、デフォルトエラーメッセージを *置き換える* エラーメッセージとして使われま"
"す。 ``:`` と ``;`` は相互に排他の文字です。"

#: ../../c-api/arg.rst:415
msgid ""
"Note that any Python object references which are provided to the caller are "
"*borrowed* references; do not release them (i.e. do not decrement their "
"reference count)!"
msgstr ""
"注意：呼び出し元に渡されるPythonオブジェクトの参照はすべて*借用*された参照で"
"す。これらを解放しないでください（つまり、参照カウントを減らさないでくださ"
"い）！"

#: ../../c-api/arg.rst:419
msgid ""
"Additional arguments passed to these functions must be addresses of "
"variables whose type is determined by the format string; these are used to "
"store values from the input tuple.  There are a few cases, as described in "
"the list of format units above, where these parameters are used as input "
"values; they should match what is specified for the corresponding format "
"unit in that case."
msgstr ""
"以下の関数に渡す補助引数 (additional argument) は、書式文字列から決定される型"
"へのアドレスでなければなりません; 補助引数に指定したアドレスは、タプルから入"
"力された値を保存するために使います。上の書式単位のリストで説明したように、補"
"助引数を入力値として使う場合がいくつかあります; その場合、対応する書式単位の"
"指定する形式に従うようにしなければなりません。"

#: ../../c-api/arg.rst:425
msgid ""
"For the conversion to succeed, the *arg* object must match the format and "
"the format must be exhausted.  On success, the ``PyArg_Parse*`` functions "
"return true, otherwise they return false and raise an appropriate exception. "
"When the ``PyArg_Parse*`` functions fail due to conversion failure in one of "
"the format units, the variables at the addresses corresponding to that and "
"the following format units are left untouched."
msgstr ""
"変換を正しく行うためには、 *arg* オブジェクトは書式文字に一致しなければなら"
"ず、かつ書式文字列内の書式単位に全て値が入るようにしなければなりません。成功"
"すると、 ``PyArg_Parse*`` 関数は真を返します。それ以外の場合には偽を返し、適"
"切な例外を送出します。書式単位のどれかの変換失敗により ``PyArg_Parse*`` が失"
"敗した場合、失敗した書式単位に対応するアドレスとそれ以降のアドレスの内容は変"
"更されません。"

#: ../../c-api/arg.rst:434
msgid "API Functions"
msgstr "API 関数"

#: ../../c-api/arg.rst:438
msgid ""
"Parse the parameters of a function that takes only positional parameters "
"into local variables.  Returns true on success; on failure, it returns false "
"and raises the appropriate exception."
msgstr ""
"位置引数のみを引数にとる関数のパラメタを解釈して、ローカルな変数に変換しま"
"す。成功すると真を返します;失敗すると偽を返し、適切な例外を送出します。"

#: ../../c-api/arg.rst:445
msgid ""
"Identical to :c:func:`PyArg_ParseTuple`, except that it accepts a va_list "
"rather than a variable number of arguments."
msgstr ""
":c:func:`PyArg_ParseTuple` と同じですが、可変長の引数ではなく *va_list* を引"
"数にとります。"

#: ../../c-api/arg.rst:451
msgid ""
"Parse the parameters of a function that takes both positional and keyword "
"parameters into local variables. The *keywords* argument is a ``NULL``-"
"terminated array of keyword parameter names specified as null-terminated "
"ASCII or UTF-8 encoded C strings. Empty names denote :ref:`positional-only "
"parameters <positional-only_parameter>`. Returns true on success; on "
"failure, it returns false and raises the appropriate exception."
msgstr ""

#: ../../c-api/arg.rst:462
msgid ""
"The *keywords* parameter declaration is :c:expr:`char * const *` in C and :c:"
"expr:`const char * const *` in C++. This can be overridden with the :c:macro:"
"`PY_CXX_CONST` macro."
msgstr ""

#: ../../c-api/arg.rst:466
msgid ""
"Added support for :ref:`positional-only parameters <positional-"
"only_parameter>`."
msgstr ":ref:`位置専用引数 <positional-only_parameter>` を追加した。"

#: ../../c-api/arg.rst:470
msgid ""
"The *keywords* parameter has now type :c:expr:`char * const *` in C and :c:"
"expr:`const char * const *` in C++, instead of :c:expr:`char **`. Added "
"support for non-ASCII keyword parameter names."
msgstr ""

#: ../../c-api/arg.rst:479
msgid ""
"Identical to :c:func:`PyArg_ParseTupleAndKeywords`, except that it accepts a "
"va_list rather than a variable number of arguments."
msgstr ""
":c:func:`PyArg_ParseTupleAndKeywords` と同じですが、可変長の引数ではなく "
"*va_list* を引数にとります。"

#: ../../c-api/arg.rst:485
msgid ""
"Ensure that the keys in the keywords argument dictionary are strings.  This "
"is only needed if :c:func:`PyArg_ParseTupleAndKeywords` is not used, since "
"the latter already does this check."
msgstr ""
"キーワード引数を格納した辞書のキーが文字列であることを確認します。この関数"
"は :c:func:`PyArg_ParseTupleAndKeywords` を使用しないときにのみ必要で、その理"
"由は後者の関数は同様のチェックを実施するためです。"

#: ../../c-api/arg.rst:494
msgid ""
"Parse the parameter of a function that takes a single positional parameter "
"into a local variable.  Returns true on success; on failure, it returns "
"false and raises the appropriate exception."
msgstr ""

#: ../../c-api/arg.rst:498
msgid "Example::"
msgstr "以下はプログラム例です::"

#: ../../c-api/arg.rst:500
msgid ""
"// Function using METH_O calling convention\n"
"static PyObject*\n"
"my_function(PyObject *module, PyObject *arg)\n"
"{\n"
"    int value;\n"
"    if (!PyArg_Parse(arg, \"i:my_function\", &value)) {\n"
"        return NULL;\n"
"    }\n"
"    // ... use value ...\n"
"}"
msgstr ""

#: ../../c-api/arg.rst:514
msgid ""
"A simpler form of parameter retrieval which does not use a format string to "
"specify the types of the arguments.  Functions which use this method to "
"retrieve their parameters should be declared as :c:macro:`METH_VARARGS` in "
"function or method tables.  The tuple containing the actual parameters "
"should be passed as *args*; it must actually be a tuple.  The length of the "
"tuple must be at least *min* and no more than *max*; *min* and *max* may be "
"equal.  Additional arguments must be passed to the function, each of which "
"should be a pointer to a :c:expr:`PyObject*` variable; these will be filled "
"in with the values from *args*; they will contain :term:`borrowed references "
"<borrowed reference>`. The variables which correspond to optional parameters "
"not given by *args* will not be filled in; these should be initialized by "
"the caller. This function returns true on success and false if *args* is not "
"a tuple or contains the wrong number of elements; an exception will be set "
"if there was a failure."
msgstr ""
"パラメーターの取得方法のよりシンプルな形式で、使用しないもの a 書式文字列 引"
"数の型を指定する 。関数 これを使用する メソッド 彼らの パラメータ 次のように"
"宣言する必要があります :c:macro:`METH_VARARGS` に 関数 にメソッド テーブル。"
"実際のパラメーターを含むタプルは *args* として渡す必要があります。必ずタプル"
"でなければなりません。タプルの長さは、*min*以上で*max*以下でなければなりませ"
"ん。*min*と*max*は等しい場合もあります。関数には追加の引数を渡す必要があり、"
"各引数はポインターでなければならない ～へ:c:expr:`PyObject*` 変数；これらは"
"*args*の値で埋められる；これらは:term:を含む：借用参照 <borrowed "
"reference>`. *args* で指定されていないオプションパラメーターに対応する変数は"
"初期化されません。これらの変数は呼び出し元で初期化する必要があります。これ 関"
"数 成功した場合にtrueを返し、*args*がタプルでない場合または要素の数が間違って"
"いる場合にfalseを返します。失敗した場合、例外が設定されます。"

#: ../../c-api/arg.rst:529
msgid ""
"This is an example of the use of this function, taken from the sources for "
"the :mod:`!_weakref` helper module for weak references::"
msgstr ""
"これは、この関数の使用例で、ソースコードから抜粋したものです:mod:`!_weakref`"
"弱参照用のヘルパーモジュール:: "

#: ../../c-api/arg.rst:532
msgid ""
"static PyObject *\n"
"weakref_ref(PyObject *self, PyObject *args)\n"
"{\n"
"    PyObject *object;\n"
"    PyObject *callback = NULL;\n"
"    PyObject *result = NULL;\n"
"\n"
"    if (PyArg_UnpackTuple(args, \"ref\", 1, 2, &object, &callback)) {\n"
"        result = PyWeakref_NewRef(object, callback);\n"
"    }\n"
"    return result;\n"
"}"
msgstr ""

#: ../../c-api/arg.rst:545
msgid ""
"The call to :c:func:`PyArg_UnpackTuple` in this example is entirely "
"equivalent to this call to :c:func:`PyArg_ParseTuple`::"
msgstr ""
"この例における :c:func:`PyArg_UnpackTuple` 呼び出しは、 :c:func:"
"`PyArg_ParseTuple` を使った以下の呼び出しと全く等価です::"

#: ../../c-api/arg.rst:548
msgid "PyArg_ParseTuple(args, \"O|O:ref\", &object, &callback)"
msgstr ""

#: ../../c-api/arg.rst:552
msgid ""
"The value to be inserted, if any, before :c:expr:`char * const *` in the "
"*keywords* parameter declaration of :c:func:`PyArg_ParseTupleAndKeywords` "
"and :c:func:`PyArg_VaParseTupleAndKeywords`. Default empty for C and "
"``const`` for C++ (:c:expr:`const char * const *`). To override, define it "
"to the desired value before including :file:`Python.h`."
msgstr ""

#: ../../c-api/arg.rst:566
msgid "Building values"
msgstr "値の構築"

#: ../../c-api/arg.rst:570
msgid ""
"Create a new value based on a format string similar to those accepted by the "
"``PyArg_Parse*`` family of functions and a sequence of values.  Returns the "
"value or ``NULL`` in the case of an error; an exception will be raised if "
"``NULL`` is returned."
msgstr ""
"``PyArg_Parse*`` ファミリの関数が受け取るのと似た形式の書式文字列および値列に"
"基づいて、新たな値を生成します。生成した値を返します。エラーの場合には "
"``NULL`` を返します; ``NULL`` を返す場合、例外を送出するでしょう。"

#: ../../c-api/arg.rst:575
msgid ""
":c:func:`Py_BuildValue` does not always build a tuple.  It builds a tuple "
"only if its format string contains two or more format units.  If the format "
"string is empty, it returns ``None``; if it contains exactly one format "
"unit, it returns whatever object is described by that format unit.  To force "
"it to return a tuple of size 0 or one, parenthesize the format string."
msgstr ""
":c:func:`Py_BuildValue` は常にタプルを生成するとは限りません。この関数がタプ"
"ルを生成するのは、書式文字列に二つ以上の書式単位が入っているときだけです。書"
"式文字列が空の場合 ``None`` を返します; 書式単位が厳密に一つだけ入っている場"
"合、書式単位で指定されている何らかのオブジェクト単体を返します。サイズがゼロ"
"や 1 のタプルを返すように強制するには、丸括弧で囲われた書式文字列を使います。"

#: ../../c-api/arg.rst:581
msgid ""
"When memory buffers are passed as parameters to supply data to build "
"objects, as for the ``s`` and ``s#`` formats, the required data is copied.  "
"Buffers provided by the caller are never referenced by the objects created "
"by :c:func:`Py_BuildValue`.  In other words, if your code invokes :c:func:"
"`malloc` and passes the allocated memory to :c:func:`Py_BuildValue`, your "
"code is responsible for calling :c:func:`free` for that memory once :c:func:"
"`Py_BuildValue` returns."
msgstr ""
"書式単位 ``s`` や ``s#`` の場合のように、オブジェクトを構築する際にデータを供"
"給するためにメモリバッファをパラメタとして渡す場合には、指定したデータはコ"
"ピーされます。 :c:func:`Py_BuildValue` が生成したオブジェクトは、呼び出し側が"
"提供したバッファを決して参照しません。別の言い方をすれば、 :c:func:`malloc` "
"を呼び出してメモリを確保し、それを :c:func:`Py_BuildValue` に渡した場合、コー"
"ド内で :c:func:`Py_BuildValue` が返った後で :c:func:`free` を呼び出す責任があ"
"るということです。"

#: ../../c-api/arg.rst:589
msgid ""
"In the following description, the quoted form is the format unit; the entry "
"in (round) parentheses is the Python object type that the format unit will "
"return; and the entry in [square] brackets is the type of the C value(s) to "
"be passed."
msgstr ""
"以下の説明では、引用符のついた形式は書式単位です; (丸)括弧で囲った部分は書式"
"単位が返す Python のオブジェクト型です; [角] 括弧は関数に渡す値の C 変数型で"
"す。"

#: ../../c-api/arg.rst:593
msgid ""
"The characters space, tab, colon and comma are ignored in format strings "
"(but not within format units such as ``s#``).  This can be used to make long "
"format strings a tad more readable."
msgstr ""
"書式文字列内では、(``s#`` のような書式単位を除いて) スペース、タブ、コロンお"
"よびコンマは無視されます。これらの文字を使うと、長い書式文字列をちょっとだけ"
"読みやすくできます。"

#: ../../c-api/arg.rst:597
msgid "``s`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``s`` (:class:`str` または ``None``) [const char \\*]"

#: ../../c-api/arg.rst:598
msgid ""
"Convert a null-terminated C string to a Python :class:`str` object using "
"``'utf-8'`` encoding. If the C string pointer is ``NULL``, ``None`` is used."
msgstr ""
"null終端された C 文字列を、 ``'utf-8'`` エンコーディングを用いて、 Python :"
"class:`str` オブジェクトに変換します。もし C 文字列ポインタが ``NULL`` の場"
"合、 ``None`` になります。"

#: ../../c-api/arg.rst:601
msgid ""
"``s#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``s#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:602
msgid ""
"Convert a C string and its length to a Python :class:`str` object using "
"``'utf-8'`` encoding. If the C string pointer is ``NULL``, the length is "
"ignored and ``None`` is returned."
msgstr ""
"C 文字列とその長さを ``'utf-8'`` エンコーディングを使って Python :class:"
"`str` オブジェクトに変換します。C 文字列ポインタが ``NULL`` の場合、長さは無"
"視され、 ``None`` になります。"

#: ../../c-api/arg.rst:606
msgid "``y`` (:class:`bytes`) [const char \\*]"
msgstr "``y`` (:class:`bytes`) [const char \\*]"

#: ../../c-api/arg.rst:607
msgid ""
"This converts a C string to a Python :class:`bytes` object.  If the C string "
"pointer is ``NULL``, ``None`` is returned."
msgstr ""
"C 文字列をPython :class:`bytes` オブジェクトに変換します。もしC 文字列ポイン"
"タが ``NULL`` だった場合、``None`` を返します。"

#: ../../c-api/arg.rst:610
msgid "``y#`` (:class:`bytes`) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr "``y#`` (:class:`bytes`) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:611
msgid ""
"This converts a C string and its lengths to a Python object.  If the C "
"string pointer is ``NULL``, ``None`` is returned."
msgstr ""
"これは C 文字列とその長さから Python オブジェクトに変換します。C 文字列ポイン"
"タが ``NULL`` の場合、長さは無視され ``None`` になります。"

#: ../../c-api/arg.rst:615 ../../c-api/arg.rst:631
msgid "Same as ``s``."
msgstr "``s`` と同じです。"

#: ../../c-api/arg.rst:617
msgid ""
"``z#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``z#`` (:class:`str` または ``None``) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:618 ../../c-api/arg.rst:634
msgid "Same as ``s#``."
msgstr "``s#`` と同じです。"

#: ../../c-api/arg.rst:620
msgid "``u`` (:class:`str`) [const wchar_t \\*]"
msgstr "``u`` (:class:`str`) [const wchar_t \\*]"

#: ../../c-api/arg.rst:621
msgid ""
"Convert a null-terminated :c:type:`wchar_t` buffer of Unicode (UTF-16 or "
"UCS-4) data to a Python Unicode object.  If the Unicode buffer pointer is "
"``NULL``, ``None`` is returned."
msgstr ""
"null 終端された Unicode (UTF-16 または UCS-4) データの :c:type:`wchar_t` バッ"
"ファから Python Unicode オブジェクトに変換します。 Unicode バッファポインタ"
"が ``NULL`` の場合、 ``None`` になります。"

#: ../../c-api/arg.rst:625
msgid "``u#`` (:class:`str`) [const wchar_t \\*, :c:type:`Py_ssize_t`]"
msgstr "``u#`` (:class:`str`) [const wchar_t \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:626
msgid ""
"Convert a Unicode (UTF-16 or UCS-4) data buffer and its length to a Python "
"Unicode object.   If the Unicode buffer pointer is ``NULL``, the length is "
"ignored and ``None`` is returned."
msgstr ""
"Unicode (UTF-16 または UCS-4) データのバッファとその長さから Python Unicode "
"オブジェクトに変換します。 Unicode バッファポインタが ``NULL`` の場合、長さは"
"無視され ``None`` になります。"

#: ../../c-api/arg.rst:630
msgid "``U`` (:class:`str` or ``None``) [const char \\*]"
msgstr "``U`` (:class:`str` または ``None``) [const char \\*]"

#: ../../c-api/arg.rst:633
msgid ""
"``U#`` (:class:`str` or ``None``) [const char \\*, :c:type:`Py_ssize_t`]"
msgstr ""
"``U#`` (:class:`str` または ``None``) [const char \\*, :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:637
msgid "Convert a plain C :c:expr:`int` to a Python integer object."
msgstr "通常の C の :c:expr:`int` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:639
msgid "``b`` (:class:`int`) [char]"
msgstr "``b`` (:class:`int`) [char]"

#: ../../c-api/arg.rst:640
msgid "Convert a plain C :c:expr:`char` to a Python integer object."
msgstr "通常のC の :c:expr:`char` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:643
msgid "Convert a plain C :c:expr:`short int` to a Python integer object."
msgstr ""
"通常のC の :c:expr:`short int` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:646
msgid "Convert a C :c:expr:`long int` to a Python integer object."
msgstr "C の :c:expr:`long int` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:649
msgid "Convert a C :c:expr:`unsigned char` to a Python integer object."
msgstr ""
"C の :c:expr:`unsigned char` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:652
msgid "Convert a C :c:expr:`unsigned short int` to a Python integer object."
msgstr ""
"C の :c:expr:`unsigned short int` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:655
msgid "Convert a C :c:expr:`unsigned int` to a Python integer object."
msgstr "C の :c:expr:`unsigned int` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:658
msgid "Convert a C :c:expr:`unsigned long` to a Python integer object."
msgstr ""
"C の :c:expr:`unsigned long` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:661
msgid "Convert a C :c:expr:`long long` to a Python integer object."
msgstr "C の :c:expr:`long long` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:666
msgid "Convert a C :c:expr:`unsigned long long` to a Python integer object."
msgstr "C :c:expr:`unsigned long long` をPythonのintオブジェクトへ変換する。"

#: ../../c-api/arg.rst:669
msgid "Convert a C :c:type:`Py_ssize_t` to a Python integer."
msgstr "C の :c:type:`Py_ssize_t` を Python の整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:672
msgid "Convert a C :c:expr:`int` to a Python :class:`bool` object."
msgstr ""

#: ../../c-api/arg.rst:674
msgid ""
"Be aware that this format requires an ``int`` argument. Unlike most other "
"contexts in C, variadic arguments are not coerced to a suitable type "
"automatically. You can convert another type (for example, a pointer or a "
"float) to a suitable ``int`` value using ``(x) ? 1 : 0`` or ``!!x``."
msgstr ""

#: ../../c-api/arg.rst:682
msgid "``c`` (:class:`bytes` of length 1) [char]"
msgstr "``c`` (長さが 1 の :class:`bytes`) [char]"

#: ../../c-api/arg.rst:683
msgid ""
"Convert a C :c:expr:`int` representing a byte to a Python :class:`bytes` "
"object of length 1."
msgstr ""
"バイトを表す通常の C の :c:expr:`int` を、長さ 1 の Python の :class:`bytes` "
"オブジェクトに変換します。"

#: ../../c-api/arg.rst:687
msgid ""
"Convert a C :c:expr:`int` representing a character to Python :class:`str` "
"object of length 1."
msgstr ""
"文字を表す通常の C の :c:expr:`int` を、長さ 1 の Python の :class:`str` オブ"
"ジェクトに変換します。"

#: ../../c-api/arg.rst:691
msgid "Convert a C :c:expr:`double` to a Python floating-point number."
msgstr ""

#: ../../c-api/arg.rst:694
msgid "Convert a C :c:expr:`float` to a Python floating-point number."
msgstr ""

#: ../../c-api/arg.rst:696
msgid "``D`` (:class:`complex`) [Py_complex \\*]"
msgstr "``D`` (:class:`complex`) [Py_complex \\*]"

#: ../../c-api/arg.rst:697
msgid "Convert a C :c:type:`Py_complex` structure to a Python complex number."
msgstr "C の :c:type:`Py_complex` 構造体を Python の複素数型に変換します。"

#: ../../c-api/arg.rst:700
msgid ""
"Pass a Python object untouched but create a new :term:`strong reference` to "
"it (i.e. its reference count is incremented by one). If the object passed in "
"is a ``NULL`` pointer, it is assumed that this was caused because the call "
"producing the argument found an error and set an exception. Therefore, :c:"
"func:`Py_BuildValue` will return ``NULL`` but won't raise an exception.  If "
"no exception has been raised yet, :exc:`SystemError` is set."
msgstr ""
"Python オブジェクトをそのまま渡すものの、それに対する新しい :term:`強参照` を"
"作成する（つまり、その参照カウントが1増加します）。渡されたオブジェクトが "
"``NULL`` ポインタ, この問題は、引数を生成する呼び出しがエラーを検出し、例外を"
"設定したため発生したものと推測されます。したがって、:c:func:`Py_BuildValue` "
"戻ってきます ``NULL`` しかし、そうはならない 送出 例外。 例外がまだ発生してい"
"ない場合、:exc:`SystemError` 設定されています。"

#: ../../c-api/arg.rst:709
msgid "``S`` (object) [PyObject \\*]"
msgstr "``S`` (object) [PyObject \\*]"

#: ../../c-api/arg.rst:710
msgid "Same as ``O``."
msgstr "``O`` と同じです。"

#: ../../c-api/arg.rst:712
msgid "``N`` (object) [PyObject \\*]"
msgstr "``N`` (object) [PyObject \\*]"

#: ../../c-api/arg.rst:713
msgid ""
"Same as ``O``, except it doesn't create a new :term:`strong reference`. "
"Useful when the object is created by a call to an object constructor in the "
"argument list."
msgstr ""
"同じです ``O``, ただし、新しい :term:`強参照` を作成しません。オブジェクトが"
"引数リスト内のオブジェクトコンストラクターの呼び出しによって作成される場合に"
"便利です。"

#: ../../c-api/arg.rst:717
msgid "``O&`` (object) [*converter*, *anything*]"
msgstr "``O&`` (object) [*converter*, *anything*]"

#: ../../c-api/arg.rst:718
msgid ""
"Convert *anything* to a Python object through a *converter* function.  The "
"function is called with *anything* (which should be compatible with :c:expr:"
"`void*`) as its argument and should return a \"new\" Python object, or "
"``NULL`` if an error occurred."
msgstr ""
"*anything* を *converter* 関数を介して Python オブジェクトに変換します。この"
"関数は *anything* (:c:expr:`void*` と互換の型でなければなりません) を引数にし"
"て呼び出され、\"新たな\" オブジェクトを返すか、失敗した場合には ``NULL`` を返"
"すようにしなければなりません。"

#: ../../c-api/arg.rst:723
msgid "``(items)`` (:class:`tuple`) [*matching-items*]"
msgstr "``(items)`` (:class:`tuple`) [*matching-items*]"

#: ../../c-api/arg.rst:724
msgid ""
"Convert a sequence of C values to a Python tuple with the same number of "
"items."
msgstr "C の値からなる配列を、同じ要素数を持つ Python のタプルに変換します。"

#: ../../c-api/arg.rst:726
msgid "``[items]`` (:class:`list`) [*matching-items*]"
msgstr "``[items]`` (:class:`list`) [*matching-items*]"

#: ../../c-api/arg.rst:727
msgid ""
"Convert a sequence of C values to a Python list with the same number of "
"items."
msgstr "C の値からなる配列を、同じ要素数を持つ Python のリストに変換します。"

#: ../../c-api/arg.rst:729
msgid "``{items}`` (:class:`dict`) [*matching-items*]"
msgstr "``{items}`` (:class:`dict`) [*matching-items*]"

#: ../../c-api/arg.rst:730
msgid ""
"Convert a sequence of C values to a Python dictionary.  Each pair of "
"consecutive C values adds one item to the dictionary, serving as key and "
"value, respectively."
msgstr ""
"C の値からなる配列を Python の辞書に変換します。一連のペアからなる C の値が、"
"それぞれキーおよび値となって辞書に追加されます。"

#: ../../c-api/arg.rst:734
msgid ""
"If there is an error in the format string, the :exc:`SystemError` exception "
"is set and ``NULL`` returned."
msgstr ""
"書式文字列に関するエラーが生じると、 :exc:`SystemError` 例外をセットして "
"``NULL`` を返します。"

#: ../../c-api/arg.rst:739
msgid ""
"Identical to :c:func:`Py_BuildValue`, except that it accepts a va_list "
"rather than a variable number of arguments."
msgstr ""
":c:func:`Py_BuildValue` と同じですが、可変長引数の代わりに va_list を受け取り"
"ます。"