unicode.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2018
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:48+0900\n"
"PO-Revision-Date: 2018-06-29 17:50+0000\n"
"Last-Translator: tomo, 2018\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"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/unicode.rst:6
msgid "Unicode Objects and Codecs"
msgstr "Unicode オブジェクトと codec"

#: ../../c-api/unicode.rst:12
msgid "Unicode Objects"
msgstr "Unicode オブジェクト"

#: ../../c-api/unicode.rst:14
msgid ""
"Since the implementation of :pep:`393` in Python 3.3, Unicode objects "
"internally use a variety of representations, in order to allow handling the "
"complete range of Unicode characters while staying memory efficient.  There "
"are special cases for strings where all code points are below 128, 256, or "
"65536; otherwise, code points must be below 1114112 (which is the full "
"Unicode range)."
msgstr ""
"Python3.3 の :pep:`393` 実装から、メモリ効率を維持しながらUnicode文字の完全な"
"範囲を扱えるように、Unicodeオブジェクトは内部的に多様な表現形式を用いていま"
"す。すべてのコードポイントが128、256または65536以下の文字列に対して特別なケー"
"スが存在しますが、それ以外ではコードポイントは1114112以下(これはすべての"
"Unicode範囲です)でなければなりません。"

#: ../../c-api/unicode.rst:20
msgid ""
":c:type:`Py_UNICODE*` and UTF-8 representations are created on demand and "
"cached in the Unicode object.  The :c:type:`Py_UNICODE*` representation is "
"deprecated and inefficient; it should be avoided in performance- or memory-"
"sensitive situations."
msgstr ""
":c:type:`Py_UNICODE*` 表現形式および UTF-8表現形式はオンデマンドで作成され、"
"Unicode オブジェクト内にキャッシュされます。:c:type:`Py_UNICODE*` 表現は推奨"
"されず、非効率ですので、重要なタスクを実行し、メモリを消費している状況下では"
"避けるべきです。"

#: ../../c-api/unicode.rst:25
msgid ""
"Due to the transition between the old APIs and the new APIs, unicode objects "
"can internally be in two states depending on how they were created:"
msgstr ""
"古いAPI群と新しいAPI群での変換のために、ユニコードオブジェクトは、オブジェク"
"トがどのように生成されたかによって、内部的に２つの状態を持ちます。"

#: ../../c-api/unicode.rst:28
msgid ""
"\"canonical\" unicode objects are all objects created by a non-deprecated "
"unicode API.  They use the most efficient representation allowed by the "
"implementation."
msgstr ""
"\"正統な\" unicode オブジェクトは、非推奨ではないunicode APIで作成されたすべ"
"てのオブジェクトです。これらのオブジェクトは実装が許すかぎり最も効率の良い表"
"現形式を使用します。"

#: ../../c-api/unicode.rst:32
msgid ""
"\"legacy\" unicode objects have been created through one of the deprecated "
"APIs (typically :c:func:`PyUnicode_FromUnicode`) and only bear the :c:type:"
"`Py_UNICODE*` representation; you will have to call :c:func:"
"`PyUnicode_READY` on them before calling any other API."
msgstr ""
"\"古い\" unicode オブジェクトは、非推奨の API (たいていは :c:func:"
"`PyUnicode_FromUnicode`) で作成されたオブジェクトで、 :c:type:`Py_UNICODE*` "
"表現形式しか持ってません;\n"
"他の API を呼び出す前に、このオブジェクトに対し :c:func:`PyUnicode_READY` を"
"呼び出す必要があるでしょう。"

#: ../../c-api/unicode.rst:39
msgid "Unicode Type"
msgstr "Unicode 型"

#: ../../c-api/unicode.rst:41
msgid ""
"These are the basic Unicode object types used for the Unicode implementation "
"in Python:"
msgstr ""
"以下は Python の Unicode 実装に用いられている基本 Unicode オブジェクト型です:"

#: ../../c-api/unicode.rst:48
msgid ""
"These types are typedefs for unsigned integer types wide enough to contain "
"characters of 32 bits, 16 bits and 8 bits, respectively.  When dealing with "
"single Unicode characters, use :c:type:`Py_UCS4`."
msgstr ""
"これらの型は、それぞれ、32ビット、16ビット、そして8ビットの文字を保持するのに"
"充分な幅を持つ符号なしの整数型のtypedefです。単一のUnicode文字を扱う場合"
"は、 :c:type:`Py_UCS4` を用いてください。"

#: ../../c-api/unicode.rst:57
msgid ""
"This is a typedef of :c:type:`wchar_t`, which is a 16-bit type or 32-bit "
"type depending on the platform."
msgstr ""
"これは、:c:type:`wchar_t` のtypedef で、プラットフォームに依存して16ビットか"
"32ビットの型になります。"

#: ../../c-api/unicode.rst:60
msgid ""
"In previous versions, this was a 16-bit type or a 32-bit type depending on "
"whether you selected a \"narrow\" or \"wide\" Unicode version of Python at "
"build time."
msgstr ""
"以前のバージョンでは、Pythonをビルドした際に \"narrow\" または \"wide\" "
"Unicode バージョンのどちらを選択したかによって、 16ビットか32ビットのどちらか"
"の型になっていました。"

#: ../../c-api/unicode.rst:70
msgid ""
"These subtypes of :c:type:`PyObject` represent a Python Unicode object.  In "
"almost all cases, they shouldn't be used directly, since all API functions "
"that deal with Unicode objects take and return :c:type:`PyObject` pointers."
msgstr ""
"これらの :c:type:`PyObject` のサブタイプは Python Unicode オブジェクトを表現"
"します。\n"
"Unicode オブジェクトを扱う全ての API 関数は :c:type:`PyObject` へのポインタを"
"受け取って PyObject へのポインタを返すので、ほとんどの場合、これらの型を直接"
"使うべきではありません。"

#: ../../c-api/unicode.rst:79
msgid ""
"This instance of :c:type:`PyTypeObject` represents the Python Unicode type.  "
"It is exposed to Python code as ``str``."
msgstr ""
"この :c:type:`PyTypeObject` のインスタンスは、Python Unicode型を表します。こ"
"れは、Pythonコードに ``str`` として露出されます。"

#: ../../c-api/unicode.rst:83
msgid ""
"The following APIs are really C macros and can be used to do fast checks and "
"to access internal read-only data of Unicode objects:"
msgstr ""
"以下の API は実際には C マクロで、Unicode オブジェクト内部の読み取り専用デー"
"タに対するチェックやアクセスを高速に行います:"

#: ../../c-api/unicode.rst:88
msgid ""
"Return true if the object *o* is a Unicode object or an instance of a "
"Unicode subtype."
msgstr ""
"*o* が Unicode 文字列型か Unicode 文字列型のサブタイプであるときに真を返しま"
"す。"

#: ../../c-api/unicode.rst:94
msgid ""
"Return true if the object *o* is a Unicode object, but not an instance of a "
"subtype."
msgstr ""
"*o* が Unicode 文字列型で、かつ Unicode 文字列型のサブタイプでないときに真を"
"返します。"

#: ../../c-api/unicode.rst:100
msgid ""
"Ensure the string object *o* is in the \"canonical\" representation.  This "
"is required before using any of the access macros described below."
msgstr ""
"文字列オブジェクト *o* が \"正統な\" 表現形式であることを保証します。\n"
"このマクロは、下で説明しているどのアクセスマクロを使うときも必要となります。"

#: ../../c-api/unicode.rst:105
msgid ""
"Returns ``0`` on success and ``-1`` with an exception set on failure, which "
"in particular happens if memory allocation fails."
msgstr ""
"成功のときには ``0`` を返し、失敗のときには例外を設定し ``-1`` を返します。\n"
"後者は、メモリ確保に失敗したときに特に起きやすいです。"

#: ../../c-api/unicode.rst:113
msgid ""
"Return the length of the Unicode string, in code points.  *o* has to be a "
"Unicode object in the \"canonical\" representation (not checked)."
msgstr ""
"Unicode 文字列のコードポイントでの長さを返します。\n"
"*o* は \"正統な\" 表現形式の Unicode オブジェクトでなければなりません (ただし"
"チェックはしません)。"

#: ../../c-api/unicode.rst:123
msgid ""
"Return a pointer to the canonical representation cast to UCS1, UCS2 or UCS4 "
"integer types for direct character access.  No checks are performed if the "
"canonical representation has the correct character size; use :c:func:"
"`PyUnicode_KIND` to select the right macro.  Make sure :c:func:"
"`PyUnicode_READY` has been called before accessing this."
msgstr ""
"文字に直接アクセスするために、 UCS1, UCS2, UCS4 のいずれかの整数型にキャスト"
"された正統な表現形式へのポインタを返します。\n"
"正統な表現が適正な文字サイズになっているかどうかのチェックはしません;\n"
":c:func:`PyUnicode_KIND` を使って正しいマクロを選んでください。\n"
"このオブジェクトにアクセスする前に、忘れずに :c:func:`PyUnicode_READY` を呼び"
"出してください。"

#: ../../c-api/unicode.rst:137
msgid "Return values of the :c:func:`PyUnicode_KIND` macro."
msgstr ":c:func:`PyUnicode_KIND` マクロの返り値です。"

#: ../../c-api/unicode.rst:144
msgid ""
"Return one of the PyUnicode kind constants (see above) that indicate how "
"many bytes per character this Unicode object uses to store its data.  *o* "
"has to be a Unicode object in the \"canonical\" representation (not checked)."
msgstr ""
"この Unicode がデータを保存するのに1文字あたり何バイト使っているかを示す "
"PyUnicode 種別の定数 (上を読んでください) のうち1つを返します。\n"
"*o* は \"正統な\" 表現形式の Unicode オブジェクトでなければなりません (ただし"
"チェックはしません)。"

#: ../../c-api/unicode.rst:155
msgid ""
"Return a void pointer to the raw unicode buffer.  *o* has to be a Unicode "
"object in the \"canonical\" representation (not checked)."
msgstr ""
"生の unicode バッファへの void ポインタを返します。\n"
"*o* は \"正統な\" 表現形式の Unicode オブジェクトでなければなりません (ただし"
"チェックはしません)。"

#: ../../c-api/unicode.rst:164
msgid ""
"Write into a canonical representation *data* (as obtained with :c:func:"
"`PyUnicode_DATA`).  This macro does not do any sanity checks and is intended "
"for usage in loops.  The caller should cache the *kind* value and *data* "
"pointer as obtained from other macro calls.  *index* is the index in the "
"string (starts at 0) and *value* is the new code point value which should be "
"written to that location."
msgstr ""
"正統な表現形式となっている (:c:func:`PyUnicode_DATA` で取得した) *data* に書"
"き込みます。\n"
"このマクロは正常性のチェックを一切行わない、ループで使われるためのもので"
"す。\n"
"呼び出し側は、他のマクロを呼び出して取得した *kind* 値と *data* ポインタを"
"キャッシュすべきです。\n"
"*index* は文字列の (0始まりの) インデックスで、 *value* はその場所に書き込ま"
"れることになる新しいコードポイントの値です。"

#: ../../c-api/unicode.rst:176
msgid ""
"Read a code point from a canonical representation *data* (as obtained with :"
"c:func:`PyUnicode_DATA`).  No checks or ready calls are performed."
msgstr ""
"正統な表現形式となっている (:c:func:`PyUnicode_DATA` で取得した) *data* から"
"コードポイントを読み取ります。\n"
"チェックや事前確認のマクロ呼び出しは一切行われません。"

#: ../../c-api/unicode.rst:184
msgid ""
"Read a character from a Unicode object *o*, which must be in the "
"\"canonical\" representation.  This is less efficient than :c:func:"
"`PyUnicode_READ` if you do multiple consecutive reads."
msgstr ""
"Unicode オブジェクト *o* から文字を読み取ります。\n"
"この Unicode オブジェクトは \"正統な\" 表現形式でなければなりません。\n"
"何度も連続して読み取る場合には、このマクロは :c:func:`PyUnicode_READ` よりも"
"非効率的です。"

#: ../../c-api/unicode.rst:193
msgid ""
"Return the maximum code point that is suitable for creating another string "
"based on *o*, which must be in the \"canonical\" representation.  This is "
"always an approximation but more efficient than iterating over the string."
msgstr ""
"*o* に基づいて他の文字列を作るのに適した最大のコードポイントを返します。\n"
"この Unicode オブジェクトは \"正統な\" 表現形式でなければなりません。\n"
"この値は常に概算値ですが、文字列全体を調べるよりも効率的です。"

#: ../../c-api/unicode.rst:202
msgid "Clear the free list. Return the total number of freed items."
msgstr "free list をクリアします。解放された要素数を返します。"

#: ../../c-api/unicode.rst:207
msgid ""
"Return the size of the deprecated :c:type:`Py_UNICODE` representation, in "
"code units (this includes surrogate pairs as 2 units).  *o* has to be a "
"Unicode object (not checked)."
msgstr ""
"非推奨の :c:type:`Py_UNICODE` 表現形式のサイズをコード単位で返します (サロ"
"ゲートペアを2つとしています)。\n"
"*o* は Unicode オブジェクトでなければなりません (ただしチェックはしません)。"

#: ../../c-api/unicode.rst:213 ../../c-api/unicode.rst:223
msgid ""
"Part of the old-style Unicode API, please migrate to using :c:func:"
"`PyUnicode_GET_LENGTH`."
msgstr ""
"古いスタイルの Unicode APIの一部なので、 :c:func:`PyUnicode_GET_LENGTH` を使"
"用するように移行してください。"

#: ../../c-api/unicode.rst:218
msgid ""
"Return the size of the deprecated :c:type:`Py_UNICODE` representation in "
"bytes.  *o* has to be a Unicode object (not checked)."
msgstr ""
"非推奨の :c:type:`Py_UNICODE` 表現形式のサイズをバイト単位で返します。\n"
"*o* は Unicode オブジェクトでなければなりません (ただしチェックはしません)。"

#: ../../c-api/unicode.rst:229
msgid ""
"Return a pointer to a :c:type:`Py_UNICODE` representation of the object.  "
"The returned buffer is always terminated with an extra null code point.  It "
"may also contain embedded null code points, which would cause the string to "
"be truncated when used in most C functions.  The ``AS_DATA`` form casts the "
"pointer to :c:type:`const char *`.  The *o* argument has to be a Unicode "
"object (not checked)."
msgstr ""
"与えられたオブジェクトの :c:type:`Py_UNICODE` 表現形式へのポインタを返しま"
"す。\n"
"返されるバッファは常に終端に null コードポイントが1つ余分に付いています。\n"
"それとは別の null コードポイントがバッファに含まれることもあるかもしれません"
"が、たいていの C 関数ではそのような文字列は切り詰められてしまうでしょう。\n"
"``AS_DATA`` の方はポインタを :c:type:`const char *` にキャストしています。\n"
"引数 *o* は Unicode オブジェクトでなければなりません (ただしチェックはしませ"
"ん)。"

