arg.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# tomo, 2017
# 秘湯 <xwhhsprings@gmail.com>, 2016
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 01:01+0900\n"
"PO-Revision-Date: 2019-09-01 05:18+0000\n"
"Last-Translator: tomo\n"
"Language-Team: Japanese (http://www.transifex.com/python-doc/python-27/"
"language/ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../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 extensions functions and "
"methods.  Additional information and examples are available in :ref:"
"`extending-index`."
msgstr ""
"これらの関数は独自の拡張モジュール用の関数やメソッドを作成する際に便利です。"
"詳しい情報や用例は :ref:`extending-index` にあります。"

#: ../../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:18
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:27
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.  "
"Also, you won't have to release any memory yourself, except with the ``es``, "
"``es#``, ``et`` and ``et#`` formats."
msgstr ""
"以下のフォーマットはオブジェクトに連続したメモリチャンクとしてアクセスするた"
"めのものです。返される unicode や bytes のために生のストレージを用意する必要"
"はありません。また、``es``,  ``es#``, ``et``, ``et#`` フォーマットの場合を除"
"いて自分でメモリを解放する必要もありません。"

#: ../../c-api/arg.rst:39
msgid "``s`` (string or Unicode) [const char \\*]"
msgstr "``s`` (文字列型または Unicode 型) [const char \\*]"

#: ../../c-api/arg.rst:33
msgid ""
"Convert a Python string or Unicode object to a C pointer to a character "
"string.  You must not provide storage for the string itself; a pointer to an "
"existing string is stored into the character pointer variable whose address "
"you pass.  The C string is NUL-terminated.  The Python string must not "
"contain embedded NUL bytes; if it does, a :exc:`TypeError` exception is "
"raised. Unicode objects are converted to C strings using the default "
"encoding.  If this conversion fails, a :exc:`UnicodeError` is raised."
msgstr ""
"Python の文字列または Unicode オブジェクトを、キャラクタ文字列を指す C のポイ"
"ンタに変換します。変換先の文字列自体の記憶領域を提供する必要はありません; "
"キャラクタ型ポインタ変数のアドレスを渡すと、すでに存在している文字列へのポイ"
"ンタをその変数に記録します。C 文字列は NUL で終端されています。Python の文字"
"列型は、NUL バイトが途中に埋め込まれていてはなりません; もし埋め込まれていれ"
"ば :exc:`TypeError` 例外を送出します。Unicode オブジェクトはデフォルトエン"
"コーディングを使って C 文字列に変換されます。変換に失敗すると :exc:"
"`UnicodeError` を送出します。"

#: ../../c-api/arg.rst:52
msgid ""
"``s#`` (string, Unicode or any read buffer compatible object) [const char "
"\\*, int (or :c:type:`Py_ssize_t`, see below)]"
msgstr ""
"``s#`` (文字列型、Unicode 型または任意の読み出しバッファ互換型) [const char "
"\\*, int (または :c:type:`Py_ssize_t`, 下記参照)]"

#: ../../c-api/arg.rst:42
msgid ""
"This variant on ``s`` stores into two C variables, the first one a pointer "
"to a character string, the second one its length.  In this case the Python "
"string may contain embedded null bytes.  Unicode objects pass back a pointer "
"to the default encoded string version of the object if such a conversion is "
"possible.  All other read-buffer compatible objects pass back a reference to "
"the raw internal data representation."
msgstr ""
"これは ``s`` の変化形で、値を二つの変数に記録します。一つ目の変数はキャラクタ"
"文字列へのポインタで、二つ目はその長さです。この書式化単位の場合には、Python "
"文字列に null バイトが埋め込まれていてもかまいません。 Unicode オブジェクトの"
"場合、デフォルトエンコーディングでの変換が可能ならば、変換したオブジェクトか"
"ら文字列へのポインタを返します。その他の読み出しバッファ互換オブジェクトは生"
"の内部データ表現への参照を返します。"

#: ../../c-api/arg.rst:49
msgid ""
"Starting with Python 2.5 the type of the length argument can be controlled "
"by defining the macro :c:macro:`PY_SSIZE_T_CLEAN` before including :file:"
"`Python.h`.  If the macro is defined, length is a :c:type:`Py_ssize_t` "
"rather than an int."
msgstr ""
"Python 2.5 から、長さの引数の型を、 :file:`Python.h` を include する前に :c:"
"macro:`PY_SSIZE_T_CLEAN` マクロを定義することで制御できるようになりました。も"
"しこのマクロが定義されていた場合、長さは int ではなく :c:type:`Py_ssize_t` に"
"なります。"

#: ../../c-api/arg.rst:61
msgid "``s*`` (string, Unicode, or any buffer compatible object) [Py_buffer]"
msgstr ""
"``s*`` (文字列型、Unicode 型、または任意のバッファ互換オブジェクト) "
"[Py_buffer]"

