arg.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-30 05:56+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Kenji Noguchi <tokyo246@gmail.com>, 2017\n"
"Language-Team: Japanese (https://www.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 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: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:31
msgid "Strings and buffers"
msgstr "文字列とバッファ"

#: ../../c-api/arg.rst:33
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:37
msgid ""
"In general, when a format sets a pointer to a buffer, the buffer is managed "
"by the corresponding Python object, and the buffer shares the lifetime of "
"this object.  You won't have to release any memory yourself. The only "
"exceptions are ``es``, ``es#``, ``et`` and ``et#``."
msgstr ""
"一般に、フォーマットがバッファにポインタをセットする時は、そのバッファは対応する Python "
"オブジェクトにより管理され、バッファはそのオブジェクトのライフタイムを共有します。自分自身でメモリを解放する必要はありません。この例外は、 "
"``es``, ``es#``, ``et``, ``et#`` だけです。"

#: ../../c-api/arg.rst:42
msgid ""
"However, when a :c:type:`Py_buffer` structure gets filled, the underlying "
"buffer is locked 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 ""
"ただし、 :c:type:`Py_buffer` 構造体に格納されたバッファーはロックされて、呼び出し側はそのバッファーを "
":c:type:`Py_BEGIN_ALLOW_THREADS` ブロック内でも、 mutable "
"なデータが破棄されたりリサイズされたりするリスク無しに利用することができます。そのかわりに、そのデータに対する処理が終わった場合 "
"(もしくは処理せずに中断した場合) には **必ず** :c:func:`PyBuffer_Release` を呼ばなければなりません。"

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

#: ../../c-api/arg.rst:51
msgid ""
"Some formats require a read-only :term:`bytes-like object`, and set a "
"pointer instead of a buffer structure.  They work by checking that the "
"object's :c:member:`PyBufferProcs.bf_releasebuffer` field is *NULL*, which "
"disallows mutable objects such as :class:`bytearray`."
msgstr ""
"いくつかのフォーマットは読み込み専用の :term:`bytes-like オブジェクト <bytes-like object>` "
"を必要とし、バッファ構造体の代わりにポインタをセットします。それらは、オブジェクトの "
":c:member:`PyBufferProcs.bf_releasebuffer` フィールドが *NULL* "
"であることをチェックして動きます。これは :class:`bytearray` などの変更可能オブジェクトを禁止します。"

#: ../../c-api/arg.rst:58
msgid ""
"For all ``#`` variants of formats (``s#``, ``y#``, etc.), the type of the "
"length argument (int or :c:type:`Py_ssize_t`) is controlled by defining the "
"macro :c:macro:`PY_SSIZE_T_CLEAN` before including :file:`Python.h`.  If the"
" macro was defined, length is a :c:type:`Py_ssize_t` rather than an "
":c:type:`int`. This behavior will change in a future Python version to only "
"support :c:type:`Py_ssize_t` and drop :c:type:`int` support. It is best to "
"always define :c:macro:`PY_SSIZE_T_CLEAN`."
msgstr ""
"全ての ``#`` 型のフォーマット (``s#``, ``y#``, など) において、length 引数の型 (int か "
":c:type:`Py_ssize_t`) は :file:`Python.h` を include する前に "
":c:macro:`PY_SSIZE_T_CLEAN` マクロを定義することで制御します。マクロが定義されている場合、 length は "
":c:type:`int` 型ではなく :c:type:`Py_ssize_t` 型になります。この挙動は将来の Python バージョンで変更され、 "
":c:type:`Py_ssize_t` のみがサポートされて :c:type:`int` はサポートされなくなるでしょう。常に "
":c:macro:`PY_SSIZE_T_CLEAN` を定義したほうが良いです。"

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

#: ../../c-api/arg.rst:68
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:77
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:83 ../../c-api/arg.rst:150
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:91
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:88
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:98
msgid ""
"``s#`` (:class:`str`, read-only :term:`bytes-like object`) [const char \\*, "
"int or :c:type:`Py_ssize_t`]"
msgstr ""
"``s#`` (:class:`str`, 読み出し専用の :term:`bytes-like object`) [const char \\*, "
"int or :c:type:`Py_ssize_t`]"

#: ../../c-api/arg.rst:94
msgid ""
"Like ``s*``, except that it doesn't accept mutable objects. 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*`` と同じですが、 mutable "
"なオブジェクトを受け取りません。結果は2つのC変数に格納されます。1つ目はC文字列へのポインターで、2つ目はその長さです。受け取った文字列は null "
"バイトを含むかもしれません。 Unicode オブジェクトは ``'utf-8'`` エンコーディングを利用して C 文字列に変換されます。"

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