#: ../../c-api/unicode.rst:236
msgid ""
"This macro is now inefficient -- because in many cases the :c:type:"
"`Py_UNICODE` representation does not exist and needs to be created -- and "
"can fail (return *NULL* with an exception set).  Try to port the code to use "
"the new :c:func:`PyUnicode_nBYTE_DATA` macros or use :c:func:"
"`PyUnicode_WRITE` or :c:func:`PyUnicode_READ`."
msgstr ""
"このマクロは今では非効率なものになりました。\n"
"というのも、多くのケースで :c:type:`Py_UNICODE` 表現形式が登場せず、作成され"
"ず、そして失敗し得ます (例外を設定して *NULL* を返します)。\n"
"コードを修正して、 :c:func:`PyUnicode_nBYTE_DATA` マクロを使うか :c:func:"
"`PyUnicode_WRITE` や :c:func:`PyUnicode_READ` を使うようにしてください。"

#: ../../c-api/unicode.rst:245
msgid ""
"Part of the old-style Unicode API, please migrate to using the :c:func:"
"`PyUnicode_nBYTE_DATA` family of macros."
msgstr ""
"古いスタイルの Unicode APIの一部なので、 :c:func:`PyUnicode_nBYTE_DATA` 系の"
"マクロを使用するように移行してください。"

#: ../../c-api/unicode.rst:249
msgid "Unicode Character Properties"
msgstr "Unicode 文字プロパティ"

#: ../../c-api/unicode.rst:251
msgid ""
"Unicode provides many different character properties. The most often needed "
"ones are available through these macros which are mapped to C functions "
"depending on the Python configuration."
msgstr ""
"Unicode は数多くの異なる文字プロパティ (character property) を提供していま"
"す。よく使われる文字プロパティは、以下のマクロで利用できます。これらのマクロ"
"は Python の設定に応じて、各々 C の関数に対応付けられています。"

#: ../../c-api/unicode.rst:258
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a whitespace character."
msgstr "*ch* が空白文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:263
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a lowercase character."
msgstr "*ch* が小文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:268
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is an uppercase character."
msgstr "*ch* が大文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:273
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a titlecase character."
msgstr ""
"*ch* がタイトルケース文字 (titlecase character) かどうかに応じて ``1`` また"
"は ``0`` を返します。"

#: ../../c-api/unicode.rst:278
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a linebreak character."
msgstr "*ch* が改行文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:283
msgid "Return ``1`` or ``0`` depending on whether *ch* is a decimal character."
msgstr "*ch* が decimal 文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:288
msgid "Return ``1`` or ``0`` depending on whether *ch* is a digit character."
msgstr "*ch* が digit 文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:293
msgid "Return ``1`` or ``0`` depending on whether *ch* is a numeric character."
msgstr ""
"*ch* が数字 (numeric) 文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:298
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is an alphabetic character."
msgstr ""
"*ch* がアルファベット文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:303
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is an alphanumeric character."
msgstr "*ch* が英数文字かどうかに応じて ``1`` または ``0`` を返します。"

#: ../../c-api/unicode.rst:308
msgid ""
"Return ``1`` or ``0`` depending on whether *ch* is a printable character. "
"Nonprintable characters are those characters defined in the Unicode "
"character database as \"Other\" or \"Separator\", excepting the ASCII space "
"(0x20) which is considered printable.  (Note that printable characters in "
"this context are those which should not be escaped when :func:`repr` is "
"invoked on a string. It has no bearing on the handling of strings written "
"to :data:`sys.stdout` or :data:`sys.stderr`.)"
msgstr ""
"*ch* が文字が印字可能な文字かどうかに基づいて ``1`` または ``0`` を返しま"
"す。\n"
"非印字可能文字は、 Unicode 文字データベースで \"Other\" または \"Separator\" "
"と定義されている文字の、印字可能と見なされる ASCII space (0x20) 以外のもので"
"す。\n"
"(なお、この文脈での印字可能文字は、文字列に :func:`repr` が呼び出されるときに"
"エスケープすべきでない文字のことです。これは :data:`sys.stdout` や :data:"
"`sys.stderr` に書き込まれる文字列の操作とは関係ありません。)"

#: ../../c-api/unicode.rst:317
msgid "These APIs can be used for fast direct character conversions:"
msgstr "以下の API は、高速に直接文字変換を行うために使われます:"

#: ../../c-api/unicode.rst:322
msgid "Return the character *ch* converted to lower case."
msgstr "*ch* を小文字に変換したものを返します。"

#: ../../c-api/unicode.rst:324 ../../c-api/unicode.rst:332
#: ../../c-api/unicode.rst:340
msgid "This function uses simple case mappings."
msgstr "この関数は単純な大文字小文字変換を使ってます。"

#: ../../c-api/unicode.rst:330
msgid "Return the character *ch* converted to upper case."
msgstr "*ch* を大文字に変換したものを返します。"

#: ../../c-api/unicode.rst:338
msgid "Return the character *ch* converted to title case."
msgstr "*ch* をタイトルケース文字に変換したものを返します。"

#: ../../c-api/unicode.rst:346
msgid ""
"Return the character *ch* converted to a decimal positive integer.  Return "
"``-1`` if this is not possible.  This macro does not raise exceptions."
msgstr ""
"*ch* を 10 進の正の整数に変換したものを返します。不可能ならば ``-1`` を返しま"
"す。このマクロは例外を送出しません。"

#: ../../c-api/unicode.rst:352
msgid ""
"Return the character *ch* converted to a single digit integer. Return ``-1`` "
"if this is not possible.  This macro does not raise exceptions."
msgstr ""
"*ch* を一桁の 2 進整数に変換したものを返します。不可能ならば ``-1`` を返しま"
"す。このマクロは例外を送出しません。"

#: ../../c-api/unicode.rst:358
msgid ""
"Return the character *ch* converted to a double. Return ``-1.0`` if this is "
"not possible.  This macro does not raise exceptions."
msgstr ""
"*ch* を :c:type:`double` に変換したものを返します。不可能ならば ``-1.0`` を返"
"します。このマクロは例外を送出しません。"

#: ../../c-api/unicode.rst:362
msgid "These APIs can be used to work with surrogates:"
msgstr "これらの API はサロゲートにも使えます:"

#: ../../c-api/unicode.rst:366
msgid "Check if *ch* is a surrogate (``0xD800 <= ch <= 0xDFFF``)."
msgstr ""
"*ch* がサロゲートかどうか (``0xD800 <= ch <= 0xDFFF``) をチェックします。"

#: ../../c-api/unicode.rst:370
msgid "Check if *ch* is a high surrogate (``0xD800 <= ch <= 0xDBFF``)."
msgstr ""
"*ch* が上位サロゲートかどうか (``0xD800 <= ch <= 0xDBFF``) をチェックします。"

#: ../../c-api/unicode.rst:374
msgid "Check if *ch* is a low surrogate (``0xDC00 <= ch <= 0xDFFF``)."
msgstr ""
"*ch* が下位サロゲートかどうか (``0xDC00 <= ch <= 0xDFFF``) をチェックします。"

#: ../../c-api/unicode.rst:378
msgid ""
"Join two surrogate characters and return a single Py_UCS4 value. *high* and "
"*low* are respectively the leading and trailing surrogates in a surrogate "
"pair."
msgstr ""
"2つのサロゲート文字を組み合わせて単一の Py_UCS4 値を返します。\n"
"*high* と *low* はそれぞれサロゲートペアの前半分と後半分です。"

#: ../../c-api/unicode.rst:384
msgid "Creating and accessing Unicode strings"
msgstr "Unicode 文字列の生成とアクセス"

#: ../../c-api/unicode.rst:386
msgid ""
"To create Unicode objects and access their basic sequence properties, use "
"these APIs:"
msgstr ""
"Unicode オブジェクトを生成したり、Unicode のシーケンスとしての基本的なプロパ"
"ティにアクセスしたりするには、以下の API を使ってください:"

#: ../../c-api/unicode.rst:391
msgid ""
"Create a new Unicode object.  *maxchar* should be the true maximum code "
"point to be placed in the string.  As an approximation, it can be rounded up "
"to the nearest value in the sequence 127, 255, 65535, 1114111."
msgstr ""
"新しい Unicode オブジェクトを生成します。\n"
"*maxchar* は文字列に並べるコードポイントの正しい最大値にすべきです。\n"
"その値は概算値として 127, 255, 65535, 1114111 の一番近い値に切り上げられま"
"す。"

#: ../../c-api/unicode.rst:395
msgid ""
"This is the recommended way to allocate a new Unicode object.  Objects "
"created using this function are not resizable."
msgstr ""
"これは新しい Unicode オブジェクトを生成する推奨された方法です。\n"
"この関数を使って生成されたオブジェクトはサイズ変更は不可能です。"

#: ../../c-api/unicode.rst:404
msgid ""
"Create a new Unicode object with the given *kind* (possible values are :c:"
"macro:`PyUnicode_1BYTE_KIND` etc., as returned by :c:func:"
"`PyUnicode_KIND`).  The *buffer* must point to an array of *size* units of "
"1, 2 or 4 bytes per character, as given by the kind."
msgstr ""
"与えられた *kind* (取り得る値は :c:macro:`PyUnicode_1BYTE_KIND` などの :c:"
"func:`PyUnicode_KIND` が返す値です) の Unicode オブジェクトを生成します。\n"
"*buffer* は、与えられた kind に従って1文字あたり 1, 2, 4 バイトのいずれかを単"
"位として、長さ *size* の配列へのポインタでなければなりません。"

#: ../../c-api/unicode.rst:414
msgid ""
"Create a Unicode object from the char buffer *u*.  The bytes will be "
"interpreted as being UTF-8 encoded.  The buffer is copied into the new "
"object. If the buffer is not *NULL*, the return value might be a shared "
"object, i.e. modification of the data is not allowed."
msgstr ""
"char 型バッファ *u* から Unicode オブジェクトを生成します。\n"
"*u* の内容は UTF-8 でエンコードされているものとします。\n"
"バッファの内容は新たなオブジェクトにコピーされます。\n"
"\n"
"バッファが *NULL* でない場合、帰り値は共有されたオブジェクトになることがあり"
"ます。\n"
"つまり、この関数が返す Unicode オブジェクトの変更は許されていません。"

#: ../../c-api/unicode.rst:419
msgid ""
"If *u* is *NULL*, this function behaves like :c:func:`PyUnicode_FromUnicode` "
"with the buffer set to *NULL*.  This usage is deprecated in favor of :c:func:"
"`PyUnicode_New`."
msgstr ""
"*u* が *NULL* の場合は、この関数は :c:func:`PyUnicode_FromUnicode` でバッ"
"ファ *u* を *NULL* にセットしたのと同じように振る舞います。\n"
"この関数は非推奨です。変わりに :c:func:`PyUnicode_New` を使ってください。"

#: ../../c-api/unicode.rst:426
msgid ""
"Create a Unicode object from a UTF-8 encoded null-terminated char buffer *u*."
msgstr ""
"UTF-8 エンコードされたnull終端のchar 型バッファ *u* から Unicode オブジェクト"
"を生成します。"

#: ../../c-api/unicode.rst:432
msgid ""
"Take a C :c:func:`printf`\\ -style *format* string and a variable number of "
"arguments, calculate the size of the resulting Python unicode string and "
"return a string with the values formatted into it.  The variable arguments "
"must be C types and must correspond exactly to the format characters in the "
"*format* ASCII-encoded string. The following format characters are allowed:"
msgstr ""
":c:func:`printf` スタイルの *format* 文字列と可変長引数を受け取り、結果の "
"unicode 文字の長さを計算し、フォーマットされた文字列を含む unicode オブジェク"
"トを返します。可変長引数は C の型を持っていて、 *format* ASCII エンコード文字"
"列で指定された書式指定文字に完全に従う必要があります。以下の書式指定文字が利"
"用できます:"

#: ../../c-api/unicode.rst:447
msgid "Format Characters"
msgstr "書式指定文字"

#: ../../c-api/unicode.rst:447
msgid "Type"
msgstr "型"

#: ../../c-api/unicode.rst:447
msgid "Comment"
msgstr "備考"

#: ../../c-api/unicode.rst:449
msgid ":attr:`%%`"
msgstr ":attr:`%%`"

#: ../../c-api/unicode.rst:449
msgid "*n/a*"
msgstr "*n/a*"

#: ../../c-api/unicode.rst:449
msgid "The literal % character."
msgstr "リテラルの % 文字"

#: ../../c-api/unicode.rst:451
msgid ":attr:`%c`"
msgstr ":attr:`%c`"

#: ../../c-api/unicode.rst:451 ../../c-api/unicode.rst:454
#: ../../c-api/unicode.rst:487 ../../c-api/unicode.rst:490
msgid "int"
msgstr "int"

#: ../../c-api/unicode.rst:451
msgid "A single character, represented as a C int."
msgstr "C の整数型で表現される単一の文字。"

#: ../../c-api/unicode.rst:454
msgid ":attr:`%d`"
msgstr ":attr:`%d`"

#: ../../c-api/unicode.rst:454
msgid "Exactly equivalent to ``printf(\"%d\")``."
msgstr "C の ``printf(\"%d\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:457
msgid ":attr:`%u`"
msgstr ":attr:`%u`"

#: ../../c-api/unicode.rst:457
msgid "unsigned int"
msgstr "unsigned int"

#: ../../c-api/unicode.rst:457
msgid "Exactly equivalent to ``printf(\"%u\")``."
msgstr "C の ``printf(\"%u\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:460
msgid ":attr:`%ld`"
msgstr ":attr:`%ld`"

#: ../../c-api/unicode.rst:460 ../../c-api/unicode.rst:463
msgid "long"
msgstr "long"

#: ../../c-api/unicode.rst:460
msgid "Exactly equivalent to ``printf(\"%ld\")``."
msgstr "C の ``printf(\"%ld\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:463
msgid ":attr:`%li`"
msgstr ":attr:`%li`"

#: ../../c-api/unicode.rst:463
msgid "Exactly equivalent to ``printf(\"%li\")``."
msgstr "C の ``printf(\"%li\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:466
msgid ":attr:`%lu`"
msgstr ":attr:`%lu`"

#: ../../c-api/unicode.rst:466
msgid "unsigned long"
msgstr "unsigned long"

#: ../../c-api/unicode.rst:466
msgid "Exactly equivalent to ``printf(\"%lu\")``."
msgstr "C の ``printf(\"%lu\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:469
msgid ":attr:`%lld`"
msgstr ":attr:`%lld`"

#: ../../c-api/unicode.rst:469 ../../c-api/unicode.rst:472
msgid "long long"
msgstr "long long"

#: ../../c-api/unicode.rst:469
msgid "Exactly equivalent to ``printf(\"%lld\")``."
msgstr "C の ``printf(\"%lld\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:472
msgid ":attr:`%lli`"
msgstr ":attr:`%lli`"