#: ../../c-api/arg.rst:55
msgid ""
"Similar to ``s#``, this code fills a Py_buffer structure provided by the "
"caller.  The buffer gets locked, so that the caller can subsequently use the "
"buffer even inside a ``Py_BEGIN_ALLOW_THREADS`` block; the caller is "
"responsible for calling ``PyBuffer_Release`` with the structure after it has "
"processed the data."
msgstr ""
"``s#`` と似ていますが、呼び出し元から渡された Py_buffer 構造体に書き込みま"
"す。バッファーはロックされるので、呼び出し元はそのバッファーを "
"``Py_BEGIN_ALLOW_THREADS`` したブロック内でさえも利用することができます。その"
"代わり、呼び出し元には、データを処理した後にその構造体に対して "
"``PyBuffer_Release`` する責任があります。"

#: ../../c-api/arg.rst:65
msgid "``z`` (string, Unicode  or ``None``) [const char \\*]"
msgstr "``z`` (文字列型または Unicode 型または ``None``) [const char \\*]"

#: ../../c-api/arg.rst:64
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:68
msgid ""
"``z#`` (string, Unicode, ``None`` or any read buffer compatible object) "
"[const char \\*, int]"
msgstr ""
"``z#`` (文字列型、 ``None`` 、または任意の読み出しバッファ互換型) [const "
"char \\*, int]"

#: ../../c-api/arg.rst:68
msgid "This is to ``s#`` as ``z`` is to ``s``."
msgstr "``s#`` の ``s`` を ``z`` にしたような意味です。"

#: ../../c-api/arg.rst:73
msgid ""
"``z*`` (string, Unicode, ``None`` or any buffer compatible object) "
"[Py_buffer]"
msgstr ""
"``z*`` (文字列型、Unicode型、 ``None`` または任意のバッファ互換型) "
"[Py_buffer]"

#: ../../c-api/arg.rst:71
msgid "This is to ``s*`` as ``z`` is to ``s``."
msgstr "``s*`` の ``s`` を ``z`` にしたような意味です。"

#: ../../c-api/arg.rst:80
msgid "``u`` (Unicode) [Py_UNICODE \\*]"
msgstr "``u`` (Unicode 型) [Py_UNICODE \\*]"

#: ../../c-api/arg.rst:76
msgid ""
"Convert a Python Unicode object to a C pointer to a NUL-terminated buffer of "
"16-bit Unicode (UTF-16) data.  As with ``s``, there is no need to provide "
"storage for the Unicode data buffer; a pointer to the existing Unicode data "
"is stored into the :c:type:`Py_UNICODE` pointer variable whose address you "
"pass."
msgstr ""
"Python の Unicode オブジェクトを、NUL で終端された 16 ビットの Unicode "
"(UTF-16) データに変換します。 ``s`` と同様に、 Unicode データバッファ用に記憶"
"領域を提供する必要はありません; :c:type:`Py_UNICODE` 型ポインタ変数のアドレス"
"を渡すと、すでに存在している Unicode データへのポインタをその変数に記録しま"
"す。"

#: ../../c-api/arg.rst:86
msgid "``u#`` (Unicode) [Py_UNICODE \\*, int]"
msgstr "``u#`` (Unicode 型) [Py_UNICODE \\*, int]"

#: ../../c-api/arg.rst:83
msgid ""
"This variant on ``u`` stores into two C variables, the first one a pointer "
"to a Unicode data buffer, the second one its length. Non-Unicode objects are "
"handled by interpreting their read-buffer pointer as pointer to a :c:type:"
"`Py_UNICODE` array."
msgstr ""
"これは ``u`` の変化形で、値を二つの変数に記録します。一つ目の変数は Unicode "
"データバッファへのポインタで、二つ目はその長さです。非 Unicode のオブジェクト"
"の場合、読み出しバッファのポインタを :c:type:`Py_UNICODE` 型シーケンスへのポ"
"インタと解釈して扱います。"

#: ../../c-api/arg.rst:105
msgid ""
"``es`` (string, Unicode or character buffer compatible object) [const char "
"\\*encoding, char \\*\\*buffer]"
msgstr ""
"``es`` (文字列型、Unicode 型またはキャラクタバッファ互換型) [const char "
"\\*encoding, char \\*\\*buffer]"

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

#: ../../c-api/arg.rst:93
msgid ""
"This format requires two arguments.  The first is only used as input, and "
"must be a :c:type:`const char\\*` which points to the name of an encoding as "
"a NUL-terminated string, or *NULL*, in which case the default encoding is "
"used.  An exception is raised if the named encoding is not known to Python. "
"The second argument must be a :c:type:`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:type:`const char\\*` 型でなければなりませ"
"ん。指定したエンコード名を Python が理解できない場合には例外を送出します。第"
"二の引数は :c:type:`char\\*\\*` でなければなりません; この引数が参照している"
"ポインタの値は、引数に指定したテキストの内容が入ったバッファへのポインタにな"
"ります。テキストは最初の引数に指定したエンコード方式でエンコードされます。"