#: ../../c-api/arg.rst:101
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:106
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:105
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:110
msgid ""
"``z#`` (:class:`str`, read-only :term:`bytes-like object` or ``None``) "
"[const char \\*, int]"
msgstr ""
"``z#`` (:class:`str`, 読み出し専用の :term:`bytes-like object` または ``None``) [const"
" char \\*, int]"

#: ../../c-api/arg.rst:109
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:120
msgid "``y`` (read-only :term:`bytes-like object`) [const char \\*]"
msgstr "``y`` (読み出し専用の :term:`bytes-like object`) [const char \\*]"

#: ../../c-api/arg.rst:113
msgid ""
"This format converts a bytes-like object to a C pointer to a 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 object をキャラクタ文字列を指す C のポインタに変換します; Unicode "
"オブジェクトを受け付けません。バイトバッファは null バイトを含むべきではありません; null バイトを含む場合は "
":exc:`ValueError` 例外を送出します。"

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

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

#: ../../c-api/arg.rst:123
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:129
msgid "``y#`` (read-only :term:`bytes-like object`) [const char \\*, int]"
msgstr "``y#`` (読み出し専用の :term:`bytes-like object`) [const char \\*, int]"

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

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

#: ../../c-api/arg.rst:132
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:type:`PyObject\\*`."
msgstr ""
"Pythonオブジェクトとして、 :class:`bytes` オブジェクトを要求し、いかなる変換も行いません。オブジェクトが bytes "
"オブジェクトでなければ、 :exc:`TypeError` を送出します。C 変数は :c:type:`PyObject\\*` "
"と宣言しても構いません。"

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

#: ../../c-api/arg.rst:137
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:type:`PyObject\\*`."
msgstr ""
"Python オブジェクトとして :class:`bytearray` オブジェクトを要求し、いかなる変換もおこないません。 もしオブジェクトが "
":class:`bytearray` でなければ、 :exc:`TypeError` を送出します。C 変数は "
":c:type:`PyObject\\*` として宣言しても構いません。"

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

#: ../../c-api/arg.rst:142
msgid ""
"Convert a Python Unicode object to a C pointer to a NUL-terminated buffer of"
" Unicode characters.  You must pass the address of a :c:type:`Py_UNICODE` "
"pointer variable, which will be filled with the pointer to an existing "
"Unicode buffer.  Please note that the width of a :c:type:`Py_UNICODE` "
"character depends on compilation options (it is either 16 or 32 bits). The "
"Python string must not contain embedded null code points; if it does, a "
":exc:`ValueError` exception is raised."
msgstr ""
"Python Unicodeオブジェクトを NUL終端されたUnicode文字バッファへのポインタに変換します。 "
":c:type:`Py_UNICODE` ポインタ変数へのアドレスを渡さなければならず、このアドレスに存在する Unicode "
"バッファへのポインタが格納されます。 :c:type:`Py_UNICODE` 文字のバイト幅はコンパイルオプション(16 "
"または32ビットのどちらか)に依存することに注意してください。Python 文字列は null コードポイントを含んではなりません; null "
"コードポイントを含む場合、 :exc:`ValueError` 例外が送出されます。"

#: ../../c-api/arg.rst:157 ../../c-api/arg.rst:166 ../../c-api/arg.rst:174
#: ../../c-api/arg.rst:182
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using "
":c:func:`PyUnicode_AsWideCharString`."
msgstr ""

#: ../../c-api/arg.rst:165
msgid "``u#`` (:class:`str`) [const Py_UNICODE \\*, int]"
msgstr ""

#: ../../c-api/arg.rst:159
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.  This variant allows "
"null code points."
msgstr ""
"これは ``u`` のバリエーションで、値を二つの変数に記録します。一つ目の変数は Unicode "
"データバッファへのポインタで、二つ目はその長さです。このフォーマットは null コードポイントを含むことができます。"

#: ../../c-api/arg.rst:173
msgid "``Z`` (:class:`str` or ``None``) [const Py_UNICODE \\*]"
msgstr ""

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

#: ../../c-api/arg.rst:181
msgid "``Z#`` (:class:`str` or ``None``) [const Py_UNICODE \\*, int]"
msgstr ""

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

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

#: ../../c-api/arg.rst:184
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:type:`PyObject\\*`."
msgstr ""
"Python オブジェクトとして Unicode オブジェクトを要求し、いかなる変換も行いません。オブジェクトが Unicode "
"オブジェクトではない場合、 :exc:`TypeError` が送出されます。C変数は :c:type:`PyObject\\*` "
"として宣言しても構いません。"

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