#: ../../c-api/unicode.rst:472
msgid "Exactly equivalent to ``printf(\"%lli\")``."
msgstr "C の ``printf(\"%lli\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:475
msgid ":attr:`%llu`"
msgstr ":attr:`%llu`"

#: ../../c-api/unicode.rst:475
msgid "unsigned long long"
msgstr "unsigned long long"

#: ../../c-api/unicode.rst:475
msgid "Exactly equivalent to ``printf(\"%llu\")``."
msgstr "C の ``printf(\"%llu\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:478
msgid ":attr:`%zd`"
msgstr ":attr:`%zd`"

#: ../../c-api/unicode.rst:478 ../../c-api/unicode.rst:481
msgid "Py_ssize_t"
msgstr "Py_ssize_t"

#: ../../c-api/unicode.rst:478
msgid "Exactly equivalent to ``printf(\"%zd\")``."
msgstr "C の ``printf(\"%zd\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:481
msgid ":attr:`%zi`"
msgstr ":attr:`%zi`"

#: ../../c-api/unicode.rst:481
msgid "Exactly equivalent to ``printf(\"%zi\")``."
msgstr "C の ``printf(\"%zi\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:484
msgid ":attr:`%zu`"
msgstr ":attr:`%zu`"

#: ../../c-api/unicode.rst:484
msgid "size_t"
msgstr "size_t"

#: ../../c-api/unicode.rst:484
msgid "Exactly equivalent to ``printf(\"%zu\")``."
msgstr "C の ``printf(\"%zu\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:487
msgid ":attr:`%i`"
msgstr ":attr:`%i`"

#: ../../c-api/unicode.rst:487
msgid "Exactly equivalent to ``printf(\"%i\")``."
msgstr "C の ``printf(\"%i\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:490
msgid ":attr:`%x`"
msgstr ":attr:`%x`"

#: ../../c-api/unicode.rst:490
msgid "Exactly equivalent to ``printf(\"%x\")``."
msgstr "C の ``printf(\"%x\")`` と厳密に同じ。"

#: ../../c-api/unicode.rst:493
msgid ":attr:`%s`"
msgstr ":attr:`%s`"

#: ../../c-api/unicode.rst:493
msgid "char\\*"
msgstr "char\\*"

#: ../../c-api/unicode.rst:493
msgid "A null-terminated C character array."
msgstr "null で終端された C の文字列。"

#: ../../c-api/unicode.rst:496
msgid ":attr:`%p`"
msgstr ":attr:`%p`"

#: ../../c-api/unicode.rst:496
msgid "void\\*"
msgstr "void\\*"

#: ../../c-api/unicode.rst:496
msgid ""
"The hex representation of a C pointer. Mostly equivalent to "
"``printf(\"%p\")`` except that it is guaranteed to start with the literal "
"``0x`` regardless of what the platform's ``printf`` yields."
msgstr ""
"C ポインタの 16 進表記。``printf(\"%p\")`` とほとんど同じですが、プラット"
"フォームにおける ``printf`` の定義に関わりなく先頭にリテラル ``0x`` が付きま"
"す。"

#: ../../c-api/unicode.rst:504
msgid ":attr:`%A`"
msgstr ":attr:`%A`"

#: ../../c-api/unicode.rst:504 ../../c-api/unicode.rst:507
#: ../../c-api/unicode.rst:516 ../../c-api/unicode.rst:519
msgid "PyObject\\*"
msgstr "PyObject\\*"

#: ../../c-api/unicode.rst:504
msgid "The result of calling :func:`ascii`."
msgstr ":func:`ascii` の戻り値。"

#: ../../c-api/unicode.rst:507
msgid ":attr:`%U`"
msgstr ":attr:`%U`"

#: ../../c-api/unicode.rst:507
msgid "A unicode object."
msgstr "unicode オブジェクト。"

#: ../../c-api/unicode.rst:509
msgid ":attr:`%V`"
msgstr ":attr:`%V`"

#: ../../c-api/unicode.rst:509
msgid "PyObject\\*, char \\*"
msgstr "PyObject\\*, char \\*"

#: ../../c-api/unicode.rst:509
msgid ""
"A unicode object (which may be *NULL*) and a null-terminated C character "
"array as a second parameter (which will be used, if the first parameter is "
"*NULL*)."
msgstr ""
"unicode オブジェクト(*NULL* でも良い)と、 2つめの引数として NUL 終端の C 文字"
"列 (2つめの引数は1つめの引数が *NULL* だった時にのみ利用されます)。"

#: ../../c-api/unicode.rst:516
msgid ":attr:`%S`"
msgstr ":attr:`%S`"

#: ../../c-api/unicode.rst:516
msgid "The result of calling :c:func:`PyObject_Str`."
msgstr ":c:func:`PyObject_Str` の戻り値。"

#: ../../c-api/unicode.rst:519
msgid ":attr:`%R`"
msgstr ":attr:`%R`"

#: ../../c-api/unicode.rst:519
msgid "The result of calling :c:func:`PyObject_Repr`."
msgstr ":c:func:`PyObject_Repr` の戻り値。"

#: ../../c-api/unicode.rst:523
msgid ""
"An unrecognized format character causes all the rest of the format string to "
"be copied as-is to the result string, and any extra arguments discarded."
msgstr ""
"識別できない書式指定文字があった場合、残りの書式文字列はそのまま出力文字列に"
"コピーされ、残りの引数は無視されます。"

#: ../../c-api/unicode.rst:527
msgid ""
"The width formatter unit is number of characters rather than bytes. The "
"precision formatter unit is number of bytes for ``\"%s\"`` and ``\"%V\"`` "
"(if the ``PyObject*`` argument is NULL), and a number of characters for "
"``\"%A\"``, ``\"%U\"``, ``\"%S\"``, ``\"%R\"`` and ``\"%V\"`` (if the "
"``PyObject*`` argument is not NULL)."
msgstr ""
"幅フォーマッタの単位はバイト数ではなく文字数です。\n"
"精度フォーマッタの単位は、 ``\"%s\"`` と (``PyObject*`` 引数が NULL の場合"
"の) ``\"%V\"`` ではバイト数、 ``\"%A\"``, ``\"%U\"``, ``\"%S\"``, ``\"%R\"`` "
"および (``PyObject*`` 引数が NULL でない場合の) ``\"%V\"`` では文字数です。"

#: ../../c-api/unicode.rst:533
msgid "Support for ``\"%lld\"`` and ``\"%llu\"`` added."
msgstr "``\"%lld\"``, ``\"%llu\"`` のサポートが追加されました。"

#: ../../c-api/unicode.rst:536
msgid "Support for ``\"%li\"``, ``\"%lli\"`` and ``\"%zi\"`` added."
msgstr "``\"%li\"``, ``\"%lli\"``, ``\"%zi\"`` のサポートが追加されました。"

#: ../../c-api/unicode.rst:539
msgid ""
"Support width and precision formatter for ``\"%s\"``, ``\"%A\"``, "
"``\"%U\"``, ``\"%V\"``, ``\"%S\"``, ``\"%R\"`` added."
msgstr ""
"``\"%s\"``, ``\"%A\"``, ``\"%U\"``, ``\"%V\"``, ``\"%S\"``, ``\"%R\"`` での幅"
"フォーマッタおよび精度フォーマッタのサポートが追加されました。"

#: ../../c-api/unicode.rst:546
msgid ""
"Identical to :c:func:`PyUnicode_FromFormat` except that it takes exactly two "
"arguments."
msgstr ""
"ちょうど２つの引数を取ることを除いて、 :c:func:`PyUnicode_FromFormat` と同じ"
"です。"

#: ../../c-api/unicode.rst:553
msgid "Decode an encoded object *obj* to a Unicode object."
msgstr "エンコードされている *obj* を Unicode オブジェクトにデコードします。"

#: ../../c-api/unicode.rst:555
msgid ""
":class:`bytes`, :class:`bytearray` and other :term:`bytes-like objects "
"<bytes-like object>` are decoded according to the given *encoding* and using "
"the error handling defined by *errors*. Both can be *NULL* to have the "
"interface use the default values (see :ref:`builtincodecs` for details)."
msgstr ""
":class:`bytes` や :class:`bytearray` や他の :term:`bytes-like objects <bytes-"
"like object>` は、与えられた *encoding* に従ってデコードされ、 *errors* で定"
"義されたエラーハンドリングが使われます。\n"
"これらの引数は両方とも *NULL* にでき、その場合この API はデフォルト値を使いま"
"す (詳しことは :ref:`builtincodecs` を参照してください)。"

#: ../../c-api/unicode.rst:561
msgid ""
"All other objects, including Unicode objects, cause a :exc:`TypeError` to be "
"set."
msgstr ""
"その他のUnicodeオブジェクトを含むオブジェクトは :exc:`TypeError` 例外を引き起"
"こします。"

#: ../../c-api/unicode.rst:564
msgid ""
"The API returns *NULL* if there was an error.  The caller is responsible for "
"decref'ing the returned objects."
msgstr ""
"この API は、エラーが生じたときには *NULL* を返します。呼び出し側は返されたオ"
"ブジェクトに対し参照カウンタを 1 つ減らす (decref) する責任があります。"

#: ../../c-api/unicode.rst:570
msgid "Return the length of the Unicode object, in code points."
msgstr "Unicode オブジェクトの長さをコードポイントで返します。"

#: ../../c-api/unicode.rst:581
msgid ""
"Copy characters from one Unicode object into another.  This function "
"performs character conversion when necessary and falls back to :c:func:"
"`memcpy` if possible.  Returns ``-1`` and sets an exception on error, "
"otherwise returns the number of copied characters."
msgstr ""
"ある Unicode オブジェクトから他へ文字をコピーします。\n"
"この関数は必要なときに文字変換を行い、可能な場合は :c:func:`memcpy` へ差し戻"
"します。\n"
"失敗のときには ``-1`` を返し、例外を設定します。そうでない場合は、コピーした"
"文字数を返します。"

#: ../../c-api/unicode.rst:592
msgid ""
"Fill a string with a character: write *fill_char* into ``unicode[start:"
"start+length]``."
msgstr ""
"文字列を文字で埋めます: ``unicode[start:start+length]`` で *fill_char* を埋め"
"ることになります。"

#: ../../c-api/unicode.rst:595
msgid ""
"Fail if *fill_char* is bigger than the string maximum character, or if the "
"string has more than 1 reference."
msgstr ""
"*fill_char* が文字列の最大文字よりも大きい場合や、文字列2つ以上の参照を持って"
"た場合は失敗します。"

#: ../../c-api/unicode.rst:598
msgid ""
"Return the number of written character, or return ``-1`` and raise an "
"exception on error."
msgstr ""
"書き込んだ文字数を返すか、失敗のときには ``-1`` を返し例外を送出します。"

#: ../../c-api/unicode.rst:607
msgid ""
"Write a character to a string.  The string must have been created through :c:"
"func:`PyUnicode_New`.  Since Unicode strings are supposed to be immutable, "
"the string must not be shared, or have been hashed yet."
msgstr ""
"文字列に文字を書き込みます。\n"
"文字列は :c:func:`PyUnicode_New` で作成しなければなりません。\n"
"Unicode 文字列は不変とされているので、この文字列は共有されていたり、これまで"
"にハッシュ化されていてはいけません。"

#: ../../c-api/unicode.rst:611
msgid ""
"This function checks that *unicode* is a Unicode object, that the index is "
"not out of bounds, and that the object can be modified safely (i.e. that it "
"its reference count is one)."
msgstr ""
"この関数は *unicode* が Unicode オブジェクトであること、インデックスが範囲内"
"であること、オブジェクトが安全に変更できる (つまり参照カウントが1である) こと"
"をチェックします。"

#: ../../c-api/unicode.rst:620
msgid ""
"Read a character from a string.  This function checks that *unicode* is a "
"Unicode object and the index is not out of bounds, in contrast to the macro "
"version :c:func:`PyUnicode_READ_CHAR`."
msgstr ""
"文字列から文字を読み取ります。\n"
"マクロ版の :c:func:`PyUnicode_READ_CHAR` とは対照的に、この関数は *unicode* "
"が Unicode オブジェクトであること、インデックスが範囲内であることをチェックし"
"ます。"

#: ../../c-api/unicode.rst:630
msgid ""
"Return a substring of *str*, from character index *start* (included) to "
"character index *end* (excluded).  Negative indices are not supported."
msgstr ""
"*str* の文字インデックス *start* (端点を含む) から文字インデックス *end* (端"
"点を含まず) までの部分文字列を返します。\n"
"負のインデックスはサポートされていません。"

#: ../../c-api/unicode.rst:639
msgid ""
"Copy the string *u* into a UCS4 buffer, including a null character, if "
"*copy_null* is set.  Returns *NULL* and sets an exception on error (in "
"particular, a :exc:`SystemError` if *buflen* is smaller than the length of "
"*u*).  *buffer* is returned on success."
msgstr ""
"文字列 *u* を UCS4 のバッファへコピーします。\n"
"*copy_null* が設定されている場合は、ヌル文字も含めます。\n"
"エラーが起きたときは、 *NULL* を返し、例外を設定します (*buflen* が *u* の長"
"さより短かった場合については、 :exc:`SystemError` が設定されます)。\n"
"成功したときは  *buffer* を返します。"

#: ../../c-api/unicode.rst:649
msgid ""
"Copy the string *u* into a new UCS4 buffer that is allocated using :c:func:"
"`PyMem_Malloc`.  If this fails, *NULL* is returned with a :exc:`MemoryError` "
"set.  The returned buffer always has an extra null code point appended."
msgstr ""
"文字列 *u* を :c:func:`PyMem_Malloc` でメモリ確保された新しい UCS4 型のバッ"
"ファにコピーします。\n"
"これが失敗した場合は、 *NULL* を返し :exc:`MemoryError` をセットします。\n"
"返されたバッファは必ず null コードポイントが追加されています。"

#: ../../c-api/unicode.rst:658
msgid "Deprecated Py_UNICODE APIs"
msgstr "廃止予定の Py_UNICODE API群"

#: ../../c-api/unicode.rst:662
msgid ""
"These API functions are deprecated with the implementation of :pep:`393`. "
"Extension modules can continue using them, as they will not be removed in "
"Python 3.x, but need to be aware that their use can now cause performance "
"and memory hits."
msgstr ""
"これらのAPI 関数は :pep:`393` の実装により廃止予定です。Python 3.x では削除さ"
"れないため、拡張モジュールはこれらの関数を引き続き使えますが、これらの関数の"
"使用はパフォーマンスとメモリに影響があることを念頭に置いてください。"