#: ../../c-api/arg.rst:102
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:110
msgid ""
"``et`` (string, Unicode or character buffer compatible object) [const char "
"\\*encoding, char \\*\\*buffer]"
msgstr ""
"``et`` (文字列型、Unicode 型またはキャラクタバッファ互換型) [const char "
"\\*encoding, char \\*\\*buffer]"

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

#: ../../c-api/arg.rst:143
msgid ""
"``es#`` (string, Unicode or character buffer compatible object) [const char "
"\\*encoding, char \\*\\*buffer, int \\*buffer_length]"
msgstr ""
"``es#`` (文字列型、Unicode 型またはキャラクタバッファ互換型) [const char "
"\\*encoding, char \\*\\*buffer, int \\*buffer_length]"

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

#: ../../c-api/arg.rst:117
msgid ""
"It requires three arguments.  The first is only used as input, and must be "
"a :c:type:`const char\\*` which points to the name of an encoding as a NUL-"
"terminated string, or *NULL*, in which case the default encoding is used.  "
"An exception is raised if the named encoding is not known to Python. The "
"second argument must be a :c:type:`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:type:`const char\\*` 型か *NULL* でなけれ"
"ばなりません。 *NULL* の場合にはデフォルトエンコーディングを使います。指定し"
"たエンコード名を Python が理解できない場合には例外を送出します。第二の引数"
"は :c:type:`char\\*\\*` でなければなりません; この引数が参照しているポインタ"
"の値は、引数に指定したテキストの内容が入ったバッファへのポインタになります。"
"テキストは最初の引数に指定したエンコード方式でエンコードされます。第三の引数"
"は整数へのポインタでなければなりません; ポインタが参照している整数の値は出力"
"バッファ内のバイト数にセットされます。"

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

#: ../../c-api/arg.rst:129
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:135
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:`TypeError` will be set. Note: "
"starting from Python 3.6 a :exc:`ValueError` will be set."
msgstr ""
"*\\*buffer* が非 *NULL* のポインタ (すでにメモリ確保済みのバッファ) を指して"
"いる場合、 :c:func:`PyArg_ParseTuple` はこのメモリ位置をバッファとして用い、 "
"*\\*buffer_length* の初期値をバッファサイズとして用います。 :c:func:"
"`PyArg_ParseTuple` は次にエンコード済みのデータをバッファにコピーして、NUL で"
"終端します。バッファの大きさが足りなければ :exc:`TypeError` がセットされま"
"す。注意: Python 3.6からは :exc:`ValueError`  がセットされます。"

#: ../../c-api/arg.rst:142
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:148
msgid ""
"``et#`` (string, Unicode or character buffer compatible object) [const char "
"\\*encoding, char \\*\\*buffer, int \\*buffer_length]"
msgstr ""
"``et#`` (文字列型、Unicode 型またはキャラクタバッファ互換型) [const char "
"\\*encoding, char \\*\\*buffer, int \\*buffer_length]"

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

#: ../../c-api/arg.rst:152
msgid "``b`` (integer) [unsigned char]"
msgstr "``b`` (整数型) [unsigned char]"

#: ../../c-api/arg.rst:151
msgid ""
"Convert a nonnegative Python integer to an unsigned tiny int, stored in a C :"
"c:type:`unsigned char`."
msgstr ""
"Python の非負の整数を、 C の :c:type:`unsigned char` 型の小さな符号無し整数に"
"変換します。"

#: ../../c-api/arg.rst:158 ../../c-api/arg.rst:485
msgid "``B`` (integer) [unsigned char]"
msgstr "``B`` (整数型) [unsigned char]"

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

#: ../../c-api/arg.rst:161 ../../c-api/arg.rst:479
msgid "``h`` (integer) [short int]"
msgstr "``h`` (整数型) [short int]"

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

#: ../../c-api/arg.rst:167 ../../c-api/arg.rst:488
msgid "``H`` (integer) [unsigned short int]"
msgstr "``H`` (整数型) [unsigned short int]"

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

#: ../../c-api/arg.rst:170 ../../c-api/arg.rst:473
msgid "``i`` (integer) [int]"
msgstr "``i`` (整数型) [int]"

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

#: ../../c-api/arg.rst:176
msgid "``I`` (integer) [unsigned int]"
msgstr "``I`` (整数型) [unsigned int]"

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

#: ../../c-api/arg.rst:179 ../../c-api/arg.rst:482
msgid "``l`` (integer) [long int]"
msgstr "``l`` (整数型) [long int]"

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