#: ../../c-api/arg.rst:189
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 have to call "
":c:func:`PyBuffer_Release` when it is done with the buffer."
msgstr ""
"このフォーマットは、読み書き可能な buffer interface を実装したオブジェクトを受け付けます。 呼び出し元から渡された "
":c:type:`Py_buffer` 構造体に値を格納します。バッファは nullバイトを含むかもしれず、呼び出し元はバッファを使い終わったら "
":c:func:`PyBuffer_Release` を呼び出さなければなりません。"

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

#: ../../c-api/arg.rst:195
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:198
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 ``'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: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\\*` 型または、 ``'utf-8'`` が使われることを表す *NULL* でなければなりません。指定したエンコード名を Python "
"が理解できない場合には例外を送出します。第二の引数は :c:type:`char\\*\\*` でなければなりません; "
"この引数が参照しているポインタの値は、引数に指定したテキストの内容が入ったバッファへのポインタになります。テキストは最初の引数に指定したエンコード方式でエンコードされます。"

#: ../../c-api/arg.rst:206
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:214
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:212
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:245
msgid ""
"``es#`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer, int "
"\\*buffer_length]"
msgstr ""
"``es#`` (:class:`str`) [const char \\*encoding, char \\*\\*buffer, int "
"\\*buffer_length]"

#: ../../c-api/arg.rst:217
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:221
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 ``'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: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* の場合には ``'utf-8'`` を使います。指定したエンコード名を "
"Python が理解できない場合には例外を送出します。第二の引数は :c:type:`char\\*\\*` でなければなりません; "
"この引数が参照しているポインタの値は、引数に指定したテキストの内容が入ったバッファへのポインタになります。テキストは最初の引数に指定したエンコード方式でエンコードされます。第三の引数は整数へのポインタでなければなりません;"
" ポインタが参照している整数の値は出力バッファ内のバイト数にセットされます。"

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

#: ../../c-api/arg.rst:233
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:238
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:244
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:250
msgid ""
"``et#`` (:class:`str`, :class:`bytes` or :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer, int \\*buffer_length]"
msgstr ""
"``et#`` (:class:`str`, :class:`bytes` または :class:`bytearray`) [const char "
"\\*encoding, char \\*\\*buffer, int \\*buffer_length]"

#: ../../c-api/arg.rst:248
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:253
msgid "Numbers"
msgstr "数"

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

#: ../../c-api/arg.rst:256
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:261 ../../c-api/arg.rst:600
msgid "``B`` (:class:`int`) [unsigned char]"
msgstr "``B`` (:class:`int`) [unsigned char]"

#: ../../c-api/arg.rst:260
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:264 ../../c-api/arg.rst:594
msgid "``h`` (:class:`int`) [short int]"
msgstr "``h`` (:class:`int`) [short int]"

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

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

#: ../../c-api/arg.rst:267
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:271 ../../c-api/arg.rst:588
msgid "``i`` (:class:`int`) [int]"
msgstr "``i`` (:class:`int`) [int]"

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

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

#: ../../c-api/arg.rst:274
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:278 ../../c-api/arg.rst:597
msgid "``l`` (:class:`int`) [long int]"
msgstr "``l`` (:class:`int`) [long int]"

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

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

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

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

#: ../../c-api/arg.rst:285
msgid "Convert a Python integer to a C :c:type:`long long`."
msgstr "PythonのintをC :c:type:`long long` へ変換する。"

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

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

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

#: ../../c-api/arg.rst:292
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:299
msgid "``c`` (:class:`bytes` or :class:`bytearray` of length 1) [char]"
msgstr "``c`` (長さ 1 の、 :class:`bytes` または :class:`bytearray`) [char]"

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

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

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

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

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

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

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

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

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

#: ../../c-api/arg.rst:312
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:315
msgid "Other objects"
msgstr "その他のオブジェクト"

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

#: ../../c-api/arg.rst:318
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:327
msgid "``O!`` (object) [*typeobject*, PyObject \\*]"
msgstr "``O!`` (object) [*typeobject*, PyObject \\*]"

#: ../../c-api/arg.rst:323
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:352 ../../c-api/arg.rst:657
msgid "``O&`` (object) [*converter*, *anything*]"
msgstr "``O&`` (object) [*converter*, *anything*]"

#: ../../c-api/arg.rst:332
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:339
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:345
msgid ""
"If the *converter* returns ``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 ""
"もし *converter* が ``Py_CLEANUP_SUPPORTED`` "
"を返すと、引数のパースが失敗した際に、コンバーターをもう一度呼び出し、すでに割り当てたメモリを開放するチャンスを与えます。二度目の呼び出しでは "
"*object* 引数は NULL になり、*address* は最初の呼び出しと同じ値になります。"

#: ../../c-api/arg.rst:351
msgid "``Py_CLEANUP_SUPPORTED`` was added."
msgstr "``Py_CLEANUP_SUPPORTED`` の追加。"

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