#: ../../c-api/unicode.rst:669
msgid ""
"Create a Unicode object from the Py_UNICODE buffer *u* of the given size. "
"*u* may be *NULL* which causes the contents to be undefined. It is the "
"user's responsibility to fill in the needed data.  The buffer is copied into "
"the new object."
msgstr ""
"*size* で指定された長さを持つ Py_UNICODE 型バッファ *u* から Unicode オブジェ"
"クトを生成します。\n"
"*u* を *NULL* にしてもよく、その場合オブジェクトの内容は未定義です。\n"
"バッファに必要な情報を埋めるのはユーザの責任です。\n"
"バッファの内容は新たなオブジェクトにコピーされます。"

#: ../../c-api/unicode.rst:674
msgid ""
"If the buffer is not *NULL*, the return value might be a shared object. "
"Therefore, modification of the resulting Unicode object is only allowed when "
"*u* is *NULL*."
msgstr ""
"バッファが *NULL* でない場合、戻り値は共有されたオブジェクトになることがあり"
"ます。\n"
"従って、この関数が返す Unicode オブジェクトを変更してよいのは *u* が *NULL* "
"のときだけです。"

#: ../../c-api/unicode.rst:678
msgid ""
"If the buffer is *NULL*, :c:func:`PyUnicode_READY` must be called once the "
"string content has been filled before using any of the access macros such "
"as :c:func:`PyUnicode_KIND`."
msgstr ""
"バッファが *NULL* の場合、文字列の内容が埋められたなら :c:func:"
"`PyUnicode_KIND` のようなアクセスマクロを使う前に :c:func:`PyUnicode_READY` "
"を呼び出さなければなりません。"

#: ../../c-api/unicode.rst:682
msgid ""
"Please migrate to using :c:func:`PyUnicode_FromKindAndData`, :c:func:"
"`PyUnicode_FromWideChar` or :c:func:`PyUnicode_New`."
msgstr ""
":c:func:`PyUnicode_FromKindAndData`, :c:func:`PyUnicode_New`, :c:func:"
"`PyUnicode_FromWideChar` のいずれかを使用するように移行してください。"

#: ../../c-api/unicode.rst:688
msgid ""
"Return a read-only pointer to the Unicode object's internal :c:type:"
"`Py_UNICODE` buffer, or *NULL* on error. This will create the :c:type:"
"`Py_UNICODE*` representation of the object if it is not yet available. The "
"buffer is always terminated with an extra null code point. Note that the "
"resulting :c:type:`Py_UNICODE` string may also contain embedded null code "
"points, which would cause the string to be truncated when used in most C "
"functions."
msgstr ""
"Unicode オブジェクトの :c:type:`Py_UNICODE` 型の内部バッファへの読み出し専用"
"のポインタを返すか、失敗のときには *NULL* を返します。\n"
"オブジェクトの :c:type:`Py_UNICODE*` 表現形式が無い場合には作成します。\n"
"結果の :c:type:`Py_UNICODE` 文字列には null コードポイントが含まれていること"
"があり、たいていの C 関数では、そのような文字列は切り詰められてしまうことに注"
"意してください。"

#: ../../c-api/unicode.rst:696
msgid ""
"Please migrate to using :c:func:`PyUnicode_AsUCS4`, :c:func:"
"`PyUnicode_AsWideChar`, :c:func:`PyUnicode_ReadChar` or similar new APIs."
msgstr ""
":c:func:`PyUnicode_AsUCS4`, :c:func:`PyUnicode_AsWideChar`, :c:func:"
"`PyUnicode_ReadChar` や類似の新しい API を使用するように移行してください。"

#: ../../c-api/unicode.rst:703
msgid ""
"Create a Unicode object by replacing all decimal digits in :c:type:"
"`Py_UNICODE` buffer of the given *size* by ASCII digits 0--9 according to "
"their decimal value.  Return *NULL* if an exception occurs."
msgstr ""
"与えられた長さ *size* を持つ :c:type:`Py_UNICODE` 型のバッファにある全ての "
"decimal digit を、それらの10進の値に対応する 0 から 9 までの ASCII 数字に置き"
"換えた Unicode オブジェクトを生成します。\n"
"例外が起きた場合は *NULL* を返します。"

#: ../../c-api/unicode.rst:710
msgid ""
"Like :c:func:`PyUnicode_AsUnicode`, but also saves the :c:func:`Py_UNICODE` "
"array length (excluding the extra null terminator) in *size*. Note that the "
"resulting :c:type:`Py_UNICODE*` string may contain embedded null code "
"points, which would cause the string to be truncated when used in most C "
"functions."
msgstr ""
":c:func:`PyUnicode_AsUnicode` に似てますが、さらに (追加の null 終端子を除い"
"た) :c:func:`Py_UNICODE` 配列の長さを *size* に保存します。\n"
"結果の :c:type:`Py_UNICODE` 文字列には null コードポイントが含まれていること"
"があり、たいていの C 関数では、そのような文字列は切り詰められてしまうことに注"
"意してください。"

#: ../../c-api/unicode.rst:721
msgid ""
"Create a copy of a Unicode string ending with a null code point. Return "
"*NULL* and raise a :exc:`MemoryError` exception on memory allocation "
"failure, otherwise return a new allocated buffer (use :c:func:`PyMem_Free` "
"to free the buffer). Note that the resulting :c:type:`Py_UNICODE*` string "
"may contain embedded null code points, which would cause the string to be "
"truncated when used in most C functions."
msgstr ""
"終端に null コードポイントが付加された Unicode 文字列のコピーを作成します。\n"
"メモリ確保に失敗したときは *NULL* を返し :exc:`MemoryError` 例外を送出しま"
"す。\n"
"そうでないときは新しくメモリ確保されたバッファを返します (このバッファを解放"
"するときには :c:func:`PyMem_Free` を使ってください)。\n"
"結果の :c:type:`Py_UNICODE` 文字列には null コードポイントが含まれていること"
"があり、たいていの C 関数では、そのような文字列は切り詰められてしまうことに注"
"意してください。"

#: ../../c-api/unicode.rst:730
msgid ""
"Please migrate to using :c:func:`PyUnicode_AsUCS4Copy` or similar new APIs."
msgstr ""
":c:func:`PyUnicode_AsUCS4Copy` や類似の新しい API を使用するように移行してく"
"ださい。"

#: ../../c-api/unicode.rst:735
msgid ""
"Return the size of the deprecated :c:type:`Py_UNICODE` representation, in "
"code units (this includes surrogate pairs as 2 units)."
msgstr ""
"非推奨の :c:type:`Py_UNICODE` 表現形式のサイズをコード単位で返します (サロ"
"ゲートペアを2つとしています)。"

#: ../../c-api/unicode.rst:738
msgid "Please migrate to using :c:func:`PyUnicode_GetLength`."
msgstr ":c:func:`PyUnicode_GetLength` を使用するように移行してください。"

#: ../../c-api/unicode.rst:743
msgid ""
"Copy an instance of a Unicode subtype to a new true Unicode object if "
"necessary. If *obj* is already a true Unicode object (not a subtype), return "
"the reference with incremented refcount."
msgstr ""
"Unicode のサブタイプのインスタンスを、必要な場合は本物の Unicode オブジェクト"
"にコピーします。\n"
"*obj* が (サブタイプではない) 既に本物の Unicode オブジェクトだった場合は、参"
"照カウントを1つ増やした参照を返します。"

#: ../../c-api/unicode.rst:747
msgid ""
"Objects other than Unicode or its subtypes will cause a :exc:`TypeError`."
msgstr ""
"Unicode やそのサブタイプ以外のオブジェクトでは :exc:`TypeError` が引き起こさ"
"れます。"

#: ../../c-api/unicode.rst:751
msgid "Locale Encoding"
msgstr "ロケールエンコーディング"

#: ../../c-api/unicode.rst:753
msgid ""
"The current locale encoding can be used to decode text from the operating "
"system."
msgstr ""
"現在のロケールエンコーディングはオペレーティングシステムのテキストをデコード"
"するのに使えます。"

#: ../../c-api/unicode.rst:760
msgid ""
"Decode a string from the current locale encoding. The supported error "
"handlers are ``\"strict\"`` and ``\"surrogateescape\"`` (:pep:`383`). The "
"decoder uses ``\"strict\"`` error handler if *errors* is ``NULL``.  *str* "
"must end with a null character but cannot contain embedded null characters."
msgstr ""
"現在のロケールエンコーディングの文字列をデコードします。\n"
"サポートされているエラーハンドラは ``\"strict\"`` および "
"``\"surrogateescape\"`` (:pep:`383`) です。\n"
"*errors* が ``NULL`` の場合は、デコーダは ``\"strict\"`` エラーハンドラを使用"
"します。\n"
"*str* は終端が null 文字でなければならず、 null 文字を含めることはできませ"
"ん。"

#: ../../c-api/unicode.rst:766
msgid ""
"Use :c:func:`PyUnicode_DecodeFSDefaultAndSize` to decode a string from :c:"
"data:`Py_FileSystemDefaultEncoding` (the locale encoding read at Python "
"startup)."
msgstr ""
":c:func:`PyUnicode_DecodeFSDefaultAndSize` を使って (Python の起動時に読み込"
"まれるロケールエンコーディングの) :c:data:`Py_FileSystemDefaultEncoding` の文"
"字列をデコードします。"

#: ../../c-api/unicode.rst:772 ../../c-api/unicode.rst:872
msgid "The :c:func:`Py_DecodeLocale` function."
msgstr ":c:func:`Py_DecodeLocale` 関数。"

#: ../../c-api/unicode.rst:776
msgid ""
"The function now also uses the current locale encoding for the "
"``surrogateescape`` error handler. Previously, :c:func:`Py_DecodeLocale` was "
"used for the ``surrogateescape``, and the current locale encoding was used "
"for ``strict``."
msgstr ""

#: ../../c-api/unicode.rst:785
msgid ""
"Similar to :c:func:`PyUnicode_DecodeLocaleAndSize`, but compute the string "
"length using :c:func:`strlen`."
msgstr ""
":c:func:`PyUnicode_DecodeLocaleAndSize` と似てますが、 :c:func:`strlen` を"
"使って文字列の長さを計算します。"

#: ../../c-api/unicode.rst:793
msgid ""
"Encode a Unicode object to the current locale encoding. The supported error "
"handlers are ``\"strict\"`` and ``\"surrogateescape\"`` (:pep:`383`). The "
"encoder uses ``\"strict\"`` error handler if *errors* is ``NULL``. Return a :"
"class:`bytes` object. *unicode* cannot contain embedded null characters."
msgstr ""
"Unicode オブジェクトを現在のロケールエンコーディングでエンコードします。\n"
"サポートされているエラーハンドラは ``\"strict\"`` および "
"``\"surrogateescape\"`` (:pep:`383`) です。\n"
"*errors* が ``NULL`` の場合は、エンコーダは ``\"strict\"`` エラーハンドラを使"
"用します。\n"
":class:`bytes` オブジェクトを返します。\n"
"*unicode* には null 文字を含められません。"

#: ../../c-api/unicode.rst:799
msgid ""
"Use :c:func:`PyUnicode_EncodeFSDefault` to encode a string to :c:data:"
"`Py_FileSystemDefaultEncoding` (the locale encoding read at Python startup)."
msgstr ""
":c:func:`PyUnicode_EncodeFSDefault` を使って (Python の起動時に読み込まれるロ"
"ケールエンコーディングの) :c:data:`Py_FileSystemDefaultEncoding` の文字列へエ"
"ンコードします。"

#: ../../c-api/unicode.rst:805 ../../c-api/unicode.rst:908
msgid "The :c:func:`Py_EncodeLocale` function."
msgstr ":c:func:`Py_EncodeLocale` 関数。"

#: ../../c-api/unicode.rst:809
msgid ""
"The function now also uses the current locale encoding for the "
"``surrogateescape`` error handler. Previously, :c:func:`Py_EncodeLocale` was "
"used for the ``surrogateescape``, and the current locale encoding was used "
"for ``strict``."
msgstr ""

#: ../../c-api/unicode.rst:817
msgid "File System Encoding"
msgstr "ファイルシステムエンコーディング"

#: ../../c-api/unicode.rst:819
msgid ""
"To encode and decode file names and other environment strings, :c:data:"
"`Py_FileSystemDefaultEncoding` should be used as the encoding, and :c:data:"
"`Py_FileSystemDefaultEncodeErrors` should be used as the error handler (:pep:"
"`383` and :pep:`529`). To encode file names to :class:`bytes` during "
"argument parsing, the ``\"O&\"`` converter should be used, passing :c:func:"
"`PyUnicode_FSConverter` as the conversion function:"
msgstr ""
"ファイル名や他の環境文字列のエンコードやデコードを行うには、 :c:data:"
"`Py_FileSystemDefaultEncoding` をエンコーディングとして使い、 :c:data:"
"`Py_FileSystemDefaultEncodeErrors` をエラーハンドラとして使うべきです (:pep:"
"`383` および :pep:`529`)。\n"
"引数の構文解析中にファイル名を :class:`bytes` にエンコードするには、 "
"``\"O&\"`` コンバーターを使い、 :c:func:`PyUnicode_FSConverter` を変換関数と"
"して渡すべきです:"

#: ../../c-api/unicode.rst:828
msgid ""
"ParseTuple converter: encode :class:`str` objects -- obtained directly or "
"through the :class:`os.PathLike` interface -- to :class:`bytes` using :c:"
"func:`PyUnicode_EncodeFSDefault`; :class:`bytes` objects are output as-is. "
"*result* must be a :c:type:`PyBytesObject*` which must be released when it "
"is no longer used."
msgstr ""
"ParseTuple コンバーター: :c:func:`PyUnicode_EncodeFSDefault` を使い -- 直接あ"
"るいは :class:`os.PathLike`  インターフェースを通して取得した -- :class:"
"`str` オブジェクトを :class:`bytes` へエンコードします;\n"
":class:`bytes` オブジェクトはそのまま出力されます。\n"
"*result* は :c:type:`PyBytesObject*` でなければならず、使われなくなったときに"
"は解放されなければなりません。"

#: ../../c-api/unicode.rst:836 ../../c-api/unicode.rst:853
msgid "Accepts a :term:`path-like object`."
msgstr ":term:`path-like object` を受け入れるようになりました。"

#: ../../c-api/unicode.rst:839
msgid ""
"To decode file names to :class:`str` during argument parsing, the ``\"O&\"`` "
"converter should be used, passing :c:func:`PyUnicode_FSDecoder` as the "
"conversion function:"
msgstr ""
"引数の構文解析中にファイル名を :class:`str` にデコードするには、 ``\"O&\"`` "
"コンバーターを使い、 :c:func:`PyUnicode_FSDecoder` を変換関数として渡すのがよ"
"いです:"