#: ../../c-api/arg.rst:185
msgid "``k`` (integer) [unsigned long]"
msgstr "``k`` (整数型) [unsigned long]"

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

#: ../../c-api/arg.rst:190
msgid "``L`` (integer) [PY_LONG_LONG]"
msgstr "``L`` (整数型) [PY_LONG_LONG]"

#: ../../c-api/arg.rst:188
msgid ""
"Convert a Python integer to a C :c:type:`long long`.  This format is only "
"available on platforms that support :c:type:`long long` (or :c:type:`_int64` "
"on Windows)."
msgstr ""
"Python の整数を、 C の :c:type:`long long` 型に変換します。この書式化単位"
"は、 :c:type:`long long` 型 (または Windows の :c:type:`_int64` 型) がサポー"
"トされているプラットフォームでのみ利用できます。"

#: ../../c-api/arg.rst:198
msgid "``K`` (integer) [unsigned PY_LONG_LONG]"
msgstr "``K`` (整数型) [unsigned PY_LONG_LONG]"

#: ../../c-api/arg.rst:193
msgid ""
"Convert a Python integer or long integer to a C :c:type:`unsigned long long` "
"without overflow checking.  This format is only available on platforms that "
"support :c:type:`unsigned long long` (or :c:type:`unsigned _int64` on "
"Windows)."
msgstr ""
"Python の整数もしくは長整数を、オーバフローチェックを行わずに、 C の :c:type:"
"`unsigned long long` 型に変換します。この書式化単位は、 :c:type:`unsigned "
"long long` 型 (または Windows の :c:type:`unsigned _int64` 型) がサポートされ"
"ているプラットフォームでのみ利用できます。"

#: ../../c-api/arg.rst:203
msgid "``n`` (integer) [Py_ssize_t]"
msgstr "``n`` (整数型) [Py_ssize_t]"

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

#: ../../c-api/arg.rst:207 ../../c-api/arg.rst:513
msgid "``c`` (string of length 1) [char]"
msgstr "``c`` (長さ 1 の文字列型) [char]"

#: ../../c-api/arg.rst:206
msgid ""
"Convert a Python character, represented as a string of length 1, to a C :c:"
"type:`char`."
msgstr ""
"長さ 1 の文字列として表現されている Python キャラクタを C の :c:type:`char` "
"型に変換します。"

#: ../../c-api/arg.rst:210 ../../c-api/arg.rst:519
msgid "``f`` (float) [float]"
msgstr "``f`` (浮動小数点数型) [float]"

#: ../../c-api/arg.rst:210
msgid "Convert a Python floating point number to a C :c:type:`float`."
msgstr "Python の浮動小数点型を、 C の :c:type:`float` 型に変換します。"

#: ../../c-api/arg.rst:213 ../../c-api/arg.rst:516
msgid "``d`` (float) [double]"
msgstr "``d`` (浮動小数点数型) [double]"

#: ../../c-api/arg.rst:213
msgid "Convert a Python floating point number to a C :c:type:`double`."
msgstr "Python の浮動小数点型を、 C の :c:type:`double` 型に変換します。"

#: ../../c-api/arg.rst:216
msgid "``D`` (complex) [Py_complex]"
msgstr "``D`` (複素数型) [Py_complex]"

#: ../../c-api/arg.rst:216
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:221 ../../c-api/arg.rst:530
msgid "``O`` (object) [PyObject \\*]"
msgstr "``O`` (object) [PyObject \\*]"

#: ../../c-api/arg.rst:219
msgid ""
"Store a Python object (without any conversion) in a C object pointer.  The C "
"program thus receives the actual object that was passed.  The object's "
"reference count is not increased.  The pointer stored is not *NULL*."
msgstr ""
"Python オブジェクトを (一切変換を行わずに) C の Python オブジェクト型ポインタ"
"に保存します。これにより、C プログラムは実際のオブジェクトを受け渡しされま"
"す。オブジェクトの参照カウントは増加しません。保存されるポインタが *NULL* に"
"なることはありません。"

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

#: ../../c-api/arg.rst:224
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:type:`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:type:`PyObject\\*` の) C の変数へのアドレスです。Python オブジェクトが指定"
"した型ではない場合、 :exc:`TypeError` を送出します。"

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

#: ../../c-api/arg.rst:231
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:type:`void \\*`. The "
"*converter* function in turn is called as follows::"
msgstr ""
"Python オブジェクトを *converter* 関数を介して C の変数に変換します。二つの引"
"数をとります: 一つ目は関数で、二つ目は (任意の型の) C 変数へのアドレスを :c:"
"type:`void \\*` 型に変換したものです。 *converter* は以下のようにして呼び出さ"
"れます::"

#: ../../c-api/arg.rst:238
msgid ""
"where *object* is the Python object to be converted and *address* is the :c:"
"type:`void\\*` argument that was passed to the :c:func:`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* は :c:func:"
"`PyArg_Parse\\*` に渡した :c:type:`void\\*` 型の引数です。戻り値 *status* は"
"変換に成功した際に ``1``,失敗した場合には ``0`` になります。変換に失敗した場"
"合、 *converter* 関数は *address* の内容を変更せずに例外を送出しなくてはなり"
"ません。"