#: ../../c-api/arg.rst:355
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 ../../c-api/arg.rst:660
msgid "``(items)`` (:class:`tuple`) [*matching-items*]"
msgstr "``(items)`` (:class:`tuple`) [*matching-items*]"

#: ../../c-api/arg.rst:364
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:368
msgid ""
"It is possible to pass \"long\" integers (integers whose value exceeds the "
"platform's :const:`LONG_MAX`) 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 ""
"\"長\" 整数 (プラットフォームの :const:`LONG_MAX` を超える値の整数) を渡すのは可能です; "
"しかしながら、適切な値域チェックはまったく行われません --- "
"値を受け取るためのフィールドが、値全てを受け取るには小さすぎる場合、上桁のビット群は暗黙のうちに切り詰められます (実際のところ、このセマンティクスは "
"C のダウンキャスト (downcast) から継承しています --- その恩恵は人それぞれかもしれませんが)。"

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

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

#: ../../c-api/arg.rst:385
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引数が keyword-"
"onlyであることを示します。現在、すべてのkeyword-only 引数は任意の引数でなければならず、そのため フォーマット文字列中の ``|`` "
"は常に ``$`` より前に指定されなければなりません。"

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

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

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

#: ../../c-api/arg.rst:406
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:412
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:421
msgid "API Functions"
msgstr "API 関数"

#: ../../c-api/arg.rst:425
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:432
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:438
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.  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 ""
"位置引数とキーワード引数の両者を取る関数の引数を解釈します。 *keywords* 引数は *NULL* で終端されたキーワード名の配列です。\n"
"空の名前は :ref:`位置引数のみ <positional-only_parameter>` を示します。成功した場合、真を返します。失敗した場合は偽を返し、また適切な例外を発生させます。"

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

#: ../../c-api/arg.rst:452
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:458
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:468
msgid ""
"Function used to deconstruct the argument lists of \"old-style\" functions "
"--- these are functions which use the :const:`METH_OLDARGS` parameter "
"parsing method, which has been removed in Python 3.  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 ""
"\"旧スタイル\" の関数における引数リストを分析するために使われる関数です --- 旧スタイルの関数は、引数解釈手法に、Python 3 で削除された"
"  :const:`METH_OLDARGS` "
"を使います。新たに書かれるコードでのパラメタ解釈にはこの関数の使用は奨められず、標準のインタプリタにおけるほとんどのコードがもはや引数解釈のためにこの関数を使わないように変更済みです。この関数を残しているのは、この関数が依然として引数以外のタプルを分析する上で便利だからですが、この目的においては将来も使われつづけるかもしれません。"

#: ../../c-api/arg.rst:479
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:493
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:509
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:517
msgid "Building values"
msgstr "値の構築"

#: ../../c-api/arg.rst:521
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:526
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:532
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:540
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:544
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:550
msgid "``s`` (:class:`str` or ``None``) [const char \\*]"
msgstr ""

#: ../../c-api/arg.rst:549
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:555
msgid "``s#`` (:class:`str` or ``None``) [const char \\*, int]"
msgstr ""

#: ../../c-api/arg.rst:553
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:559
msgid "``y`` (:class:`bytes`) [const char \\*]"
msgstr "``y`` (:class:`bytes`) [const char \\*]"

#: ../../c-api/arg.rst:558
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:563
msgid "``y#`` (:class:`bytes`) [const char \\*, int]"
msgstr "``y#`` (:class:`bytes`) [const char \\*, int]"

#: ../../c-api/arg.rst:562
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:566 ../../c-api/arg.rst:582
msgid "Same as ``s``."
msgstr "``s`` と同じです。"

#: ../../c-api/arg.rst:569
msgid "``z#`` (:class:`str` or ``None``) [const char \\*, int]"
msgstr ""

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

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

#: ../../c-api/arg.rst:572
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 ""

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

#: ../../c-api/arg.rst:577
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 ""

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

#: ../../c-api/arg.rst:585
msgid "``U#`` (:class:`str` or ``None``) [const char \\*, int]"
msgstr ""

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

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

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

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

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

#: ../../c-api/arg.rst:603
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:606
msgid "Convert a C :c:type:`unsigned int` to a Python integer object."
msgstr "C の :c:type:`unsigned int` を Python の整数オブジェクトに変換します。"

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

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

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

#: ../../c-api/arg.rst:618
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:622
msgid "``c`` (:class:`bytes` of length 1) [char]"
msgstr "``c`` (長さが 1 の :class:`bytes`) [char]"

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

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

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

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

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

#: ../../c-api/arg.rst:635
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:638
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* を返しますが例外は送出しません。例外をまだ送出していなければ "
":exc:`SystemError` をセットします。"

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

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

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

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

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

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

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

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