#: ../../c-api/unicode.rst:845
msgid ""
"ParseTuple converter: decode :class:`bytes` objects -- obtained either "
"directly or indirectly through the :class:`os.PathLike` interface -- to :"
"class:`str` using :c:func:`PyUnicode_DecodeFSDefaultAndSize`; :class:`str` "
"objects are output as-is. *result* must be a :c:type:`PyUnicodeObject*` "
"which must be released when it is no longer used."
msgstr ""
"ParseTuple コンバーター: :c:func:`PyUnicode_DecodeFSDefaultAndSize` を使い "
"-- 直接的あるいは間接的に :class:`os.PathLike` インターフェースを通して取得し"
"た -- :class:`bytes` オブジェクトを :class:`str` へエンコードします;\n"
":class:`bytes` オブジェクトはそのまま出力されます。\n"
"*result* は :c:type:`PyUnicodeObject*` でなければならず、使われなくなったとき"
"には解放されなければなりません。"

#: ../../c-api/unicode.rst:859
msgid ""
"Decode a string using :c:data:`Py_FileSystemDefaultEncoding` and the :c:data:"
"`Py_FileSystemDefaultEncodeErrors` error handler."
msgstr ""
":c:data:`Py_FileSystemDefaultEncoding` と :c:data:"
"`Py_FileSystemDefaultEncodeErrors` エラーハンドラを使い、文字列をデコードしま"
"す。"

#: ../../c-api/unicode.rst:862 ../../c-api/unicode.rst:883
#: ../../c-api/unicode.rst:899
msgid ""
"If :c:data:`Py_FileSystemDefaultEncoding` is not set, fall back to the "
"locale encoding."
msgstr ""
":c:data:`Py_FileSystemDefaultEncoding` が設定されていない場合は、ロケールエン"
"コーディングに差し戻されます。"

#: ../../c-api/unicode.rst:865
msgid ""
":c:data:`Py_FileSystemDefaultEncoding` is initialized at startup from the "
"locale encoding and cannot be modified later. If you need to decode a string "
"from the current locale encoding, use :c:func:"
"`PyUnicode_DecodeLocaleAndSize`."
msgstr ""
":c:data:`Py_FileSystemDefaultEncoding` は起動時にロケールエンコーディングで初"
"期化され、それ以降は変更できません。\n"
"現在のロケールエンコーディングで文字列をデコードする必要がある場合は、 :c:"
"func:`PyUnicode_DecodeLocaleAndSize` を使ってください。"

#: ../../c-api/unicode.rst:874 ../../c-api/unicode.rst:888
#: ../../c-api/unicode.rst:912
msgid "Use :c:data:`Py_FileSystemDefaultEncodeErrors` error handler."
msgstr ""
":c:data:`Py_FileSystemDefaultEncodeErrors` エラーハンドラを使うようになりまし"
"た。"

#: ../../c-api/unicode.rst:880
msgid ""
"Decode a null-terminated string using :c:data:`Py_FileSystemDefaultEncoding` "
"and the :c:data:`Py_FileSystemDefaultEncodeErrors` error handler."
msgstr ""
":c:data:`Py_FileSystemDefaultEncoding` と :c:data:"
"`Py_FileSystemDefaultEncodeErrors` エラーハンドラを使い、 null 終端文字列をデ"
"コードします。"

#: ../../c-api/unicode.rst:886
msgid ""
"Use :c:func:`PyUnicode_DecodeFSDefaultAndSize` if you know the string length."
msgstr ""
"文字列の長さが分かっている場合は、 :c:func:"
"`PyUnicode_DecodeFSDefaultAndSize` を使ってください。"

#: ../../c-api/unicode.rst:894
msgid ""
"Encode a Unicode object to :c:data:`Py_FileSystemDefaultEncoding` with the :"
"c:data:`Py_FileSystemDefaultEncodeErrors` error handler, and return :class:"
"`bytes`. Note that the resulting :class:`bytes` object may contain null "
"bytes."
msgstr ""
":c:data:`Py_FileSystemDefaultEncoding` エラーハンドラで Unicode オブジェクト"
"を :c:data:`Py_FileSystemDefaultEncoding` にエンコードし、 :class:`bytes` を"
"返します。\n"
"返される :class:`bytes` オブジェクトは null バイトを含んでいるかもしれないこ"
"とに注意してください。"

#: ../../c-api/unicode.rst:902
msgid ""
":c:data:`Py_FileSystemDefaultEncoding` is initialized at startup from the "
"locale encoding and cannot be modified later. If you need to encode a string "
"to the current locale encoding, use :c:func:`PyUnicode_EncodeLocale`."
msgstr ""
":c:data:`Py_FileSystemDefaultEncoding` は起動時にロケールエンコーディングで初"
"期化され、それ以降は変更できません。\n"
"現在のロケールエンコーディングで文字列をエンコードする必要がある場合は、 :c:"
"func:`PyUnicode_EncodeLocale` を使ってください。"

#: ../../c-api/unicode.rst:916
msgid "wchar_t Support"
msgstr "wchar_t サポート"

#: ../../c-api/unicode.rst:918
msgid ":c:type:`wchar_t` support for platforms which support it:"
msgstr ":c:type:`wchar_t` をサポートするプラットフォームでの wchar_t サポート:"

#: ../../c-api/unicode.rst:922
msgid ""
"Create a Unicode object from the :c:type:`wchar_t` buffer *w* of the given "
"*size*. Passing ``-1`` as the *size* indicates that the function must itself "
"compute the length, using wcslen. Return *NULL* on failure."
msgstr ""
"*size* の :c:type:`wchar_t` バッファ *w* から Unicode オブジェクトを生成しま"
"す。\n"
"*size* として ``-1`` を渡すことで、 wcslen を使い自身で長さを計算しなければな"
"らないことを関数に指示します。\n"
"失敗すると *NULL* を返します。"

#: ../../c-api/unicode.rst:930
msgid ""
"Copy the Unicode object contents into the :c:type:`wchar_t` buffer *w*.  At "
"most *size* :c:type:`wchar_t` characters are copied (excluding a possibly "
"trailing null termination character).  Return the number of :c:type:"
"`wchar_t` characters copied or ``-1`` in case of an error.  Note that the "
"resulting :c:type:`wchar_t*` string may or may not be null-terminated.  It "
"is the responsibility of the caller to make sure that the :c:type:`wchar_t*` "
"string is null-terminated in case this is required by the application. Also, "
"note that the :c:type:`wchar_t*` string might contain null characters, which "
"would cause the string to be truncated when used with most C functions."
msgstr ""
"Unicode オブジェクトの内容を :c:type:`wchar_t` バッファ *w* にコピーしま"
"す。\n"
"最大で *size* 個の :c:type:`wchar_t` 文字を (末尾の null 終端文字を除いて) コ"
"ピーします。\n"
"コピーした :c:type:`wchar_t` 文字の個数を返します。エラーの時には -1 を返しま"
"す。 :c:type:`wchar_t` 文字列は null 終端されている場合も、されていない場合も"
"あります。\n"
"関数の呼び出し側の責任で、アプリケーションの必要に応じて :c:type:`wchar_t` 文"
"字列を null 終端してください。\n"
"また、結果の :c:type:`wchar_t*` 文字列には文字列の途中にも null 文字が含まれ"
"ていることがあり、たいていの C 関数では、そのような文字列は切り詰められてしま"
"うことに注意してください。"

#: ../../c-api/unicode.rst:943
msgid ""
"Convert the Unicode object to a wide character string. The output string "
"always ends with a null character. If *size* is not *NULL*, write the number "
"of wide characters (excluding the trailing null termination character) into "
"*\\*size*."
msgstr ""
"Unicode オブジェクトをワイドキャラクター文字列に変換します。\n"
"出力される文字列は常に終端が null 文字です。\n"
"*size* が *NULL* でない場合は、 (末尾にある null 終端文字を除いた) ワイドキャ"
"ラクター文字の個数を書き込みます。"

#: ../../c-api/unicode.rst:948
msgid ""
"Returns a buffer allocated by :c:func:`PyMem_Alloc` (use :c:func:"
"`PyMem_Free` to free it) on success. On error, returns *NULL*, *\\*size* is "
"undefined and raises a :exc:`MemoryError`. Note that the resulting :c:type:"
"`wchar_t` string might contain null characters, which would cause the string "
"to be truncated when used with most C functions."
msgstr ""
"成功のときは :c:func:`PyMem_Alloc` でメモリ確保されたバッファ (解放するには :"
"c:func:`PyMem_Free` を使います) を返します。\n"
"失敗のときは *NULL* を返し、 *\\*size* は未定義となり、 :exc:`MemoryError` を"
"送出します。\n"
"結果の :c:type:`wchar_t` 文字列には null 文字が含まれていることがあり、たいて"
"いの C 関数では、そのような文字列は切り詰められてしまうことに注意してくださ"
"い。"

#: ../../c-api/unicode.rst:960
msgid "Built-in Codecs"
msgstr "組み込み codec (built-in codec)"

#: ../../c-api/unicode.rst:962
msgid ""
"Python provides a set of built-in codecs which are written in C for speed. "
"All of these codecs are directly usable via the following functions."
msgstr ""
"Python には、処理速度を高めるために C で書かれた codec が揃えてあります。これ"
"ら全ての codec は以下の関数を介して直接利用できます。"

#: ../../c-api/unicode.rst:965
msgid ""
"Many of the following APIs take two arguments encoding and errors, and they "
"have the same semantics as the ones of the built-in :func:`str` string "
"object constructor."
msgstr ""
"以下の API の多くが、 *encoding* と *errors* という二つの引数をとります。これ"
"らのパラメータは、組み込みの文字列コンストラクタである :func:`str` における同"
"名のパラメータと同じ意味を持ちます。"

#: ../../c-api/unicode.rst:969
msgid ""
"Setting encoding to *NULL* causes the default encoding to be used which is "
"ASCII.  The file system calls should use :c:func:`PyUnicode_FSConverter` for "
"encoding file names. This uses the variable :c:data:"
"`Py_FileSystemDefaultEncoding` internally. This variable should be treated "
"as read-only: on some systems, it will be a pointer to a static string, on "
"others, it will change at run-time (such as when the application invokes "
"setlocale)."
msgstr ""
"*encoding* を *NULL* にすると、デフォルトエンコーディングである ASCII を使い"
"ます。\n"
"ファイルシステムに関する関数の呼び出しでは、ファイル名に対するエンコーディン"
"グとして :c:func:`PyUnicode_FSConverter` を使わねばなりません。\n"
"これは内部で変数 :c:data:`Py_FileSystemDefaultEncoding` を使用しています。\n"
"この変数は読み出し専用の変数として扱わねばなりません: この変数は、あるシステ"
"ムによっては静的な文字列に対するポインタであったり、また別のシステムでは、(ア"
"プリケーションが setlocale を呼んだときなどに) 変わったりもします。"

#: ../../c-api/unicode.rst:977
msgid ""
"Error handling is set by errors which may also be set to *NULL* meaning to "
"use the default handling defined for the codec.  Default error handling for "
"all built-in codecs is \"strict\" (:exc:`ValueError` is raised)."
msgstr ""
"*errors* で指定するエラー処理もまた、 *NULL* を指定できます。 *NULL* を指定す"
"ると、codec で定義されているデフォルト処理の使用を意味します。全ての組み込み "
"codec で、デフォルトのエラー処理は \"strict\" (:exc:`ValueError` を送出する) "
"になっています。"

#: ../../c-api/unicode.rst:981
msgid ""
"The codecs all use a similar interface.  Only deviation from the following "
"generic ones are documented for simplicity."
msgstr ""
"個々の codec は全て同様のインタフェースを使っています。個別の codec の説明で"
"は、説明を簡単にするために以下の汎用のインタフェースとの違いだけを説明してい"
"ます。"

#: ../../c-api/unicode.rst:986
msgid "Generic Codecs"
msgstr "汎用 codec"

#: ../../c-api/unicode.rst:988
msgid "These are the generic codec APIs:"
msgstr "以下は汎用 codec の API です:"

#: ../../c-api/unicode.rst:994
msgid ""
"Create a Unicode object by decoding *size* bytes of the encoded string *s*. "
"*encoding* and *errors* have the same meaning as the parameters of the same "
"name in the :func:`str` built-in function.  The codec to be used is looked "
"up using the Python codec registry.  Return *NULL* if an exception was "
"raised by the codec."
msgstr ""
"*size* バイトのエンコードされた文字列 *s* をデコードして Unicode オブジェクト"
"を生成します。\n"
"*encoding* と *errors* は、組み込み関数 :func:`str` の同名のパラメータと同じ"
"意味を持ちます。\n"
"使用する codec の検索は、 Python の codec レジストリを使って行います。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1004
msgid ""
"Encode a Unicode object and return the result as Python bytes object. "
"*encoding* and *errors* have the same meaning as the parameters of the same "
"name in the Unicode :meth:`~str.encode` method. The codec to be used is "
"looked up using the Python codec registry. Return *NULL* if an exception was "
"raised by the codec."
msgstr ""
"Unicode オブジェクトをエンコードし、その結果を Python の bytes オブジェクトと"
"して返します。\n"
"*encoding* および *errors* は Unicode 型の :meth:`~str.encode` メソッドに与え"
"る同名のパラメータと同じ意味を持ちます。\n"
"使用する codec の検索は、 Python の codec レジストリを使って行います。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1014
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer *s* of the given *size* and return a "
"Python bytes object.  *encoding* and *errors* have the same meaning as the "
"parameters of the same name in the Unicode :meth:`~str.encode` method.  The "
"codec to be used is looked up using the Python codec registry.  Return "
"*NULL* if an exception was raised by the codec."
msgstr ""
"*size* で指定されたサイズの :c:type:`Py_UNICODE` バッファ *s* をエンコードし"
"た Python の bytes オブジェクトを返します。\n"
"*encoding* および *errors* は Unicode 型の :meth:`~str.encode` メソッドに与え"
"る同名のパラメータと同じ意味を持ちます。\n"
"使用する codec の検索は、 Python の codec レジストリを使って行います。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1022 ../../c-api/unicode.rst:1273
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsEncodedString` を使用するように移行してください。"

#: ../../c-api/unicode.rst:1026
msgid "UTF-8 Codecs"
msgstr "UTF-8 Codecs"

#: ../../c-api/unicode.rst:1028
msgid "These are the UTF-8 codec APIs:"
msgstr "以下は UTF-8 codec の APIです:"

#: ../../c-api/unicode.rst:1033
msgid ""
"Create a Unicode object by decoding *size* bytes of the UTF-8 encoded string "
"*s*. Return *NULL* if an exception was raised by the codec."
msgstr ""
"UTF-8 でエンコードされた *size* バイトの文字列 *s* から Unicode オブジェクト"
"を生成します。codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1040
msgid ""
"If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeUTF8`. If "
"*consumed* is not *NULL*, trailing incomplete UTF-8 byte sequences will not "
"be treated as an error. Those bytes will not be decoded and the number of "
"bytes that have been decoded will be stored in *consumed*."
msgstr ""
"*consumed* が *NULL* の場合、 :c:func:`PyUnicode_DecodeUTF8` と同じように動作"
"します。 *consumed* が *NULL* でない場合、 :c:func:"
"`PyUnicode_DecodeUTF8Stateful` は末尾の不完全な UTF-8 バイト列をエラーとみな"
"しません。これらのバイト列はデコードされず、デコードされたバイト数を "
"*consumed* に返します。"