#: ../../c-api/arg.rst:248
msgid "``S`` (string) [PyStringObject \\*]"
msgstr "``S`` (文字列型) [PyStringObject \\*]"

#: ../../c-api/arg.rst:246
msgid ""
"Like ``O`` but requires that the Python object is a string object.  Raises :"
"exc:`TypeError` if the object is not a string object.  The C variable may "
"also be declared as :c:type:`PyObject\\*`."
msgstr ""
"``O`` に似ていますが、Python オブジェクトは文字列オブジェクトでなければなりま"
"せん。オブジェクトが文字列オブジェクトでない場合には :exc:`TypeError` を送出"
"します。 C 変数は :c:type:`PyObject\\*` で宣言しておいてもかまいません。"

#: ../../c-api/arg.rst:253
msgid "``U`` (Unicode string) [PyUnicodeObject \\*]"
msgstr "``U`` (Unicode 型) [PyUnicodeObject \\*]"

#: ../../c-api/arg.rst:251
msgid ""
"Like ``O`` but requires that the Python object is a Unicode object.  Raises :"
"exc:`TypeError` if the object is not a Unicode object.  The C variable may "
"also be declared as :c:type:`PyObject\\*`."
msgstr ""
"``O`` に似ていますが、Python オブジェクトは Unicode オブジェクトでなければな"
"りません。オブジェクトが Unicode オブジェクトでない場合には :exc:`TypeError` "
"を送出します。 C 変数は :c:type:`PyObject\\*` で宣言しておいてもかまいませ"
"ん。"

#: ../../c-api/arg.rst:260
msgid "``t#`` (read-only character buffer) [char \\*, int]"
msgstr "``t#`` (読み出し専用キャラクタバッファ) [char \\*, int]"

#: ../../c-api/arg.rst:256
msgid ""
"Like ``s#``, but accepts any object which implements the read-only buffer "
"interface.  The :c:type:`char\\*` variable is set to point to the first byte "
"of the buffer, and the :c:type:`int` is set to the length of the buffer. "
"Only single-segment buffer objects are accepted; :exc:`TypeError` is raised "
"for all others."
msgstr ""
"``s#`` に似ていますが、読み出し専用バッファインタフェースを実装している任意の"
"オブジェクトを受理します。 :c:type:`char\\*` 変数はバッファの最初のバイトを指"
"すようにセットされ、 :c:type:`int` はバッファの長さにセットされます。単一セグ"
"メントからなるバッファオブジェクトだけを受理します; それ以外の場合には :exc:"
"`TypeError` を送出します。"

#: ../../c-api/arg.rst:266
msgid "``w`` (read-write character buffer) [char \\*]"
msgstr "``w`` (読み書き可能なキャラクタバッファ) [char \\*]"

#: ../../c-api/arg.rst:263
msgid ""
"Similar to ``s``, but accepts any object which implements the read-write "
"buffer interface.  The caller must determine the length of the buffer by "
"other means, or use ``w#`` instead.  Only single-segment buffer objects are "
"accepted; :exc:`TypeError` is raised for all others."
msgstr ""
"``s`` と同様ですが、読み書き可能なバッファインタフェースを実装している任意の"
"オブジェクトを受理します。呼び出し側は何らかの別の手段でバッファの長さを決定"
"するか、あるいは ``w#`` を使わねばなりません。単一セグメントからなるバッファ"
"オブジェクトだけを受理します; それ以外の場合には :exc:`TypeError` を送出しま"
"す。"

#: ../../c-api/arg.rst:273
msgid "``w#`` (read-write character buffer) [char \\*, Py_ssize_t]"
msgstr "``w#`` (読み書き可能なキャラクタバッファ) [char \\*, Py_ssize_t]"

#: ../../c-api/arg.rst:269
msgid ""
"Like ``s#``, but accepts any object which implements the read-write buffer "
"interface.  The :c:type:`char \\*` variable is set to point to the first "
"byte of the buffer, and the :c:type:`Py_ssize_t` is set to the length of the "
"buffer.  Only single-segment buffer objects are accepted; :exc:`TypeError` "
"is raised for all others."
msgstr ""
"``s#`` に似ていますが、読み書き可能なバッファインタフェースを実装している任意"
"のオブジェクトを受理します。 :c:type:`char\\*` 変数はバッファの最初のバイトを"
"指すようにセットされ、 :c:type:`Py_ssize_t` はバッファの長さにセットされま"
"す。単一セグメントからなるバッファオブジェクトだけを受理します; それ以外の場"
"合には :exc:`TypeError` を送出します。"