#: ../../c-api/unicode.rst:1048
msgid ""
"Encode a Unicode object using UTF-8 and return the result as Python bytes "
"object.  Error handling is \"strict\".  Return *NULL* if an exception was "
"raised by the codec."
msgstr ""
"UTF-8 で Unicode オブジェクトをエンコードし、結果を Python バイト列オブジェク"
"トとして返します。エラー処理は \"strict\" です。 codec が例外を送出した場合に"
"は *NULL* を返します。"

#: ../../c-api/unicode.rst:1055
msgid ""
"Return a pointer to the UTF-8 encoding of the Unicode object, and store the "
"size of the encoded representation (in bytes) in *size*.  The *size* "
"argument can be *NULL*; in this case no size will be stored.  The returned "
"buffer always has an extra null byte appended (not included in *size*), "
"regardless of whether there are any other null code points."
msgstr ""
"Unicode オブジェクトを UTF-8 でエンコードしたものへのポインタを返し、エンコー"
"ドされた表現形式でのサイズ (バイト単位) を *size* に格納します。\n"
"*size* 引数は *NULL* でも構いません; その場合はサイズは格納されません。\n"
"返されるバッファには、 null コードポイントがあるかどうかに関わらず、常に "
"null バイトが終端に付加されています (これは *size* には勘定されません)。"

#: ../../c-api/unicode.rst:1061
msgid ""
"In the case of an error, *NULL* is returned with an exception set and no "
"*size* is stored."
msgstr ""
"エラーが起きた場合は、 *NULL* を返し、例外を設定し、 *size* には何も格納しま"
"せん。"

#: ../../c-api/unicode.rst:1064
msgid ""
"This caches the UTF-8 representation of the string in the Unicode object, "
"and subsequent calls will return a pointer to the same buffer.  The caller "
"is not responsible for deallocating the buffer."
msgstr ""
"この関数は、 Unicode オブジェクトの文字列の UTF-8 表現形式をキャッシュし、そ"
"れ以降の呼び出しでは同じバッファへのポインタを返します。\n"
"呼び出し側にバッファを解放する責任はありません。"

#: ../../c-api/unicode.rst:1073
msgid "As :c:func:`PyUnicode_AsUTF8AndSize`, but does not store the size."
msgstr ""
":c:func:`PyUnicode_AsUTF8AndSize` とほぼ同じですが、サイズを格納しません。"

#: ../../c-api/unicode.rst:1080
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer *s* of the given *size* using UTF-8 "
"and return a Python bytes object.  Return *NULL* if an exception was raised "
"by the codec."
msgstr ""
"与えられたサイズの :c:type:`Py_UNICODE` バッファ *s* を UTF-8 でエンコードし"
"て、 Python の bytes オブジェクトとして返します。\n"
"codec が例外を発生させたときは *NULL* を返します。"

#: ../../c-api/unicode.rst:1087
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsUTF8String`, :c:func:`PyUnicode_AsUTF8AndSize` or :c:func:"
"`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsUTF8String`, :c:func:`PyUnicode_AsUTF8AndSize`, :c:func:"
"`PyUnicode_AsEncodedString` のいずれかを使用するように移行してください。"

#: ../../c-api/unicode.rst:1091
msgid "UTF-32 Codecs"
msgstr "UTF-32 Codecs"

#: ../../c-api/unicode.rst:1093
msgid "These are the UTF-32 codec APIs:"
msgstr "以下は UTF-32 codec API です:"

#: ../../c-api/unicode.rst:1099
msgid ""
"Decode *size* bytes from a UTF-32 encoded buffer string and return the "
"corresponding Unicode object.  *errors* (if non-*NULL*) defines the error "
"handling. It defaults to \"strict\"."
msgstr ""
"UTF-32 でエンコードされたバッファ文字列から *size* バイトをデコードし、 "
"Unicodeオブジェクトとして返します。 *errors* は (*NULL* でないなら) エラーハ"
"ンドラを指定します。デフォルトは \"strict\" です。"

#: ../../c-api/unicode.rst:1103 ../../c-api/unicode.rst:1176
msgid ""
"If *byteorder* is non-*NULL*, the decoder starts decoding using the given "
"byte order::"
msgstr ""
"*byteorder* が *NULL* でない時、デコーダは与えられたバイトオーダーでデコード"
"を開始します。 ::"

#: ../../c-api/unicode.rst:1110
msgid ""
"If ``*byteorder`` is zero, and the first four bytes of the input data are a "
"byte order mark (BOM), the decoder switches to this byte order and the BOM "
"is not copied into the resulting Unicode string.  If ``*byteorder`` is "
"``-1`` or ``1``, any byte order mark is copied to the output."
msgstr ""
"``*byteorder`` が 0 で、入力データの最初の 4 バイトが byte order mark (BOM) "
"ならば、デコーダはこのバイトオーダーに切り替え、BOM は結果の Unicode 文字列に"
"コピーされません。 ``*byteorder`` が ``-1`` または ``1`` ならば、全ての byte "
"order mark は出力にコピーされます。"

#: ../../c-api/unicode.rst:1115 ../../c-api/unicode.rst:1189
msgid ""
"After completion, *\\*byteorder* is set to the current byte order at the end "
"of input data."
msgstr ""
"デコードが完了した後、入力データの終端に来た時点でのバイトオーダーを "
"*\\*byteorder* にセットします。"

#: ../../c-api/unicode.rst:1118 ../../c-api/unicode.rst:1192
msgid "If *byteorder* is *NULL*, the codec starts in native order mode."
msgstr ""
"*byteorder* が *NULL* のとき、 codec は native order モードで開始します。"

#: ../../c-api/unicode.rst:1120 ../../c-api/unicode.rst:1156
#: ../../c-api/unicode.rst:1194 ../../c-api/unicode.rst:1231
msgid "Return *NULL* if an exception was raised by the codec."
msgstr "codec が例外を発生させたときは *NULL* を返します。"

#: ../../c-api/unicode.rst:1126
msgid ""
"If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeUTF32`. If "
"*consumed* is not *NULL*, :c:func:`PyUnicode_DecodeUTF32Stateful` will not "
"treat trailing incomplete UTF-32 byte sequences (such as a number of bytes "
"not divisible by four) as an error. Those bytes will not be decoded and the "
"number of bytes that have been decoded will be stored in *consumed*."
msgstr ""
"*consumed* が *NULL* のとき、 :c:func:`PyUnicode_DecodeUTF32` と同じように振"
"る舞います。 *consumed* が *NULL* でないとき、 :c:func:"
"`PyUnicode_DecodeUTF32Stateful` は末尾の不完全な (4 で割り切れない長さのバイ"
"ト列などの) UTF-32 バイト列をエラーとして扱いません。末尾の不完全なバイト列は"
"デコードされず、デコードされたバイト数が *consumed* に格納されます。"

#: ../../c-api/unicode.rst:1135
msgid ""
"Return a Python byte string using the UTF-32 encoding in native byte order. "
"The string always starts with a BOM mark.  Error handling is \"strict\". "
"Return *NULL* if an exception was raised by the codec."
msgstr ""
"ネイティブバイトオーダーで UTF-32 エンコーディングされた Python バイト文字列"
"を返します。\n"
"文字列は常に BOM マークで始まります。\n"
"エラーハンドラは \"strict\" です。\n"
"codec が例外を発生させたときは *NULL* を返します。"

#: ../../c-api/unicode.rst:1143
msgid ""
"Return a Python bytes object holding the UTF-32 encoded value of the Unicode "
"data in *s*.  Output is written according to the following byte order::"
msgstr ""
"*s* の Unicode データを UTF-32 にエンコードし、その値を Python の bytes オブ"
"ジェクトに格納して返します。\n"
"出力は以下のバイトオーダーで従って書かれます::"

#: ../../c-api/unicode.rst:1150 ../../c-api/unicode.rst:1224
msgid ""
"If byteorder is ``0``, the output string will always start with the Unicode "
"BOM mark (U+FEFF). In the other two modes, no BOM mark is prepended."
msgstr ""
"byteorder が ``0`` のとき、出力文字列は常に Unicode BOM マーク (U+FEFF) で始"
"まります。それ以外の2つのモードでは、先頭に BOM マークは出力されません。"

#: ../../c-api/unicode.rst:1153
msgid ""
"If *Py_UNICODE_WIDE* is not defined, surrogate pairs will be output as a "
"single code point."
msgstr ""
"*Py_UNICODE_WIDE* が定義されていない場合は、サロゲートペアを 1 つのコードポイ"
"ントとして出力します。"

#: ../../c-api/unicode.rst:1160
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsUTF32String` or :c:func:`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsUTF32String` または :c:func:`PyUnicode_AsEncodedString` を使用す"
"るように移行してください。"

#: ../../c-api/unicode.rst:1164
msgid "UTF-16 Codecs"
msgstr "UTF-16 Codecs"

#: ../../c-api/unicode.rst:1166
msgid "These are the UTF-16 codec APIs:"
msgstr "以下は UTF-16 codec の APIです:"

#: ../../c-api/unicode.rst:1172
msgid ""
"Decode *size* bytes from a UTF-16 encoded buffer string and return the "
"corresponding Unicode object.  *errors* (if non-*NULL*) defines the error "
"handling. It defaults to \"strict\"."
msgstr ""
"UTF-16 でエンコードされたバッファ *s* から *size* バイトだけデコードして、結"
"果を Unicode オブジェクトで返します。 *errors* は (*NULL* でない場合) エラー"
"処理方法を定義します。デフォルト値は \"strict\" です。"

#: ../../c-api/unicode.rst:1183
msgid ""
"If ``*byteorder`` is zero, and the first two bytes of the input data are a "
"byte order mark (BOM), the decoder switches to this byte order and the BOM "
"is not copied into the resulting Unicode string.  If ``*byteorder`` is "
"``-1`` or ``1``, any byte order mark is copied to the output (where it will "
"result in either a ``\\ufeff`` or a ``\\ufffe`` character)."
msgstr ""
"``*byteorder`` が 0 で、入力データの先頭2バイトがバイトオーダーマーク (BOM) "
"だった場合、デコーダは BOM が示すバイトオーダーに切り替え、そのBOMを結果の "
"Unicode 文字列にコピーしません。 ``*byteorder`` が ``-1`` か ``1`` だった場"
"合、すべてのBOMは出力へコピーされます (出力では ``\\ufeff`` か ``\\ufffe`` の"
"どちらかになるでしょう)。"

#: ../../c-api/unicode.rst:1200
msgid ""
"If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeUTF16`. If "
"*consumed* is not *NULL*, :c:func:`PyUnicode_DecodeUTF16Stateful` will not "
"treat trailing incomplete UTF-16 byte sequences (such as an odd number of "
"bytes or a split surrogate pair) as an error. Those bytes will not be "
"decoded and the number of bytes that have been decoded will be stored in "
"*consumed*."
msgstr ""
"*consumed* が *NULL* の場合、 :c:func:`PyUnicode_DecodeUTF16` と同じように動"
"作します。 *consumed* が *NULL* でない場合、 :c:func:"
"`PyUnicode_DecodeUTF16Stateful` は末尾の不完全な UTF-16 バイト列 (奇数長のバ"
"イト列や分割されたサロゲートペア) をエラーとみなしません。これらのバイト列は"
"デコードされず、デコードされたバイト数を *consumed* に返します。"

#: ../../c-api/unicode.rst:1209
msgid ""
"Return a Python byte string using the UTF-16 encoding in native byte order. "
"The string always starts with a BOM mark.  Error handling is \"strict\". "
"Return *NULL* if an exception was raised by the codec."
msgstr ""
"ネイティブバイトオーダーで UTF-16 エンコーディングされた Python バイト文字列"
"を返します。\n"
"文字列は常に BOM マークで始まります。\n"
"エラーハンドラは \"strict\" です。\n"
"codec が例外を発生させたときは *NULL* を返します。"

#: ../../c-api/unicode.rst:1217
msgid ""
"Return a Python bytes object holding the UTF-16 encoded value of the Unicode "
"data in *s*.  Output is written according to the following byte order::"
msgstr ""
"*s* の Unicode データを UTF-16 にエンコードし、その値を Python の bytes オブ"
"ジェクトに格納して返します。\n"
"出力は以下のバイトオーダーに従って書かれます::"

#: ../../c-api/unicode.rst:1227
msgid ""
"If *Py_UNICODE_WIDE* is defined, a single :c:type:`Py_UNICODE` value may get "
"represented as a surrogate pair. If it is not defined, each :c:type:"
"`Py_UNICODE` values is interpreted as a UCS-2 character."
msgstr ""
"*Py_UNICODE_WIDE* が定義されている場合、単一の :c:type:`Py_UNICODE` 値はサロ"
"ゲートペアとして表現されることがあります。 *Py_UNICODE_WIDE* が定義されていな"
"ければ、各 :c:type:`Py_UNICODE` 値は UCS-2 文字として表現されます。"

#: ../../c-api/unicode.rst:1235
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsUTF16String` or :c:func:`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsUTF16String` または :c:func:`PyUnicode_AsEncodedString` を使用す"
"るように移行してください。"

#: ../../c-api/unicode.rst:1239
msgid "UTF-7 Codecs"
msgstr "UTF-7 Codecs"

#: ../../c-api/unicode.rst:1241
msgid "These are the UTF-7 codec APIs:"
msgstr "以下は UTF-7 codec の API です:"

#: ../../c-api/unicode.rst:1246
msgid ""
"Create a Unicode object by decoding *size* bytes of the UTF-7 encoded string "
"*s*.  Return *NULL* if an exception was raised by the codec."
msgstr ""
"UTF-7 でエンコードされた *size* バイトの文字列 *s* をデコードして Unicode オ"
"ブジェクトを作成します。 codec が例外を発生させたときは *NULL* を返します。"

#: ../../c-api/unicode.rst:1253
msgid ""
"If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeUTF7`.  If "
"*consumed* is not *NULL*, trailing incomplete UTF-7 base-64 sections will "
"not be treated as an error.  Those bytes will not be decoded and the number "
"of bytes that have been decoded will be stored in *consumed*."
msgstr ""
"*consumed* が *NULL* のとき、 :c:func:`PyUnicode_DecodeUTF7` と同じように動作"
"します。 *consumed* が *NULL* でないとき、末尾の不完全な UTF-7 base-64 部分を"
"エラーとしません。不完全な部分のバイト列はデコードせずに、デコードしたバイト"
"数を *consumed* に格納します。"

#: ../../c-api/unicode.rst:1262
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer of the given size using UTF-7 and "
"return a Python bytes object.  Return *NULL* if an exception was raised by "
"the codec."
msgstr ""
"与えられたサイズの :c:type:`Py_UNICODE` バッファを UTF-7 でエンコードして、 "
"Python の bytes オブジェクトとして返します。 codec が例外を発生させたときは "
"*NULL* を返します。"

#: ../../c-api/unicode.rst:1266
msgid ""
"If *base64SetO* is nonzero, \"Set O\" (punctuation that has no otherwise "
"special meaning) will be encoded in base-64.  If *base64WhiteSpace* is "
"nonzero, whitespace will be encoded in base-64.  Both are set to zero for "
"the Python \"utf-7\" codec."
msgstr ""
"*base64SetO* がゼロでないとき、 \"Set O\" 文字 (他の場合には何も特別な意味を"
"持たない句読点) を base-64 エンコードします。 *base64WhiteSpace* がゼロでない"
"とき、空白文字を base-64 エンコードします。 Python の \"utf-7\" codec では、"
"両方ともゼロに設定されています。"

#: ../../c-api/unicode.rst:1277
msgid "Unicode-Escape Codecs"
msgstr "Unicode-Escape Codecs"

#: ../../c-api/unicode.rst:1279
msgid "These are the \"Unicode Escape\" codec APIs:"
msgstr "以下は \"Unicode Escape\" codec の API です:"

#: ../../c-api/unicode.rst:1285
msgid ""
"Create a Unicode object by decoding *size* bytes of the Unicode-Escape "
"encoded string *s*.  Return *NULL* if an exception was raised by the codec."
msgstr ""
"Unicode-Escape でエンコードされた *size* バイトの文字列 *s* から Unicode オブ"
"ジェクトを生成します。codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1291
msgid ""
"Encode a Unicode object using Unicode-Escape and return the result as a "
"bytes object.  Error handling is \"strict\".  Return *NULL* if an exception "
"was raised by the codec."
msgstr ""
"Unicode-Escape を使い Unicode オブジェクトをエンコードし、結果を bytes オブ"
"ジェクトとして返します。\n"
"エラー処理は \"strict\" です。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1298
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer of the given *size* using Unicode-"
"Escape and return a bytes object.  Return *NULL* if an exception was raised "
"by the codec."
msgstr ""
"Unicode-Escape を使い *size* で指定された長さを持つ :c:type:`Py_UNICODE` 型"
"バッファをエンコードし、 bytes オブジェクトにして返します。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1303
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsUnicodeEscapeString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsUnicodeEscapeString` を使用するように移行してください。"

#: ../../c-api/unicode.rst:1307
msgid "Raw-Unicode-Escape Codecs"
msgstr "Raw-Unicode-Escape Codecs"

#: ../../c-api/unicode.rst:1309
msgid "These are the \"Raw Unicode Escape\" codec APIs:"
msgstr "以下は \"Raw Unicode Escape\" codec の APIです:"

#: ../../c-api/unicode.rst:1315
msgid ""
"Create a Unicode object by decoding *size* bytes of the Raw-Unicode-Escape "
"encoded string *s*.  Return *NULL* if an exception was raised by the codec."
msgstr ""
"Raw-Unicode-Escape でエンコードされた *size* バイトの文字列 *s* から Unicode "
"オブジェクトを生成します。codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1321
msgid ""
"Encode a Unicode object using Raw-Unicode-Escape and return the result as a "
"bytes object.  Error handling is \"strict\".  Return *NULL* if an exception "
"was raised by the codec."
msgstr ""
"Raw-Unicode-Escape を使い Unicode オブジェクトをエンコードし、結果を bytes オ"
"ブジェクトとして返します。\n"
"エラー処理は \"strict\" です。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1329
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer of the given *size* using Raw-Unicode-"
"Escape and return a bytes object.  Return *NULL* if an exception was raised "
"by the codec."
msgstr ""
"Raw-Unicode-Escape を使い *size* で指定された長さを持つ :c:type:`Py_UNICODE` "
"型バッファをエンコードし、 bytes オブジェクトにして返します。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1335
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsRawUnicodeEscapeString` or :c:func:"
"`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsRawUnicodeEscapeString` または :c:func:"
"`PyUnicode_AsEncodedString` を使用するように移行してください。"

#: ../../c-api/unicode.rst:1339
msgid "Latin-1 Codecs"
msgstr "Latin-1 Codecs"

#: ../../c-api/unicode.rst:1341
msgid ""
"These are the Latin-1 codec APIs: Latin-1 corresponds to the first 256 "
"Unicode ordinals and only these are accepted by the codecs during encoding."
msgstr ""
"以下は Latin-1 codec の APIです: Latin-1 は、 Unicode 序数の最初の 256 個に対"
"応し、エンコード時にはこの 256 個だけを受理します。"

#: ../../c-api/unicode.rst:1347
msgid ""
"Create a Unicode object by decoding *size* bytes of the Latin-1 encoded "
"string *s*.  Return *NULL* if an exception was raised by the codec."
msgstr ""
"Latin-1 でエンコードされた *size* バイトの文字列 *s* から Unicode オブジェク"
"トを生成します。codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1353
msgid ""
"Encode a Unicode object using Latin-1 and return the result as Python bytes "
"object.  Error handling is \"strict\".  Return *NULL* if an exception was "
"raised by the codec."
msgstr ""
"Latin-1 で Unicode オブジェクトをエンコードし、結果を Python bytes オブジェク"
"トとして返します。\n"
"エラー処理は \"strict\" です。 codec が例外を送出した場合には *NULL* を返しま"
"す。"

#: ../../c-api/unicode.rst:1360
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer of the given *size* using Latin-1 and "
"return a Python bytes object.  Return *NULL* if an exception was raised by "
"the codec."
msgstr ""
"*size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを Latin-1 でエ"
"ンコードし、 Python bytes オブジェクトにして返します。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1367
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsLatin1String` or :c:func:`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsLatin1String` または :c:func:`PyUnicode_AsEncodedString` を使用"
"するように移行してください。"

#: ../../c-api/unicode.rst:1371
msgid "ASCII Codecs"
msgstr "ASCII Codecs"

#: ../../c-api/unicode.rst:1373
msgid ""
"These are the ASCII codec APIs.  Only 7-bit ASCII data is accepted. All "
"other codes generate errors."
msgstr ""
"以下は ASCII codec の APIです。 7 ビットの ASCII データだけを受理します。その"
"他のコードはエラーになります。"

#: ../../c-api/unicode.rst:1379
msgid ""
"Create a Unicode object by decoding *size* bytes of the ASCII encoded string "
"*s*.  Return *NULL* if an exception was raised by the codec."
msgstr ""
"ASCII でエンコードされた *size* バイトの文字列 *s* から Unicode オブジェクト"
"を生成します。codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1385
msgid ""
"Encode a Unicode object using ASCII and return the result as Python bytes "
"object.  Error handling is \"strict\".  Return *NULL* if an exception was "
"raised by the codec."
msgstr ""
"ASCII で Unicode オブジェクトをエンコードし、結果を Python bytes オブジェクト"
"として返します。\n"
"エラー処理は \"strict\" です。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1392
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer of the given *size* using ASCII and "
"return a Python bytes object.  Return *NULL* if an exception was raised by "
"the codec."
msgstr ""
"*size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを ASCII でエン"
"コードし、 Python bytes オブジェクトにして返します。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1399
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsASCIIString` or :c:func:`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsASCIIString` または :c:func:`PyUnicode_AsEncodedString` を使用す"
"るように移行してください。"

#: ../../c-api/unicode.rst:1403
msgid "Character Map Codecs"
msgstr "Character Map Codecs"

#: ../../c-api/unicode.rst:1405
msgid ""
"This codec is special in that it can be used to implement many different "
"codecs (and this is in fact what was done to obtain most of the standard "
"codecs included in the :mod:`encodings` package). The codec uses mapping to "
"encode and decode characters.  The mapping objects provided must support "
"the :meth:`__getitem__` mapping interface; dictionaries and sequences work "
"well."
msgstr ""
"この codec は、多くの様々な codec を実装する際に使われるという点で特殊な "
"codec です (実際、 :mod:`encodings` パッケージに入っている標準 codecs のほと"
"んどは、この codec を使っています)。\n"
"この codec は、文字のエンコードやデコードに対応表を使います。\n"
"提供される対応表のオブジェクトは :meth:`__getitem__` マッピングインターフェー"
"スをサポートしていなければなりません; 辞書やシーケンスがそれに適しています。"

#: ../../c-api/unicode.rst:1411
msgid "These are the mapping codec APIs:"
msgstr "以下は mapping codec の APIです:"

#: ../../c-api/unicode.rst:1416
msgid ""
"Create a Unicode object by decoding *size* bytes of the encoded string *s* "
"using the given *mapping* object.  Return *NULL* if an exception was raised "
"by the codec."
msgstr ""
"与えられた *mapping* オブジェクトを使って、 *size* バイトのエンコードされた文"
"字列 *s* をデコードして Unicode オブジェクトを作成します。\n"
"codec が例外を発生させたときは *NULL* を返します。"

#: ../../c-api/unicode.rst:1420
msgid ""
"If *mapping* is *NULL*, Latin-1 decoding will be applied.  Else *mapping* "
"must map bytes ordinals (integers in the range from 0 to 255) to Unicode "
"strings, integers (which are then interpreted as Unicode ordinals) or "
"``None``.  Unmapped data bytes -- ones which cause a :exc:`LookupError`, as "
"well as ones which get mapped to ``None``, ``0xFFFE`` or ``'\\ufffe'``, are "
"treated as undefined mappings and cause an error."
msgstr ""

#: ../../c-api/unicode.rst:1431
msgid ""
"Encode a Unicode object using the given *mapping* object and return the "
"result as a bytes object.  Error handling is \"strict\".  Return *NULL* if "
"an exception was raised by the codec."
msgstr ""
"Unicode オブジェクトを *mapping* に指定されたオブジェクトを使ってエンコード"
"し、結果を bytes オブジェクトとして返します。エラー処理は \"strict\" です。 "
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1435
msgid ""
"The *mapping* object must map Unicode ordinal integers to bytes objects, "
"integers in the range from 0 to 255 or ``None``.  Unmapped character "
"ordinals (ones which cause a :exc:`LookupError`) as well as mapped to "
"``None`` are treated as \"undefined mapping\" and cause an error."
msgstr ""

#: ../../c-api/unicode.rst:1444
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer of the given *size* using the given "
"*mapping* object and return the result as a bytes object.  Return *NULL* if "
"an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1451
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsCharmapString` or :c:func:`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsCharmapString` または :c:func:`PyUnicode_AsEncodedString` を使用"
"するように移行してください。"

#: ../../c-api/unicode.rst:1454
msgid "The following codec API is special in that maps Unicode to Unicode."
msgstr ""
"以下の codec API は Unicode から Unicode への対応付けを行う特殊なものです。"

#: ../../c-api/unicode.rst:1459
msgid ""
"Translate a Unicode object using the given *mapping* object and return the "
"resulting Unicode object.  Return *NULL* if an exception was raised by the "
"codec."
msgstr ""

#: ../../c-api/unicode.rst:1463
msgid ""
"The *mapping* object must map Unicode ordinal integers to Unicode strings, "
"integers (which are then interpreted as Unicode ordinals) or ``None`` "
"(causing deletion of the character).  Unmapped character ordinals (ones "
"which cause a :exc:`LookupError`) are left untouched and are copied as-is."
msgstr ""

#: ../../c-api/unicode.rst:1472
msgid ""
"Translate a :c:type:`Py_UNICODE` buffer of the given *size* by applying a "
"character *mapping* table to it and return the resulting Unicode object. "
"Return *NULL* when an exception was raised by the codec."
msgstr ""

#: ../../c-api/unicode.rst:1479
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_Translate`. or :ref:`generic codec based API <codec-"
"registry>`"
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_Translate`. または :ref:`汎用の codec ベースの API <codec-"
"registry>` を使用するように移行してください。"

#: ../../c-api/unicode.rst:1483
msgid "MBCS codecs for Windows"
msgstr "Windows 用の MBCS codec"

#: ../../c-api/unicode.rst:1485
msgid ""
"These are the MBCS codec APIs. They are currently only available on Windows "
"and use the Win32 MBCS converters to implement the conversions.  Note that "
"MBCS (or DBCS) is a class of encodings, not just one.  The target encoding "
"is defined by the user settings on the machine running the codec."
msgstr ""
"以下は MBCS codec の API です。この codec は現在のところ、 Windows 上だけで利"
"用でき、変換の実装には Win32 MBCS 変換機構 (Win32 MBCS converter) を使ってい"
"ます。 MBCS (または DBCS) はエンコード方式の種類 (class) を表す言葉で、単一の"
"エンコード方式を表すわけでなないので注意してください。利用されるエンコード方"
"式 (target encoding) は、 codec を動作させているマシン上のユーザ設定で定義さ"
"れています。"

#: ../../c-api/unicode.rst:1492
msgid ""
"Create a Unicode object by decoding *size* bytes of the MBCS encoded string "
"*s*. Return *NULL* if an exception was raised by the codec."
msgstr ""
"MBCS でエンコードされた *size* バイトの文字列 *s* から Unicode オブジェクトを"
"生成します。codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1499
msgid ""
"If *consumed* is *NULL*, behave like :c:func:`PyUnicode_DecodeMBCS`. If "
"*consumed* is not *NULL*, :c:func:`PyUnicode_DecodeMBCSStateful` will not "
"decode trailing lead byte and the number of bytes that have been decoded "
"will be stored in *consumed*."
msgstr ""
"*consumed* が *NULL* のとき、 :c:func:`PyUnicode_DecodeMBCS` と同じ動作をしま"
"す。 *consumed* が *NULL* でないとき、 :c:func:"
"`PyUnicode_DecodeMBCSStateful` は文字列の最後にあるマルチバイト文字の前半バイ"
"トをデコードせず、 *consumed* にデコードしたバイト数を格納します。"

#: ../../c-api/unicode.rst:1507
msgid ""
"Encode a Unicode object using MBCS and return the result as Python bytes "
"object.  Error handling is \"strict\".  Return *NULL* if an exception was "
"raised by the codec."
msgstr ""
"MBCS で Unicode オブジェクトをエンコードし、結果を Python バイト列オブジェク"
"トとして返します。エラー処理は \"strict\" です。 codec が例外を送出した場合に"
"は *NULL* を返します。"

#: ../../c-api/unicode.rst:1514
msgid ""
"Encode the Unicode object using the specified code page and return a Python "
"bytes object.  Return *NULL* if an exception was raised by the codec. Use :c:"
"data:`CP_ACP` code page to get the MBCS encoder."
msgstr ""
"指定されたコードページを使い Unicode オブジェクトをエンコードし、 Python "
"bytes オブジェクトを返します。\n"
"codec が例外を送出した場合には *NULL* を返します。\n"
":c:data:`CP_ACP` コードページを使い MBCS エンコーダを取得してください。"