#: ../../c-api/arg.rst:278
msgid "``w*`` (read-write byte-oriented buffer) [Py_buffer]"
msgstr "``w*`` (読み書き可能なバイト列バッファ) [Py_buffer]"

#: ../../c-api/arg.rst:276
msgid "This is to ``w`` what ``s*`` is to ``s``."
msgstr "``s`` に対する ``s*`` と同じ、 ``w`` のバージョンです。"

#: ../../c-api/arg.rst:291 ../../c-api/arg.rst:548
msgid "``(items)`` (tuple) [*matching-items*]"
msgstr "``(items)`` (タプル型) [*matching-items*]"

#: ../../c-api/arg.rst:281
msgid ""
"The object must be a Python sequence 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 ""
"オブジェクトは *items* に入っている書式化単位の数だけの長さを持つ Python の"
"シーケンス型でなければなりません。各 C 引数は *items* 内の個々の書式化単位に"
"対応づけできなければなりません。シーケンスの書式化単位は入れ子構造にできま"
"す。"

#: ../../c-api/arg.rst:287
msgid ""
"Prior to Python version 1.5.2, this format specifier only accepted a tuple "
"containing the individual parameters, not an arbitrary sequence. Code which "
"previously caused :exc:`TypeError` to be raised here may now proceed without "
"an exception.  This is not expected to be a problem for existing code."
msgstr ""
"Python のバージョン 1.5.2 より以前は、この書式化指定文字列はパラメタ列ではな"
"く、個別のパラメタが入ったタプルでなければなりませんでした。このため、以前"
"は :exc:`TypeError` を引き起こしていたようなコードが現在は例外を出さずに処理"
"されるかもしれません。とはいえ、既存のコードにとってこれは問題ないと思われま"
"す。"

#: ../../c-api/arg.rst:293
msgid ""
"It is possible to pass Python long integers where integers are requested; "
"however no proper range checking is done --- the most significant bits are "
"silently truncated when the receiving field is too small to receive the "
"value (actually, the semantics are inherited from downcasts in C --- your "
"mileage may vary)."
msgstr ""
"Python 整数型を要求している場所に Python 長整数型を渡すのは可能です; しかしな"
"がら、適切な値域チェックはまったく行われません --- 値を受け取るためのフィール"
"ドが、値全てを受け取るには小さすぎる場合、上桁のビット群は暗黙のうちに切り詰"
"められます (実際のところ、このセマンティクスは C のダウンキャスト (downcast) "
"から継承しています --- その恩恵は人それぞれかもしれませんが)。"

#: ../../c-api/arg.rst:299
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:307
msgid "``|``"
msgstr "``|``"

#: ../../c-api/arg.rst:303
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:312
msgid "``:``"
msgstr "``:``"

#: ../../c-api/arg.rst:310
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:317
msgid "``;``"
msgstr "``;``"

#: ../../c-api/arg.rst:315
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:319
msgid ""
"Note that any Python object references which are provided to the caller are "
"*borrowed* references; do not decrement their reference count!"
msgstr ""
"呼び出し側に提供される Python オブジェクトの参照は全て *借りた (borrowed)* も"
"のです; オブジェクトの参照カウントをデクリメントしてはなりません!"

#: ../../c-api/arg.rst:322
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:328
msgid ""
"For the conversion to succeed, the *arg* object must match the format and "
"the format must be exhausted.  On success, the :c:func:`PyArg_Parse\\*` "
"functions return true, otherwise they return false and raise an appropriate "
"exception. When the :c:func:`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* オブジェクトは書式化文字に一致しなければなら"
"ず、かつ書式化文字列内の書式化単位に全て値が入るようにしなければなりません。"
"成功すると、 :c:func:`PyArg_Parse\\*` 関数は真を返します。それ以外の場合には"
"偽を返し、適切な例外を送出します。書式化単位のどれかの変換失敗により :c:func:"
"`PyArg_Parse\\*` が失敗した場合、失敗した書式化単位に対応するアドレスとそれ以"
"降のアドレスの内容は変更されません。"

#: ../../c-api/arg.rst:338
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:345
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:351
msgid ""
"Parse the parameters of a function that takes both positional and keyword "
"parameters into local variables.  Returns true on success; on failure, it "
"returns false and raises the appropriate exception."
msgstr ""
"位置引数およびキーワード引数をとる関数のパラメタを解釈して、ローカルな変数に"
"変換します。成功すると真を返します;失敗すると偽を返し、適切な例外を送出しま"
"す。"

#: ../../c-api/arg.rst:358
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:364
msgid ""
"Function used to deconstruct the argument lists of \"old-style\" functions "
"--- these are functions which use the :const:`METH_OLDARGS` parameter "
"parsing method.  This is not recommended for use in parameter parsing in new "
"code, and most code in the standard interpreter has been modified to no "
"longer use this for that purpose.  It does remain a convenient way to "
"decompose other tuples, however, and may continue to be used for that "
"purpose."
msgstr ""
"\"旧スタイル\" の関数における引数リストを分析するために使われる関数です --- "
"旧スタイルの関数は、引数解釈手法に :const:`METH_OLDARGS` を使います。新たに書"
"かれるコードでのパラメタ解釈にはこの関数の使用は奨められず、標準のインタプリ"
"タにおけるほとんどのコードがもはや引数解釈のためにこの関数を使わないように変"
"更済みです。この関数を残しているのは、この関数が依然として引数以外のタプルを"
"分析する上で便利だからですが、この目的においては将来も使われつづけるかもしれ"
"ません。"

#: ../../c-api/arg.rst:375
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 :const:`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:type:`PyObject\\*` variable; these will be "
"filled in with the values from *args*; they will contain borrowed "
"references.  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 ""
"パラメータ取得を簡単にした形式で、引数の型を指定する書式化文字列を使いませ"
"ん。パラメタの取得にこの手法を使う関数は、関数宣言テーブル、またはメソッド宣"
"言テーブル内で :const:`METH_VARARGS` として宣言しなければなりません。実引数の"
"入ったタプルは *args* に渡します; このタプルは本当のタプルでなければなりませ"
"ん。タプルの長さは少なくとも *min* で、 *max* を超えてはなりません; *min* と "
"*max* が等しくてもかまいません。補助引数を関数に渡さなければならず、各補助引"
"数は :c:type:`PyObject\\*` 変数へのポインタでなければなりません; これらの補助"
"引数には、 *args* の値が入ります; 値の参照は借用参照です。オプションのパラメ"
"タに対応する変数のうち、 *args* に指定していないものには値が入りません; 呼び"
"出し側はそれらの値を初期化しておかなければなりません。この関数は成功すると真"
"を返し、 *args* がタプルでない場合や間違った数の要素が入っている場合に偽を返"
"します; 何らかの失敗が起きた場合には例外をセットします。"

#: ../../c-api/arg.rst:389
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:405
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:412
msgid ""
"This function used an :c:type:`int` type for *min* and *max*. This might "
"require changes in your code for properly supporting 64-bit systems."
msgstr ""
"この関数は *min* と *max* に :c:type:`int` を利用していました。この変更によ"
"り、64 bitシステムを正しくサポートするためには修正が必要になるでしょう。"

#: ../../c-api/arg.rst:419
msgid ""
"Create a new value based on a format string similar to those accepted by "
"the :c:func:`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 ""
":c:func:`PyArg_Parse\\*` ファミリの関数が受け取るのと似た形式の書式化文字列お"
"よび値列に基づいて、新たな値を生成します。生成した値を返します。エラーの場合"
"には *NULL* を返します; *NULL* を返す場合、例外を送出するでしょう。"