#: ../../c-api/unicode.rst:1523
msgid ""
"Encode the :c:type:`Py_UNICODE` buffer of the given *size* using MBCS and "
"return a Python bytes object.  Return *NULL* if an exception was raised by "
"the codec."
msgstr ""
"*size* で指定された長さを持つ :c:type:`Py_UNICODE` 型バッファを MBCS でエン"
"コードし、 Python bytes オブジェクトにして返します。\n"
"codec が例外を送出した場合には *NULL* を返します。"

#: ../../c-api/unicode.rst:1530
msgid ""
"Part of the old-style :c:type:`Py_UNICODE` API; please migrate to using :c:"
"func:`PyUnicode_AsMBCSString`, :c:func:`PyUnicode_EncodeCodePage` or :c:func:"
"`PyUnicode_AsEncodedString`."
msgstr ""
"古いスタイルの :c:type:`Py_UNICODE` APIの一部です; :c:func:"
"`PyUnicode_AsMBCSString`, :c:func:`PyUnicode_EncodeCodePage`, :c:func:"
"`PyUnicode_AsEncodedString` のいずれかを使用するように移行してください。"

#: ../../c-api/unicode.rst:1534
msgid "Methods & Slots"
msgstr "メソッドとスロット"

#: ../../c-api/unicode.rst:1540
msgid "Methods and Slot Functions"
msgstr "メソッドおよびスロット関数 (slot function)"

#: ../../c-api/unicode.rst:1542
msgid ""
"The following APIs are capable of handling Unicode objects and strings on "
"input (we refer to them as strings in the descriptions) and return Unicode "
"objects or integers as appropriate."
msgstr ""
"以下の API は Unicode オブジェクトおよび文字列を入力に取り (説明では、どちら"
"も文字列と表記しています)、場合に応じて Unicode オブジェクトか整数を返す機能"
"を持っています。"

#: ../../c-api/unicode.rst:1546
msgid "They all return *NULL* or ``-1`` if an exception occurs."
msgstr ""
"これらの関数は全て、例外が発生した場合には *NULL* または ``-1`` を返します。"

#: ../../c-api/unicode.rst:1551
msgid "Concat two strings giving a new Unicode string."
msgstr "二つの文字列を結合して、新たな Unicode 文字列を生成します。"

#: ../../c-api/unicode.rst:1556
msgid ""
"Split a string giving a list of Unicode strings.  If *sep* is *NULL*, "
"splitting will be done at all whitespace substrings.  Otherwise, splits "
"occur at the given separator.  At most *maxsplit* splits will be done.  If "
"negative, no limit is set.  Separators are not included in the resulting "
"list."
msgstr ""
"Unicode 文字列のリストを分割して、 Unicode 文字列からなるリストを返します。 "
"*sep* が *NULL* の場合、全ての空白文字を使って分割を行います。それ以外の場"
"合、指定された文字を使って分割を行います。最大で *maxsplit* 個までの分割を行"
"います。 *maxsplit* が負ならば分割数に制限を設けません。分割結果のリスト内に"
"は分割文字は含みません。"

#: ../../c-api/unicode.rst:1564
msgid ""
"Split a Unicode string at line breaks, returning a list of Unicode strings. "
"CRLF is considered to be one line break.  If *keepend* is ``0``, the Line "
"break characters are not included in the resulting strings."
msgstr ""
"Unicode 文字列を改行文字で区切り、Unicode 文字列からなるリストを返します。\n"
"CRLF は一個の改行文字とみなします。\n"
"*keepend* が ``0`` の場合、分割結果のリスト内に改行文字を含めません。"

#: ../../c-api/unicode.rst:1572
msgid ""
"Translate a string by applying a character mapping table to it and return "
"the resulting Unicode object."
msgstr ""
"文字列に文字対応表 *table* を適用して変換し、変換結果を Unicode オブジェクト"
"で返します。"

#: ../../c-api/unicode.rst:1575
msgid ""
"The mapping table must map Unicode ordinal integers to Unicode ordinal "
"integers or ``None`` (causing deletion of the character)."
msgstr ""
"対応表は、Unicode 序数を表す整数を Unicode 序数を表す整数または ``None`` (そ"
"の文字を削除する) に対応付けなければなりません。"

#: ../../c-api/unicode.rst:1578
msgid ""
"Mapping tables need only provide the :meth:`__getitem__` interface; "
"dictionaries and sequences work well.  Unmapped character ordinals (ones "
"which cause a :exc:`LookupError`) are left untouched and are copied as-is."
msgstr ""
"対応表が提供する必要があるメソッドは :meth:`__getitem__` インタフェースだけで"
"す; 従って、辞書やシーケンス型を使ってもうまく動作します。\n"
"対応付けを行っていない (:exc:`LookupError` を起こすような) 文字序数に対して"
"は、変換は行わず、そのままコピーします。"

#: ../../c-api/unicode.rst:1582
msgid ""
"*errors* has the usual meaning for codecs. It may be *NULL* which indicates "
"to use the default error handling."
msgstr ""
"*errors* は codecs で通常使われるのと同じ意味を持ちます。 *errors* は *NULL* "
"にしてもよく、デフォルトエラー処理の使用を意味します。"

#: ../../c-api/unicode.rst:1588
msgid ""
"Join a sequence of strings using the given *separator* and return the "
"resulting Unicode string."
msgstr ""
"指定した *separator* で文字列からなるシーケンスを連結 (join) し、連結結果を "
"Unicode 文字列で返します。"

#: ../../c-api/unicode.rst:1595
msgid ""
"Return ``1`` if *substr* matches ``str[start:end]`` at the given tail end "
"(*direction* == ``-1`` means to do a prefix match, *direction* == ``1`` a "
"suffix match), ``0`` otherwise. Return ``-1`` if an error occurred."
msgstr ""
"*substr* が ``str[start:end]`` の末端 (*direction* == ``-1`` は先頭一致、 "
"*direction* == ``1`` は末尾一致) でとマッチする場合に ``1`` を返し、それ以外"
"の場合には ``0`` を返します。\n"
"エラーが発生した時は ``-1`` を返します。"

#: ../../c-api/unicode.rst:1603
msgid ""
"Return the first position of *substr* in ``str[start:end]`` using the given "
"*direction* (*direction* == ``1`` means to do a forward search, *direction* "
"== ``-1`` a backward search).  The return value is the index of the first "
"match; a value of ``-1`` indicates that no match was found, and ``-2`` "
"indicates that an error occurred and an exception has been set."
msgstr ""
"``str[start:end]`` 中に *substr* が最初に出現する場所を返します。\n"
"このとき指定された検索方向 *direction* (*direction* == ``1`` は順方向検索、 "
"*direction* == ``-1`` は逆方向検索) で検索します。\n"
"戻り値は最初にマッチが見つかった場所のインデックスです; 戻り値 ``-1`` はマッ"
"チが見つからなかったことを表し、 ``-2`` はエラーが発生して例外情報が設定され"
"ていることを表します。"

#: ../../c-api/unicode.rst:1613
msgid ""
"Return the first position of the character *ch* in ``str[start:end]`` using "
"the given *direction* (*direction* == ``1`` means to do a forward search, "
"*direction* == ``-1`` a backward search).  The return value is the index of "
"the first match; a value of ``-1`` indicates that no match was found, and "
"``-2`` indicates that an error occurred and an exception has been set."
msgstr ""
"``str[start:end]`` 中に文字 *ch* が最初に出現する場所を返します。\n"
"このとき指定された検索方向 *direction* (*direction* == ``1`` は順方向検索、 "
"*direction* == ``-1`` は逆方向検索) で検索します。\n"
"戻り値は最初にマッチが見つかった場所のインデックスです; 戻り値 ``-1`` はマッ"
"チが見つからなかったことを表し、 ``-2`` はエラーが発生して例外情報が設定され"
"ていることを表します。"

#: ../../c-api/unicode.rst:1625
msgid ""
"Return the number of non-overlapping occurrences of *substr* in ``str[start:"
"end]``.  Return ``-1`` if an error occurred."
msgstr ""
"``str[start:end]`` に *substr* が重複することなく出現する回数を返します。エ"
"ラーが発生した場合には ``-1`` を返します。"

#: ../../c-api/unicode.rst:1632
msgid ""
"Replace at most *maxcount* occurrences of *substr* in *str* with *replstr* "
"and return the resulting Unicode object. *maxcount* == ``-1`` means replace "
"all occurrences."
msgstr ""
"*str* 中に出現する *substr* を最大で *maxcount* 個 *replstr* に置換し、置換結"
"果である Unicode オブジェクトを返します。\n"
"*maxcount* == ``-1`` にすると、文字列中に現れる全ての *substr* を置換します。"

#: ../../c-api/unicode.rst:1639
msgid ""
"Compare two strings and return ``-1``, ``0``, ``1`` for less than, equal, "
"and greater than, respectively."
msgstr ""
"二つの文字列を比較して、左引数が右引数より小さい場合、左右引数が等価の場合、"
"左引数が右引数より大きい場合に対して、それぞれ ``-1``, ``0``, ``1`` を返しま"
"す。"

#: ../../c-api/unicode.rst:1642
msgid ""
"This function returns ``-1`` upon failure, so one should call :c:func:"
"`PyErr_Occurred` to check for errors."
msgstr ""
"この関数は、失敗したときに ``-1`` を返すので、 :c:func:`PyErr_Occurred` を呼"
"び出して、エラーをチェックすべきです。"

#: ../../c-api/unicode.rst:1648
msgid ""
"Compare a unicode object, *uni*, with *string* and return ``-1``, ``0``, "
"``1`` for less than, equal, and greater than, respectively. It is best to "
"pass only ASCII-encoded strings, but the function interprets the input "
"string as ISO-8859-1 if it contains non-ASCII characters."
msgstr ""
"Unicode オブジェクト *uni* と *string* を比較して、左引数が右引数より小さい場"
"合、左右引数が等価の場合、左引数が右引数より大きい場合に対して、それぞれ "
"``-1``, ``0``, ``1`` を返します。\n"
"ASCII エンコードされた文字列だけを渡すのが最も良いですが、入力文字列に非 "
"ASCII 文字が含まれている場合は ISO-8859-1 として解釈します。"

#: ../../c-api/unicode.rst:1653
msgid "This function does not raise exceptions."
msgstr "この関数は例外を送出しません。"

#: ../../c-api/unicode.rst:1658
msgid "Rich compare two unicode strings and return one of the following:"
msgstr "二つのunicode文字列を比較して、下のうちの一つを返します:"

#: ../../c-api/unicode.rst:1660
msgid "``NULL`` in case an exception was raised"
msgstr "``NULL`` を、例外が発生したときに返します。"

#: ../../c-api/unicode.rst:1661
msgid ":const:`Py_True` or :const:`Py_False` for successful comparisons"
msgstr ""
":const:`Py_True` もしくは :const:`Py_False` を、正しく比較できた時に返しま"
"す。"

#: ../../c-api/unicode.rst:1662
msgid ":const:`Py_NotImplemented` in case the type combination is unknown"
msgstr ""
":const:`Py_NotImplemented` を、 *left* と *right* のどちらかに対する :c:func:"
"`PyUnicode_FromObject` が失敗したときに返します。(原文: in case the type "
"combination is unknown)"

#: ../../c-api/unicode.rst:1664
msgid ""
"Possible values for *op* are :const:`Py_GT`, :const:`Py_GE`, :const:"
"`Py_EQ`, :const:`Py_NE`, :const:`Py_LT`, and :const:`Py_LE`."
msgstr ""
"*op* に入れられる値は、 :const:`Py_GT`, :const:`Py_GE`, :const:`Py_EQ`, :"
"const:`Py_NE`, :const:`Py_LT`, and :const:`Py_LE` のどれかです。"

#: ../../c-api/unicode.rst:1670
msgid ""
"Return a new string object from *format* and *args*; this is analogous to "
"``format % args``."
msgstr ""
"新たな文字列オブジェクトを *format* および *args* から生成して返します; この"
"メソッドは ``format % args`` のようなものです。"

#: ../../c-api/unicode.rst:1676
msgid ""
"Check whether *element* is contained in *container* and return true or false "
"accordingly."
msgstr ""
"*element* が *container* 内にあるか調べ、その結果に応じて真または偽を返しま"
"す。"

#: ../../c-api/unicode.rst:1679
msgid ""
"*element* has to coerce to a one element Unicode string. ``-1`` is returned "
"if there was an error."
msgstr ""
"*element* は単要素の Unicode 文字に型強制できなければなりません。エラーが生じ"
"た場合には ``-1`` を返します。"

#: ../../c-api/unicode.rst:1685
msgid ""
"Intern the argument *\\*string* in place.  The argument must be the address "
"of a pointer variable pointing to a Python unicode string object.  If there "
"is an existing interned string that is the same as *\\*string*, it sets "
"*\\*string* to it (decrementing the reference count of the old string object "
"and incrementing the reference count of the interned string object), "
"otherwise it leaves *\\*string* alone and interns it (incrementing its "
"reference count). (Clarification: even though there is a lot of talk about "
"reference counts, think of this function as reference-count-neutral; you own "
"the object after the call if and only if you owned it before the call.)"
msgstr ""
"引数 *\\*string* をインプレースで収容 (intern) します。\n"
"引数は Python Unicode 文字列オブジェクトを指すポインタ変数のアドレスでなけれ"
"ばなりません。\n"
"*\\*string* と等しい、すでに収容済みの文字列が存在する場合は、 *\\*string* に"
"その文字列を設定します (そして、元の渡された文字列オブジェクトの参照カウント"
"をデクリメントし、すでに収容済みの文字列オブジェクトの参照カウントをインクリ"
"メントします)。\n"
"そうでない場合は、 *\\*string* は変更せず、そのまま収容します (そして、参照カ"
"ウントをインクリメントします)。\n"
"(解説: 参照カウントについては沢山説明して来ましたが、この関数は参照カウント中"
"立 (reference-count-neutral) と考えてください; この関数を呼び出した後にオブ"
"ジェクトの所有権を持っているのは、関数を呼び出す前にすでに所有権を持っていた"
"場合かつその場合に限ります。)"

#: ../../c-api/unicode.rst:1698
msgid ""
"A combination of :c:func:`PyUnicode_FromString` and :c:func:"
"`PyUnicode_InternInPlace`, returning either a new unicode string object that "
"has been interned, or a new (\"owned\") reference to an earlier interned "
"string object with the same value."
msgstr ""
":c:func:`PyUnicode_FromString` と :c:func:`PyUnicode_InternInPlace` を組み合"
"わせたもので、収容済みの新たな文字列オブジェクトを返すか、同じ値を持つ収容済"
"みの Unicode 文字列オブジェクトに対する新たな (\"所有権のある\") 参照を返しま"
"す。"