#: ../../c-api/arg.rst:424
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` は常にタプルを生成するとは限りません。\n"
"この関数がタプルを生成するのは、書式化文字列に二つ以上の書式化単位が入ってい"
"るときだけです。\n"
"書式化文字列が空の場合、 ``None``  を返します; 書式化単位が厳密に一つだけ入っ"
"ている場合、書式化単位で指定されている何らかのオブジェクト単体を返します。\n"
"サイズが ``0`` や ``1`` のタプルを返すように強制するには、丸括弧で囲われた書"
"式化文字列を使います。"

#: ../../c-api/arg.rst:431
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:439
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:444
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:450
msgid "``s`` (string) [char \\*]"
msgstr "``s`` (文字列型) [char \\*]"

#: ../../c-api/arg.rst:449
msgid ""
"Convert a null-terminated C string to a Python object.  If the C string "
"pointer is *NULL*, ``None`` is used."
msgstr ""
"null 終端された C 文字列から Python オブジェクトに変換します。 C 文字列ポイン"
"タが *NULL* の場合、 ``None`` になります。"

#: ../../c-api/arg.rst:454
msgid "``s#`` (string) [char \\*, int]"
msgstr "``s#`` (文字列型) [char \\*, int]"

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

#: ../../c-api/arg.rst:457
msgid "``z`` (string or ``None``) [char \\*]"
msgstr "``z`` (文字列型または ``None``) [char \\*]"

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

#: ../../c-api/arg.rst:460
msgid "``z#`` (string or ``None``) [char \\*, int]"
msgstr "``z#`` (文字列型または ``None``) [char \\*, int]"

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

#: ../../c-api/arg.rst:465
msgid "``u`` (Unicode string) [Py_UNICODE \\*]"
msgstr "``u`` (Unicode 文字列型) [Py_UNICODE \\*]"

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

#: ../../c-api/arg.rst:470
msgid "``u#`` (Unicode string) [Py_UNICODE \\*, int]"
msgstr "``u#`` (Unicode 文字列型) [Py_UNICODE \\*, int]"

#: ../../c-api/arg.rst:468
msgid ""
"Convert a Unicode (UCS-2 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 (UCS-2 または UCS-4) データのバッファとその長さから Python Unicode オ"
"ブジェクトに変換します。 Unicode バッファポインタが *NULL* の場合、長さは無視"
"され ``None`` になります。"

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

#: ../../c-api/arg.rst:476
msgid "``b`` (integer) [char]"
msgstr "``b`` (整数型) [char]"

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

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

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

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

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

#: ../../c-api/arg.rst:492
msgid "``I`` (integer/long) [unsigned int]"
msgstr "``I`` (整数型/長整数型) [unsigned int]"

#: ../../c-api/arg.rst:491
msgid ""
"Convert a C :c:type:`unsigned int` to a Python integer object or a Python "
"long integer object, if it is larger than ``sys.maxint``."
msgstr ""
"C の :c:type:`unsigned int` を Python の整数オブジェクト、あるいは、値が "
"``sys.maxint`` より大きければ長整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:496
msgid "``k`` (integer/long) [unsigned long]"
msgstr "``k`` (整数型/長整数型) [unsigned long]"

#: ../../c-api/arg.rst:495
msgid ""
"Convert a C :c:type:`unsigned long` to a Python integer object or a Python "
"long integer object, if it is larger than ``sys.maxint``."
msgstr ""
"C の :c:type:`unsigned long` を Python の整数オブジェクト、あるいは、値が "
"``sys.maxint`` より大きければ長整数オブジェクトに変換します。"

#: ../../c-api/arg.rst:500
msgid "``L`` (long) [PY_LONG_LONG]"
msgstr "``L`` (長整数型) [PY_LONG_LONG]"

#: ../../c-api/arg.rst:499
msgid ""
"Convert a C :c:type:`long long` to a Python long integer object. Only "
"available on platforms that support :c:type:`long long`."
msgstr ""
"C の :c:type:`long long` を Python の長整数オブジェクトに変換します。 :c:"
"type:`long long` をサポートしているプラットフォームでのみ利用可能です。"

#: ../../c-api/arg.rst:504
msgid "``K`` (long) [unsigned PY_LONG_LONG]"
msgstr "``K`` (長整数型) [unsigned PY_LONG_LONG]"

#: ../../c-api/arg.rst:503
msgid ""
"Convert a C :c:type:`unsigned long long` to a Python long integer object. "
"Only available on platforms that support :c:type:`unsigned long long`."
msgstr ""
"C の :c:type:`unsigned long long` を Python の長整数オブジェクトに変換しま"
"す。 :c:type:`long long` をサポートしているプラットフォームでのみ利用可能で"
"す。"

#: ../../c-api/arg.rst:509
msgid "``n`` (int) [Py_ssize_t]"
msgstr "``n`` (整数型) [Py_ssize_t]"

#: ../../c-api/arg.rst:507
msgid "Convert a C :c:type:`Py_ssize_t` to a Python integer or long integer."
msgstr ""
"C の :c:type:`Py_ssize_t` を Python の整数オブジェクト、あるいは長整数オブ"
"ジェクトに変換します。"

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

#: ../../c-api/arg.rst:516
msgid "Convert a C :c:type:`double` to a Python floating point number."
msgstr "C の :c:type:`double` を Python の浮動小数点数に変換します。"

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

#: ../../c-api/arg.rst:522
msgid "``D`` (complex) [Py_complex \\*]"
msgstr "``D`` (複素数型) [Py_complex \\*]"

#: ../../c-api/arg.rst:522
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:525
msgid ""
"Pass a Python object untouched (except for its reference count, which 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 オブジェクトを手を加えずに渡します (ただし、参照カウントは 1 インクリ"
"メントします)。渡したオブジェクトが *NULL* ポインタの場合、この引数を生成する"
"のに使った何らかの呼び出しがエラーになったのが原因であると仮定して、例外を"
"セットします。従ってこのとき :c:func:`Py_BuildValue` は *NULL* を返しますが :"
"c:func:`Py_BuildValue` 自体は例外を送出しません。例外をまだ送出していなけれ"
"ば :exc:`SystemError` をセットします。"

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

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

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

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

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

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

#: ../../c-api/arg.rst:552
msgid "``[items]`` (list) [*matching-items*]"
msgstr "``[items]`` (リスト型) [*matching-items*]"

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

#: ../../c-api/arg.rst:557
msgid "``{items}`` (dictionary) [*matching-items*]"
msgstr "``{items}`` (辞書型) [*matching-items*]"

#: ../../c-api/arg.rst:555
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:559
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:564
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 を受け取り"
"ます。"