codecs.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-30 05:56+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Osamu NAKAMURA, 2017\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/codecs.rst:2
msgid ":mod:`codecs` --- Codec registry and base classes"
msgstr ":mod:`codecs` --- codec レジストリと基底クラス"

#: ../../library/codecs.rst:11
msgid "**Source code:** :source:`Lib/codecs.py`"
msgstr "**ソースコード:** :source:`Lib/codecs.py`"

#: ../../library/codecs.rst:23
msgid ""
"This module defines base classes for standard Python codecs (encoders and "
"decoders) and provides access to the internal Python codec registry, which "
"manages the codec and error handling lookup process. Most standard codecs "
"are :term:`text encodings <text encoding>`, which encode text to bytes, but "
"there are also codecs provided that encode text to text, and bytes to bytes."
" Custom codecs may encode and decode between arbitrary types, but some "
"module features are restricted to use specifically with :term:`text "
"encodings <text encoding>`, or with codecs that encode to :class:`bytes`."
msgstr ""
"このモジュールは、標準的な Python codec (エンコーダとデコーダ) 用の基底クラスを定義し、codec "
"とエラー処理検索プロセスを管理する内部の Python codec レジストリへのアクセスを提供します。多くの codec "
"はテキストをバイト形式にエンコードする :term:`テキストエンコーディング <text encoding>` "
"ですが、テキストをテキストに、またはバイトをバイトにエンコードする codec も提供されています。カスタムの codec "
"は任意の型間でエンコードとデコードを行えますが、一部のモジュール機能は :term:`テキストエンコーディング <text encoding>` か "
":class:`bytes` へのエンコードのみに制限されています。"

#: ../../library/codecs.rst:33
msgid ""
"The module defines the following functions for encoding and decoding with "
"any codec:"
msgstr "このモジュールでは、任意の codec でエンコードやデコードを行うための、以下の関数が定義されています。"

#: ../../library/codecs.rst:38
msgid "Encodes *obj* using the codec registered for *encoding*."
msgstr "*encoding* に記載された codec を使用して *obj* をエンコードします。"

#: ../../library/codecs.rst:40
msgid ""
"*Errors* may be given to set the desired error handling scheme. The default "
"error handler is ``'strict'`` meaning that encoding errors raise "
":exc:`ValueError` (or a more codec specific subclass, such as "
":exc:`UnicodeEncodeError`). Refer to :ref:`codec-base-classes` for more "
"information on codec error handling."
msgstr ""
"希望のエラー処理スキームを *errors* に設定することができます。デフォルトのエラーハンドラ (エラー処理関数) は ``'strict'`` "
"です。これはエンコードエラーは :exc:`ValueError` (もしくは :exc:`UnicodeEncodeError` のような、より "
"codec に固有のサブクラス) を送出することを意味します。codec エラー処理についてのより詳しい情報は :ref:`codec-base-"
"classes` を参照してください。"

#: ../../library/codecs.rst:48
msgid "Decodes *obj* using the codec registered for *encoding*."
msgstr "*encoding* に記載された codec を使用して *obj* をデコードします。"

#: ../../library/codecs.rst:50
msgid ""
"*Errors* may be given to set the desired error handling scheme. The default "
"error handler is ``'strict'`` meaning that decoding errors raise "
":exc:`ValueError` (or a more codec specific subclass, such as "
":exc:`UnicodeDecodeError`). Refer to :ref:`codec-base-classes` for more "
"information on codec error handling."
msgstr ""
"希望のエラー処理スキームを *errors* に設定することができます。デフォルトのエラーハンドラは ``'strict'`` "
"です。これはデコードエラーは :exc:`ValueError` (もしくは :exc:`UnicodeDecodeError` のような、より "
"codec に固有のサブクラス) を送出することを意味します。codec エラー処理についてのより詳しい情報は :ref:`codec-base-"
"classes` を参照してください。"

#: ../../library/codecs.rst:56
msgid "The full details for each codec can also be looked up directly:"
msgstr "各 codec についての詳細も、次のようにして直接調べることができます。"

#: ../../library/codecs.rst:60
msgid ""
"Looks up the codec info in the Python codec registry and returns a "
":class:`CodecInfo` object as defined below."
msgstr ""
"Python codec レジストリから codec 情報を探し、以下で定義するような :class:`CodecInfo` オブジェクトを返します。"

#: ../../library/codecs.rst:63
msgid ""
"Encodings are first looked up in the registry's cache. If not found, the "
"list of registered search functions is scanned. If no :class:`CodecInfo` "
"object is found, a :exc:`LookupError` is raised. Otherwise, the "
":class:`CodecInfo` object is stored in the cache and returned to the caller."
msgstr ""
"エンコーディングの検索は、まずレジストリのキャッシュから行います。見つからなければ、登録されている検索関数のリストから探します。 "
":class:`CodecInfo` オブジェクトが一つも見つからなければ :exc:`LookupError` を送出します。見つかったら、その "
":class:`CodecInfo` オブジェクトはキャッシュに保存され、呼び出し側に返されます。"

#: ../../library/codecs.rst:70
msgid ""
"Codec details when looking up the codec registry. The constructor arguments "
"are stored in attributes of the same name:"
msgstr "codec レジストリ内を検索する場合の、codec の詳細です。コントラクタ引数は、次の同名の属性に保存されます。"

#: ../../library/codecs.rst:76
msgid "The name of the encoding."
msgstr "エンコーディングの名前です。"

#: ../../library/codecs.rst:82
msgid ""
"The stateless encoding and decoding functions. These must be functions or "
"methods which have the same interface as the :meth:`~Codec.encode` and "
":meth:`~Codec.decode` methods of Codec instances (see :ref:`Codec Interface "
"<codec-objects>`). The functions or methods are expected to work in a "
"stateless mode."
msgstr ""
"ステートレスなエンコーディングとデコーディングの関数です。これらは、Codec インスタンスの :meth:`~Codec.encode` メソッドと "
":meth:`~Codec.decode` メソッドと同じインターフェースを持っている必要があります (see :ref:`Codec "
"のインターフェース <codec-objects>` を参照)。この関数またはメソッドは、ステートレスモードで動作することが想定されています。"

#: ../../library/codecs.rst:92
msgid ""
"Incremental encoder and decoder classes or factory functions. These have to "
"provide the interface defined by the base classes "
":class:`IncrementalEncoder` and :class:`IncrementalDecoder`, respectively. "
"Incremental codecs can maintain state."
msgstr ""
"インクリメンタル・エンコーダとデコーダのクラスまたはファクトリ関数です。これらは、基底クラスの :class:`IncrementalEncoder` "
"と :class:`IncrementalDecoder` が定義するインターフェースをそれぞれ提供する必要があります。インクリメンタルな codec "
"は、ステート (内部状態) を保持することができます。"

#: ../../library/codecs.rst:101
msgid ""
"Stream writer and reader classes or factory functions. These have to provide"
" the interface defined by the base classes :class:`StreamWriter` and "
":class:`StreamReader`, respectively. Stream codecs can maintain state."
msgstr ""
"ストリームライターとリーダーのクラスまたはファクトリ関数です。これらは、基底クラスの  :class:`StreamWriter` と "
":class:`StreamReader` が定義するインターフェースをそれぞれ提供する必要があります。ストリーム codec "
"は、ステートを保持することができます。"

#: ../../library/codecs.rst:106
msgid ""
"To simplify access to the various codec components, the module provides "
"these additional functions which use :func:`lookup` for the codec lookup:"
msgstr ""
"さまざまな codec 構成要素へのアクセスを簡便化するために、このモジュールは以下のような関数を提供しています。これらの関数は、 codec の検索に"
" :func:`lookup` を使います:"

#: ../../library/codecs.rst:111
msgid ""
"Look up the codec for the given encoding and return its encoder function."
msgstr "与えられたエンコーディングに対する codec を検索し、エンコーダ関数を返します。"

#: ../../library/codecs.rst:113 ../../library/codecs.rst:120
#: ../../library/codecs.rst:146 ../../library/codecs.rst:154
msgid "Raises a :exc:`LookupError` in case the encoding cannot be found."
msgstr "エンコーディングが見つからなければ :exc:`LookupError` を送出します。"

#: ../../library/codecs.rst:118
msgid ""
"Look up the codec for the given encoding and return its decoder function."
msgstr "与えられたエンコーディングに対する codec を検索し、デコーダ関数を返します。"

#: ../../library/codecs.rst:125
msgid ""
"Look up the codec for the given encoding and return its incremental encoder "
"class or factory function."
msgstr "与えられたエンコーディングに対する codec を検索し、インクリメンタル・エンコーダクラスまたはファクトリ関数を返します。"

#: ../../library/codecs.rst:128
msgid ""
"Raises a :exc:`LookupError` in case the encoding cannot be found or the "
"codec doesn't support an incremental encoder."
msgstr ""
"エンコーディングが見つからないか、 codec がインクリメンタル・エンコーダをサポートしなければ :exc:`LookupError` を送出します。"

#: ../../library/codecs.rst:134
msgid ""
"Look up the codec for the given encoding and return its incremental decoder "
"class or factory function."
msgstr "与えられたエンコーディングに対する codec を検索し、インクリメンタル・デコーダクラスまたはファクトリ関数を返します。"

#: ../../library/codecs.rst:137
msgid ""
"Raises a :exc:`LookupError` in case the encoding cannot be found or the "
"codec doesn't support an incremental decoder."
msgstr ""
"エンコーディングが見つからないか、 codec がインクリメンタル・デコーダをサポートしなければ :exc:`LookupError` を送出します。"

#: ../../library/codecs.rst:143
msgid ""
"Look up the codec for the given encoding and return its "
":class:`StreamReader` class or factory function."
msgstr ""
"与えられたエンコーディングに対する codec を検索し、:class:`StreamReader` クラスまたはファクトリ関数を返します。"

#: ../../library/codecs.rst:151
msgid ""
"Look up the codec for the given encoding and return its "
":class:`StreamWriter` class or factory function."
msgstr ""
"与えられたエンコーディングに対する codec を検索し、:class:`StreamWriter` クラスまたはファクトリ関数を返します。"

#: ../../library/codecs.rst:156
msgid ""
"Custom codecs are made available by registering a suitable codec search "
"function:"
msgstr "次のように、適切な codec 検索関数を登録することで、カスタムの codecs を利用することができます。"

#: ../../library/codecs.rst:161
msgid ""
"Register a codec search function. Search functions are expected to take one "
"argument, being the encoding name in all lower case letters, and return a "
":class:`CodecInfo` object. In case a search function cannot find a given "
"encoding, it should return ``None``."
msgstr ""
"codec 検索関数を登録します。検索関数は第 1 "
"引数にすべてアルファベットの小文字から成るエンコーディング名を取り、:class:`CodecInfo` "
"オブジェクトを返します。検索関数が指定されたエンコーディングを見つけられない場合、``None`` を返します。"

#: ../../library/codecs.rst:168
msgid ""
"Search function registration is not currently reversible, which may cause "
"problems in some cases, such as unit testing or module reloading."
msgstr "現在、検索関数の登録は不可逆的です。このため、ユニットテストやモジュールの再ロード時などに問題が生じることがあります。"

#: ../../library/codecs.rst:172
msgid ""
"While the builtin :func:`open` and the associated :mod:`io` module are the "
"recommended approach for working with encoded text files, this module "
"provides additional utility functions and classes that allow the use of a "
"wider range of codecs when working with binary files:"
msgstr ""
"エンコードされたテキストファイルを処理する場合、組み込みの :func:`open` とそれに関連付けられた :mod:`io` "
"モジュールの使用が推奨されていますが、このモジュールは追加のユーティリティ関数とクラスを提供し、バイナリファイルを処理する場合に幅広い codecs "
"を利用できるようにします。"

#: ../../library/codecs.rst:179
msgid ""
"Open an encoded file using the given *mode* and return an instance of "
":class:`StreamReaderWriter`, providing transparent encoding/decoding. The "
"default file mode is ``'r'``, meaning to open the file in read mode."
msgstr ""
"エンコードされたファイルを *mode* を使って開き、透過的なエンコード/デコードを提供する :class:`StreamReaderWriter` "
"のインスタンスを返します。デフォルトのファイルモードは ``'r'`` 、つまり、読み出しモードでファイルを開きます。"

#: ../../library/codecs.rst:185
msgid ""
"Underlying encoded files are always opened in binary mode. No automatic "
"conversion of ``'\\n'`` is done on reading and writing. The *mode* argument "
"may be any binary mode acceptable to the built-in :func:`open` function; the"
" ``'b'`` is automatically added."
msgstr ""
"下層のエンコードされたファイルは、常にバイナリモードで開きます。読み書き時に、 ``'\\n'`` の自動変換は行われません。*mode* "
"引数は、組み込みの :func:`open` 関数が受け入れる任意のバイナリモードにすることができます。``'b'`` が自動的に付加されます。"

#: ../../library/codecs.rst:190
msgid ""
"*encoding* specifies the encoding which is to be used for the file. Any "
"encoding that encodes to and decodes from bytes is allowed, and the data "
"types supported by the file methods depend on the codec used."
msgstr ""
"*encoding* "
"は、そのファイルに対して使用されるエンコーディングを指定します。バイトにエンコードする、あるいはバイトからデコードするすべてのエンコーディングが許可されます。ファイルメソッドがサポートするデータ型は、使用される"
" codec によって異なります。"

#: ../../library/codecs.rst:194
msgid ""
"*errors* may be given to define the error handling. It defaults to "
"``'strict'`` which causes a :exc:`ValueError` to be raised in case an "
"encoding error occurs."
msgstr ""
"エラーハンドリングのために *errors* を渡すことができます。これはデフォルトでは ``'strict'`` で、エンコード時にエラーがあれば "
":exc:`ValueError` を送出します。"

#: ../../library/codecs.rst:197
msgid ""
"*buffering* has the same meaning as for the built-in :func:`open` function."
"  It defaults to line buffered."
msgstr "*buffering* は組み込み関数 :func:`open` の場合と同じ意味を持ちます。デフォルトでは行バッファリングです。"

#: ../../library/codecs.rst:203
msgid ""
"Return a :class:`StreamRecoder` instance, a wrapped version of *file* which "
"provides transparent transcoding. The original file is closed when the "
"wrapped version is closed."
msgstr ""
"透過的なエンコード変換を行うファイルのラップされたバージョンである、:class:`StreamRecoder` "
"インスタンスを返します。元のファイルは、ラップされたバージョンが閉じられる時に、閉じられます。"

#: ../../library/codecs.rst:207
msgid ""
"Data written to the wrapped file is decoded according to the given "
"*data_encoding* and then written to the original file as bytes using "
"*file_encoding*. Bytes read from the original file are decoded according to "
"*file_encoding*, and the result is encoded using *data_encoding*."
msgstr ""
"ラップされたファイルに書き込まれたデータは、指定された *data_encoding* に従ってデコードされ、次に *file_encoding* "
"を使用して元のファイルにバイトとして書き出されます。元のファイルから読み出されたバイトは、*file_encoding* に従ってデコードされ、結果は "
"*data_encoding* を使用してエンコードされます。"

#: ../../library/codecs.rst:213
msgid "If *file_encoding* is not given, it defaults to *data_encoding*."
msgstr "*file_encoding* が与えられなければ、*data_encoding* がデフォルトになります。"

#: ../../library/codecs.rst:215
msgid ""
"*errors* may be given to define the error handling. It defaults to "
"``'strict'``, which causes :exc:`ValueError` to be raised in case an "
"encoding error occurs."
msgstr ""
"エラーハンドリングのために *errors* を渡すことができます。これはデフォルトでは ``'strict'`` で、エンコード時にエラーがあれば "
":exc:`ValueError` を送出します。"

#: ../../library/codecs.rst:222
msgid ""
"Uses an incremental encoder to iteratively encode the input provided by "
"*iterator*. This function is a :term:`generator`. The *errors* argument (as "
"well as any other keyword argument) is passed through to the incremental "
"encoder."
msgstr ""
"インクリメンタル・エンコーダを使って、 *iterator* から供給される入力を反復的にエンコードします。この関数は "
":term:`generator` です。 *errors* 引数は (他のあらゆるキーワード引数と同様に) "
"インクリメンタル・エンコーダにそのまま引き渡されます。"

#: ../../library/codecs.rst:227
msgid ""
"This function requires that the codec accept text :class:`str` objects to "
"encode. Therefore it does not support bytes-to-bytes encoders such as "
"``base64_codec``."
msgstr ""
"この関数では、コーデックはエンコードするテキストの :class:`str` オブジェクトを受け付ける必要があります。\n"
"従って、 ``base64_codec`` のようなバイトからバイトへのエンコーダはサポートしていません。"

#: ../../library/codecs.rst:234
msgid ""
"Uses an incremental decoder to iteratively decode the input provided by "
"*iterator*. This function is a :term:`generator`. The *errors* argument (as "
"well as any other keyword argument) is passed through to the incremental "
"decoder."
msgstr ""
"インクリメンタル・デコーダを使って、 *iterator* から供給される入力を反復的にデコードします。この関数は :term:`generator` "
"です。 *errors* 引数は (他のあらゆるキーワード引数と同様に) インクリメンタル・デコーダにそのまま引き渡されます。"

#: ../../library/codecs.rst:239
msgid ""
"This function requires that the codec accept :class:`bytes` objects to "
"decode. Therefore it does not support text-to-text encoders such as "
"``rot_13``, although ``rot_13`` may be used equivalently with "
":func:`iterencode`."
msgstr ""
"この関数では、コーデックはエンコードする :class:`bytes` オブジェクトを受け付ける必要があります。\n"
"従って、 ``rot_13`` のようなテキストからテキストへのエンコーダが :func:`iterencode` で同等に使えるとしても、この関数ではサポートしていません。"

#: ../../library/codecs.rst:245
msgid ""
"The module also provides the following constants which are useful for "
"reading and writing to platform dependent files:"
msgstr "このモジュールは以下のような定数も定義しています。プラットフォーム依存なファイルを読み書きするのに役立ちます:"

#: ../../library/codecs.rst:260
msgid ""
"These constants define various byte sequences, being Unicode byte order "
"marks (BOMs) for several encodings. They are used in UTF-16 and UTF-32 data "
"streams to indicate the byte order used, and in UTF-8 as a Unicode "
"signature. :const:`BOM_UTF16` is either :const:`BOM_UTF16_BE` or "
":const:`BOM_UTF16_LE` depending on the platform's native byte order, "
":const:`BOM` is an alias for :const:`BOM_UTF16`, :const:`BOM_LE` for "
":const:`BOM_UTF16_LE` and :const:`BOM_BE` for :const:`BOM_UTF16_BE`. The "
"others represent the BOM in UTF-8 and UTF-32 encodings."
msgstr ""
"これらの定数は、いくつかのエンコーディングの Unicode のバイトオーダマーク (BOM) "
"で、様々なバイトシーケンスを定義します。これらは、UTF-16 と UTF-32 のデータストリームで使用するバイトオーダを指定したり、 UTF-8 で"
" Unicode シグネチャとして使われます。 :const:`BOM_UTF16` は、プラットフォームのネイティブバイトオーダによって "
":const:`BOM_UTF16_BE` または :const:`BOM_UTF16_LE` です。 :const:`BOM` は "
":const:`BOM_UTF16` のエイリアスです。同様に、 :const:`BOM_LE` は :const:`BOM_UTF16_LE` の、 "
":const:`BOM_BE` は :const:`BOM_UTF16_BE` のエイリアスです。その他の定数は UTF-8 と UTF-32 "
"エンコーディングの BOM を表します。"

#: ../../library/codecs.rst:274
msgid "Codec Base Classes"
msgstr "Codec 基底クラス"

#: ../../library/codecs.rst:276
msgid ""
"The :mod:`codecs` module defines a set of base classes which define the "
"interfaces for working with codec objects, and can also be used as the basis"
" for custom codec implementations."
msgstr ""
":mod:`codecs` モジュールは、 codec "
"オブジェクトを操作するインタフェースを定義する一連の基底クラスを定義します。このモジュールは、カスタムの codec "
"の実装の基礎として使用することもできます。"

#: ../../library/codecs.rst:280
msgid ""
"Each codec has to define four interfaces to make it usable as codec in "
"Python: stateless encoder, stateless decoder, stream reader and stream "
"writer. The stream reader and writers typically reuse the stateless "
"encoder/decoder to implement the file protocols. Codec authors also need to "
"define how the codec will handle encoding and decoding errors."
msgstr ""
"Python で codec として使えるようにするには、ステートレスエンコーダ、ステートレスデコーダ、ストリームリーダ、ストリームライタの 4 "
"つのインタフェースを定義する必要があります。通常は、ストリームリーダとライタはステートレスエンコーダとデコーダを再利用して、ファイルプロトコルを実装します。codec"
" の作者は、codec がエンコードとデコードのエラーの処理方法も定義する必要があります。"

#: ../../library/codecs.rst:291
msgid "Error Handlers"
msgstr "エラーハンドラ"

#: ../../library/codecs.rst:293
msgid ""
"To simplify and standardize error handling, codecs may implement different "
"error handling schemes by accepting the *errors* string argument.  The "
"following string values are defined and implemented by all standard Python "
"codecs:"
msgstr ""
"エラー処理の簡便化と標準化のため、コーデックは、*errors* "
"文字列引数を指定した場合に別のエラー処理を行うような仕組みを実装してもかまいません。全ての標準 Python codec "
"では以下の文字列が定義され、実装されています:"

#: ../../library/codecs.rst:301 ../../library/codecs.rst:316
#: ../../library/codecs.rst:349
msgid "Value"
msgstr "値"

#: ../../library/codecs.rst:301 ../../library/codecs.rst:316
#: ../../library/codecs.rst:349
msgid "Meaning"
msgstr "意味"

#: ../../library/codecs.rst:303
msgid "``'strict'``"
msgstr "``'strict'``"

#: ../../library/codecs.rst:303
msgid ""
"Raise :exc:`UnicodeError` (or a subclass); this is the default.  Implemented"
" in :func:`strict_errors`."
msgstr ""
":exc:`UnicodeError` (または、そのサブクラス) を送出します。これがデフォルトの動作です。 "
":func:`strict_errors` で実装されています。"

#: ../../library/codecs.rst:307
msgid "``'ignore'``"
msgstr "``'ignore'``"

#: ../../library/codecs.rst:307
msgid ""
"Ignore the malformed data and continue without further notice.  Implemented "
"in :func:`ignore_errors`."
msgstr "不正な形式のデータを無視し、何も通知することなく処理を継続します。:func:`ignore_errors` で実装されています。"

#: ../../library/codecs.rst:312
msgid ""
"The following error handlers are only applicable to :term:`text encodings "
"<text encoding>`:"
msgstr "以下のエラーハンドラは、 :term:`テキストエンコーディング <text encoding>` にのみ適用されます。"

#: ../../library/codecs.rst:318
msgid "``'replace'``"
msgstr "``'replace'``"

#: ../../library/codecs.rst:318
msgid ""
"Replace with a suitable replacement marker; Python will use the official "
"``U+FFFD`` REPLACEMENT CHARACTER for the built-in codecs on decoding, and "
"'?' on encoding.  Implemented in :func:`replace_errors`."
msgstr ""
"適当な置換マーカーで置換します。Python では、組み込み codec のデコード時には公式の ``U+FFFD`` 代替文字が、エンコード時には "
"'?' が使用されます。 :func:`replace_errors` で実装されています。"

#: ../../library/codecs.rst:325
msgid "``'xmlcharrefreplace'``"
msgstr "``'xmlcharrefreplace'``"

#: ../../library/codecs.rst:325
msgid ""
"Replace with the appropriate XML character reference (only for encoding).  "
"Implemented in :func:`xmlcharrefreplace_errors`."
msgstr ""
"適切な XML 文字参照で置換します (エンコードのみ)。 :func:`xmlcharrefreplace_errors` で実装されています。"

#: ../../library/codecs.rst:329
msgid "``'backslashreplace'``"
msgstr "``'backslashreplace'``"

#: ../../library/codecs.rst:329
msgid ""
"Replace with backslashed escape sequences. Implemented in "
":func:`backslashreplace_errors`."
msgstr ""
"バックスラッシュつきのエスケープシーケンスで置換します。 :func:`backslashreplace_errors` で実装されています。"

#: ../../library/codecs.rst:333
msgid "``'namereplace'``"
msgstr "``'namereplace'``"

#: ../../library/codecs.rst:333
msgid ""
"Replace with ``\\N{...}`` escape sequences (only for encoding).  Implemented"
" in :func:`namereplace_errors`."
msgstr ""
"``\\N{...}`` エスケープシーケンスで置換します (エンコードのみ)。 :func:`namereplace_errors` "
"で実装されています。"

#: ../../library/codecs.rst:337
msgid "``'surrogateescape'``"
msgstr "``'surrogateescape'``"

#: ../../library/codecs.rst:337
msgid ""
"On decoding, replace byte with individual surrogate code ranging from "
"``U+DC80`` to ``U+DCFF``.  This code will then be turned back into the same "
"byte when the ``'surrogateescape'`` error handler is used when encoding the "
"data.  (See :pep:`383` for more.)"
msgstr ""
"デコード時には、バイト列を ``U+DC80`` から ``U+DCFF`` の範囲の個々のサロゲートコードで置き換えます。データのエンコード時に "
"``'surrogateescape'`` エラーハンドラが使用されると、このコードは同じバイト列に戻されます。 (詳しくは :pep:`383` "
"を参照。)"

#: ../../library/codecs.rst:346
msgid ""
"In addition, the following error handler is specific to the given codecs:"
msgstr "さらに、次のエラーハンドラは与えられた codec に特有です:"

#: ../../library/codecs.rst:349
msgid "Codecs"
msgstr "Codecs"

#: ../../library/codecs.rst:351
msgid "``'surrogatepass'``"
msgstr "``'surrogatepass'``"

#: ../../library/codecs.rst:351
msgid "utf-8, utf-16, utf-32, utf-16-be, utf-16-le, utf-32-be, utf-32-le"
msgstr "utf-8, utf-16, utf-32, utf-16-be, utf-16-le, utf-32-be, utf-32-le"

#: ../../library/codecs.rst:351
msgid ""
"Allow encoding and decoding of surrogate codes.  These codecs normally treat"
" the presence of surrogates as an error."
msgstr "サロゲートコードのエンコードとデコードを許可します。通常、これらの codecc は、サロゲートの存在をエラーとして扱います。"

#: ../../library/codecs.rst:356
msgid "The ``'surrogateescape'`` and ``'surrogatepass'`` error handlers."
msgstr "``'surrogateescape'`` および ``'surrogatepass'`` エラーハンドラ。"

#: ../../library/codecs.rst:359
msgid ""
"The ``'surrogatepass'`` error handlers now works with utf-16\\* and "
"utf-32\\* codecs."
msgstr ""
"``'surrogatepass'`` エラーハンドラは utf-16\\* コーデックと utf-32\\* コーデックで動作するようになりました。"

#: ../../library/codecs.rst:362
msgid "The ``'namereplace'`` error handler."
msgstr "``'namereplace'`` エラーハンドラです。"

#: ../../library/codecs.rst:365
msgid ""
"The ``'backslashreplace'`` error handlers now works with decoding and "
"translating."
msgstr "``'backslashreplace'`` エラーハンドラは、デコード時と翻訳時に動作するようになりました。"

#: ../../library/codecs.rst:369
msgid ""
"The set of allowed values can be extended by registering a new named error "
"handler:"
msgstr "次のように、名前付きの新しいエラーハンドラを登録することで、許可される値の集合を拡張することができます。"

#: ../../library/codecs.rst:374
msgid ""
"Register the error handling function *error_handler* under the name *name*. "
"The *error_handler* argument will be called during encoding and decoding in "
"case of an error, when *name* is specified as the errors parameter."
msgstr ""
"エラーハンドラ *error_handler* を名前 *name* で登録します。エンコード中およびデコード中にエラーが送出された場合、*name* "
"が errors 引数として指定されていれば *error_handler* が呼び出されます。"

#: ../../library/codecs.rst:378
msgid ""
"For encoding, *error_handler* will be called with a "
":exc:`UnicodeEncodeError` instance, which contains information about the "
"location of the error. The error handler must either raise this or a "
"different exception, or return a tuple with a replacement for the "
"unencodable part of the input and a position where encoding should continue."
" The replacement may be either :class:`str` or :class:`bytes`.  If the "
"replacement is bytes, the encoder will simply copy them into the output "
"buffer. If the replacement is a string, the encoder will encode the "
"replacement.  Encoding continues on original input at the specified "
"position. Negative position values will be treated as being relative to the "
"end of the input string. If the resulting position is out of bound an "
":exc:`IndexError` will be raised."
msgstr ""
"*error_handler* はエラーの場所に関する情報の入った :exc:`UnicodeEncodeError` "
"インスタンスとともに呼び出されます。エラー処理関数はこの例外を送出するか、別の例外を送出するか、入力のエンコードできなかった部分の代替文字列とエンコードを再開する場所が入ったタプルを返す必要があります。代替文字列は"
" :class:`str` または :class:`bytes` "
"のいずれかにすることができます。代替文字列がバイト列である場合、エンコーダは単に出力バッファにそれをコピーします。代替文字列が文字列である場合、エンコーダは代替文字列をエンコードします。元の入力中の指定位置からエンコードが再開されます。位置を負の値にすると、入力文字列の末端からの相対位置として扱われます。境界の外側にある位置を返した場合には"
" :exc:`IndexError` が送出されます。"

#: ../../library/codecs.rst:390
msgid ""
"Decoding and translating works similarly, except :exc:`UnicodeDecodeError` "
"or :exc:`UnicodeTranslateError` will be passed to the handler and that the "
"replacement from the error handler will be put into the output directly."
msgstr ""
"デコードと翻訳の動作は似ていますが、エラーハンドラに渡されるのが :exc:`UnicodeDecodeError` か "
":exc:`UnicodeTranslateError` である点と、エラーハンドラの置換した内容が直接出力されるという点が異なります。"

#: ../../library/codecs.rst:395
msgid ""
"Previously registered error handlers (including the standard error handlers)"
" can be looked up by name:"
msgstr "登録済みのエラーハンドラ (標準エラーハンドラを含む) は、次のようにその名前で検索することができます。"

#: ../../library/codecs.rst:400
msgid "Return the error handler previously registered under the name *name*."
msgstr "名前 *name* で登録済みのエラーハンドラを返します。"

#: ../../library/codecs.rst:402
msgid "Raises a :exc:`LookupError` in case the handler cannot be found."
msgstr "エラーハンドラが見つからなければ :exc:`LookupError` を送出します。"

#: ../../library/codecs.rst:404
msgid ""
"The following standard error handlers are also made available as module "
"level functions:"
msgstr "以下の標準エラーハンドラも、モジュールレベルの関数として利用できます。"

#: ../../library/codecs.rst:409
msgid ""
"Implements the ``'strict'`` error handling: each encoding or decoding error "
"raises a :exc:`UnicodeError`."
msgstr ""
"``strict`` エラー処理を実装します。エンコードエラーまたはデコードエラーはそれぞれ :exc:`UnicodeError` を送出します。"

#: ../../library/codecs.rst:415
msgid ""
"Implements the ``'replace'`` error handling (for :term:`text encodings <text"
" encoding>` only): substitutes ``'?'`` for encoding errors (to be encoded by"
" the codec), and ``'\\ufffd'`` (the Unicode replacement character) for "
"decoding errors."
msgstr ""
"``'replace'`` エラー処理を実装します ( :term:`テキストエンコーディング <text encoding>` のみ)。(codec "
"によりエンコードする必要のある) エンコードエラーに対しては ``'?'`` に、デコードエラーに対しては ``'\\ufffd'`` (Unicode"
" 代替文字) に置き換えます。"

#: ../../library/codecs.rst:423
msgid ""
"Implements the ``'ignore'`` error handling: malformed data is ignored and "
"encoding or decoding is continued without further notice."
msgstr "``ignore`` エラー処理を実装します。不正な形式のデータは無視され、エンコードまたはデコードは何も通知することなく継続されます。"

#: ../../library/codecs.rst:429
msgid ""
"Implements the ``'xmlcharrefreplace'`` error handling (for encoding with "
":term:`text encodings <text encoding>` only): the unencodable character is "
"replaced by an appropriate XML character reference."
msgstr ""
"``'xmlcharrefreplace'`` エラー処理を実装します ( :term:`テキストエンコーディング <text encoding>` "
"のエンコードのみ)。エンコードできない文字は、適切な XML 文字参照に置き換えます。"

#: ../../library/codecs.rst:436
msgid ""
"Implements the ``'backslashreplace'`` error handling (for :term:`text "
"encodings <text encoding>` only): malformed data is replaced by a "
"backslashed escape sequence."
msgstr ""
"``'backslashreplace'`` エラー処理を実装します ( :term:`テキストエンコーディング <text encoding>` "
"のエンコードのみ)。不正な形式のデータは、バックスラッシュ付きのエスケープシーケンスに置き換えます。"

#: ../../library/codecs.rst:442
msgid ""
"Implements the ``'namereplace'`` error handling (for encoding with "
":term:`text encodings <text encoding>` only): the unencodable character is "
"replaced by a ``\\N{...}`` escape sequence."
msgstr ""
"``'namereplace'`` エラー処理を実装します ( :term:`テキストエンコーディング <text encoding>` "
"のエンコードのみ)。エンコードできない文字は、``\\N{...}`` エスケープシーケンスに置き換えます。"

#: ../../library/codecs.rst:452
msgid "Stateless Encoding and Decoding"
msgstr "ステートレスなエンコードとデコード"

#: ../../library/codecs.rst:454
msgid ""
"The base :class:`Codec` class defines these methods which also define the "
"function interfaces of the stateless encoder and decoder:"
msgstr ""
"基底の :class:`Codec` "
"クラスは以下のメソッドを定義します。これらのメソッドは、内部状態を持たないエンコーダ／デコーダ関数のインタフェースを定義します:"

#: ../../library/codecs.rst:460
msgid ""
"Encodes the object *input* and returns a tuple (output object, length "
"consumed). For instance, :term:`text encoding` converts a string object to a"
" bytes object using a particular character set encoding (e.g., ``cp1252`` or"
" ``iso-8859-1``)."
msgstr ""
"オブジェクト *input* エンコードし、(出力オブジェクト, 消費した長さ) のタプルを返します。例えば、 :term:`テキストエンコーディング "
"<text encoding>` は文字列オブジェクトを特有の文字セット (例えば ``cp1252`` や ``iso-8859-1``) "
"を用いてバイト列オブジェクトに変換します。"

#: ../../library/codecs.rst:465 ../../library/codecs.rst:487
msgid ""
"The *errors* argument defines the error handling to apply. It defaults to "
"``'strict'`` handling."
msgstr "*errors* 引数は適用するエラー処理を定義します。``'strict'`` 処理がデフォルトです。"

#: ../../library/codecs.rst:468
msgid ""
"The method may not store state in the :class:`Codec` instance. Use "
":class:`StreamWriter` for codecs which have to keep state in order to make "
"encoding efficient."
msgstr ""
"このメソッドは :class:`Codec` に内部状態を保存してはなりません。効率よくエンコードするために状態を保持しなければならないような "
"codecs には :class:`StreamWriter` を使ってください。"

#: ../../library/codecs.rst:472
msgid ""
"The encoder must be able to handle zero length input and return an empty "
"object of the output object type in this situation."
msgstr "エンコーダは長さが 0 の入力を処理できなければなりません。この場合、空のオブジェクトを出力オブジェクトとして返さなければなりません。"

#: ../../library/codecs.rst:478
msgid ""
"Decodes the object *input* and returns a tuple (output object, length "
"consumed).  For instance, for a :term:`text encoding`, decoding converts a "
"bytes object encoded using a particular character set encoding to a string "
"object."
msgstr ""
"オブジェクト *input* をデコードし、(出力オブジェクト, 消費した長さ) のタプルを返します。例えば、 :term:`テキストエンコーディング "
"<text encoding>` は、特定の文字集合エンコーディングでエンコードされたバイト列オブジェクトを文字列オブジェクトに変換します。"

#: ../../library/codecs.rst:483
msgid ""
"For text encodings and bytes-to-bytes codecs, *input* must be a bytes object"
" or one which provides the read-only buffer interface -- for example, buffer"
" objects and memory mapped files."
msgstr ""
"テキストエンコーディングとバイト列からバイト列への codec では、*input* は bytes "
"オブジェクト、または読み出し専用のバッファインタフェースを提供するオブジェクトである必要があります。例えば、buffer "
"オブジェクトやメモリマップドファイルでなければなりません。"

#: ../../library/codecs.rst:490
msgid ""
"The method may not store state in the :class:`Codec` instance. Use "
":class:`StreamReader` for codecs which have to keep state in order to make "
"decoding efficient."
msgstr ""
"このメソッドは、 :class:`Codec` "
"インスタンスに内部状態を保存してはなりません。効率よくエンコード／デコードするために状態を保持しなければならないような codecs には "
":class:`StreamReader` を使ってください。"

#: ../../library/codecs.rst:494
msgid ""
"The decoder must be able to handle zero length input and return an empty "
"object of the output object type in this situation."
msgstr "デコーダは長さが 0 の入力を処理できなければなりません。この場合、空のオブジェクトを出力オブジェクトとして返さなければなりません。"

#: ../../library/codecs.rst:499
msgid "Incremental Encoding and Decoding"
msgstr "インクリメンタルなエンコードとデコード"

#: ../../library/codecs.rst:501
msgid ""
"The :class:`IncrementalEncoder` and :class:`IncrementalDecoder` classes "
"provide the basic interface for incremental encoding and decoding. "
"Encoding/decoding the input isn't done with one call to the stateless "
"encoder/decoder function, but with multiple calls to the "
":meth:`~IncrementalEncoder.encode`/:meth:`~IncrementalDecoder.decode` method"
" of the incremental encoder/decoder. The incremental encoder/decoder keeps "
"track of the encoding/decoding process during method calls."
msgstr ""
":class:`IncrementalEncoder` クラスおよび :class:`IncrementalDecoder` "
"クラスはそれぞれインクリメンタル・エンコードおよびデコードのための基本的なインタフェースを提供します。エンコード／デコードは内部状態を持たないエンコーダ／デコーダを一度呼び出すことで行なわれるのではなく、インクリメンタル・エンコーダ／デコーダの"
" :meth:`~IncrementalEncoder.encode`/:meth:`~IncrementalDecoder.decode` "
"メソッドを複数回呼び出すことで行なわれます。インクリメンタル・エンコーダ／デコーダはメソッド呼び出しの間エンコード／デコード処理の進行を管理します。"

#: ../../library/codecs.rst:509
msgid ""
"The joined output of calls to the "
":meth:`~IncrementalEncoder.encode`/:meth:`~IncrementalDecoder.decode` method"
" is the same as if all the single inputs were joined into one, and this "
"input was encoded/decoded with the stateless encoder/decoder."
msgstr ""
":meth:`~IncrementalEncoder.encode`/:meth:`~IncrementalDecoder.decode` "
"メソッド呼び出しの出力結果をまとめたものは、入力をひとまとめにして内部状態を持たないエンコーダ／デコーダでエンコード／デコードしたものと同じになります。"

#: ../../library/codecs.rst:518
msgid "IncrementalEncoder Objects"
msgstr "IncrementalEncoder オブジェクト"

#: ../../library/codecs.rst:520
msgid ""
"The :class:`IncrementalEncoder` class is used for encoding an input in "
"multiple steps. It defines the following methods which every incremental "
"encoder must define in order to be compatible with the Python codec "
"registry."
msgstr ""
":class:`IncrementalEncoder` クラスは入力を複数ステップでエンコードするのに使われます。全てのインクリメンタル・エンコーダが "
"Python codec レジストリと互換性を持つために定義すべきメソッドとして、このクラスには以下のメソッドが定義されています。"

#: ../../library/codecs.rst:527
msgid "Constructor for an :class:`IncrementalEncoder` instance."
msgstr ":class:`IncrementalEncoder` インスタンスのコンストラクタ。"

#: ../../library/codecs.rst:529
msgid ""
"All incremental encoders must provide this constructor interface. They are "
"free to add additional keyword arguments, but only the ones defined here are"
" used by the Python codec registry."
msgstr ""
"全てのインクリメンタル・エンコーダはこのコンストラクタインタフェースを提供しなければなりません。さらにキーワード引数を付け加えるのは構いませんが、Python"
" codec レジストリで利用されるのはここで定義されているものだけです。"

#: ../../library/codecs.rst:533
msgid ""
"The :class:`IncrementalEncoder` may implement different error handling "
"schemes by providing the *errors* keyword argument. See :ref:`error-"
"handlers` for possible values."
msgstr ""
":class:`IncrementalEncoder` は、 *errors* "
"キーワード引数を提供することで、様々なエラー取扱方法を実装することができます。取り得る値については :ref:`error-handlers` "
"を参照してください。"

#: ../../library/codecs.rst:537
msgid ""
"The *errors* argument will be assigned to an attribute of the same name. "
"Assigning to this attribute makes it possible to switch between different "
"error handling strategies during the lifetime of the "
":class:`IncrementalEncoder` object."
msgstr ""
"*errors* 引数は、同名の属性に代入されます。この属性を変更すると、 :class:`IncrementalEncoder` "
"オブジェクトが生きている間に、異なるエラー処理方法に切り替えることができるようになります。"

#: ../../library/codecs.rst:545
msgid ""
"Encodes *object* (taking the current state of the encoder into account) and "
"returns the resulting encoded object. If this is the last call to "
":meth:`encode` *final* must be true (the default is false)."
msgstr ""
"*object* を(エンコーダの現在の状態を考慮に入れて)エンコードし、得られたエンコードされたオブジェクトを返します。 :meth:`encode`"
" 呼び出しがこれで最後という時には *final* は真でなければなりません(デフォルトは偽です)。"

#: ../../library/codecs.rst:552
msgid ""
"Reset the encoder to the initial state. The output is discarded: call "
"``.encode(object, final=True)``, passing an empty byte or text string if "
"necessary, to reset the encoder and to get the output."
msgstr ""
"エンコーダを初期状態にリセットします。出力は破棄されます。``.encode(object, final=True)`` "
"を呼び出して、必要に応じて空バイト列またはテキスト文字列を渡すことにより、エンコーダをリセットし、出力を取得します。"

#: ../../library/codecs.rst:559
msgid ""
"Return the current state of the encoder which must be an integer. The "
"implementation should make sure that ``0`` is the most common state. (States"
" that are more complicated than integers can be converted into an integer by"
" marshaling/pickling the state and encoding the bytes of the resulting "
"string into an integer)."
msgstr ""
"エンコーダの現在の状態を返します。それは必ず整数でなければなりません。実装は、``0`` が最も一般的な状態であることを保証すべきです "
"(整数より複雑な状態は、状態を marshal/pickle して生じた文字列のバイトを整数にコード化することによって整数に変換することができます)。"

#: ../../library/codecs.rst:568
msgid ""
"Set the state of the encoder to *state*. *state* must be an encoder state "
"returned by :meth:`getstate`."
msgstr ""
"エンコーダの状態を *state* にセットします。 *state* は :meth:`getstate` "
"によって返されたエンコーダ状態でなければなりません。"

#: ../../library/codecs.rst:575
msgid "IncrementalDecoder Objects"
msgstr "IncrementalDecoder オブジェクト"

#: ../../library/codecs.rst:577
msgid ""
"The :class:`IncrementalDecoder` class is used for decoding an input in "
"multiple steps. It defines the following methods which every incremental "
"decoder must define in order to be compatible with the Python codec "
"registry."
msgstr ""
":class:`IncrementalDecoder` クラスは入力を複数ステップでデコードするのに使われます。全てのインクリメンタル・デコーダが "
"Python codec レジストリと互換性を持つために定義すべきメソッドとして、このクラスには以下のメソッドが定義されています。"

#: ../../library/codecs.rst:584
msgid "Constructor for an :class:`IncrementalDecoder` instance."
msgstr ":class:`IncrementalDecoder` インスタンスのコンストラクタ。"

#: ../../library/codecs.rst:586
msgid ""
"All incremental decoders must provide this constructor interface. They are "
"free to add additional keyword arguments, but only the ones defined here are"
" used by the Python codec registry."
msgstr ""
"全てのインクリメンタル・デコーダはこのコンストラクタインタフェースを提供しなければなりません。さらにキーワード引数を付け加えるのは構いませんが、Python"
" codec レジストリで利用されるのはここで定義されているものだけです。"

#: ../../library/codecs.rst:590
msgid ""
"The :class:`IncrementalDecoder` may implement different error handling "
"schemes by providing the *errors* keyword argument. See :ref:`error-"
"handlers` for possible values."
msgstr ""
":class:`IncrementalDecoder` は、 *errors* "
"キーワード引数を提供することで、様々なエラー取扱方法を実装することができます。取り得る値については :ref:`error-handlers` "
"を参照してください。"

#: ../../library/codecs.rst:594
msgid ""
"The *errors* argument will be assigned to an attribute of the same name. "
"Assigning to this attribute makes it possible to switch between different "
"error handling strategies during the lifetime of the "
":class:`IncrementalDecoder` object."
msgstr ""
"*errors* 引数は、同名の属性に代入されます。この属性を変更すると、 :class:`IncrementalDecoder` "
"オブジェクトが生きている間に、異なるエラー処理方法に切り替えることができるようになります。"

#: ../../library/codecs.rst:602
msgid ""
"Decodes *object* (taking the current state of the decoder into account) and "
"returns the resulting decoded object. If this is the last call to "
":meth:`decode` *final* must be true (the default is false). If *final* is "
"true the decoder must decode the input completely and must flush all "
"buffers. If this isn't possible (e.g. because of incomplete byte sequences "
"at the end of the input) it must initiate error handling just like in the "
"stateless case (which might raise an exception)."
msgstr ""
"*object* を(デコーダの現在の状態を考慮に入れて)デコードし、得られたデコードされたオブジェクトを返します。 :meth:`decode` "
"呼び出しがこれで最後という時には *final* は真でなければなりません(デフォルトは偽です)。もし *final* "
"が真ならばデコーダは入力をデコードし切り全てのバッファをフラッシュしなければなりません。そうできない場合(たとえば入力の最後に不完全なバイト列があるから)、デコーダは内部状態を持たない場合と同じようにエラーの取り扱いを開始しなければなりません(例外を送出するかもしれません)。"

#: ../../library/codecs.rst:613
msgid "Reset the decoder to the initial state."
msgstr "デコーダを初期状態にリセットします。"

#: ../../library/codecs.rst:618
msgid ""
"Return the current state of the decoder. This must be a tuple with two "
"items, the first must be the buffer containing the still undecoded input. "
"The second must be an integer and can be additional state info. (The "
"implementation should make sure that ``0`` is the most common additional "
"state info.) If this additional state info is ``0`` it must be possible to "
"set the decoder to the state which has no input buffered and ``0`` as the "
"additional state info, so that feeding the previously buffered input to the "
"decoder returns it to the previous state without producing any output. "
"(Additional state info that is more complicated than integers can be "
"converted into an integer by marshaling/pickling the info and encoding the "
"bytes of the resulting string into an integer.)"
msgstr ""
"デコーダの現在の状態を返します。これは2要素を含むタプルでなければなりません。1番目はまだデコードされていない入力を含むバッファです。2番目は整数で、付加的な状態情報です"
" (実装は ``0`` が最も一般的な付加的な状態情報であることを保証すべきです)。この付加的な状態情報が ``0`` "
"である場合、デコーダを入力がバッファされていない状態に戻して、付加的な状態情報を ``0`` "
"にセットすることが可能でなければなりません。その結果、以前バッファされた入力をデコーダに与えることで、何の出力もせずにデコーダを前の状態に戻します。 "
"(整数より複雑な付加的な状態情報は、情報を marshal/pickle "
"して、結果として生じる文字列のバイト列を整数にエンコードすることで、整数に変換することができます。)"

#: ../../library/codecs.rst:633
msgid ""
"Set the state of the encoder to *state*. *state* must be a decoder state "
"returned by :meth:`getstate`."
msgstr ""
"エンコーダ (訳注: デコーダの間違い?) の状態を *state* にセットします。 *state* は :meth:`getstate` "
"によって返されたデコーダ状態でなければなりません。"

#: ../../library/codecs.rst:638
msgid "Stream Encoding and Decoding"
msgstr "ストリームのエンコードとデコード"

#: ../../library/codecs.rst:641
msgid ""
"The :class:`StreamWriter` and :class:`StreamReader` classes provide generic "
"working interfaces which can be used to implement new encoding submodules "
"very easily. See :mod:`encodings.utf_8` for an example of how this is done."
msgstr ""
":class:`StreamWriter` と :class:`StreamReader` "
"クラスは、新しいエンコーディングサブモジュールを非常に簡単に実装するのに使用できる、一般的なインターフェイスを提供します。実装例は "
":mod:`encodings.utf_8` をご覧ください。"

#: ../../library/codecs.rst:649
msgid "StreamWriter Objects"
msgstr "StreamWriter オブジェクト"

#: ../../library/codecs.rst:651
msgid ""
"The :class:`StreamWriter` class is a subclass of :class:`Codec` and defines "
"the following methods which every stream writer must define in order to be "
"compatible with the Python codec registry."
msgstr ""
":class:`StreamWriter` クラスは :class:`Codec` "
"のサブクラスで、以下のメソッドを定義しています。全てのストリームライタは、 Python の codec "
"レジストリとの互換性を保つために、これらのメソッドを定義する必要があります。"

#: ../../library/codecs.rst:658
msgid "Constructor for a :class:`StreamWriter` instance."
msgstr ":class:`StreamWriter` インスタンスのコンストラクタです。"

#: ../../library/codecs.rst:660
msgid ""
"All stream writers must provide this constructor interface. They are free to"
" add additional keyword arguments, but only the ones defined here are used "
"by the Python codec registry."
msgstr ""
"全てのストリームライタはコンストラクタとしてこのインタフェースを提供しなければなりません。キーワード引数を追加しても構いませんが、Python の "
"codec レジストリはここで定義されている引数だけを使います。"

#: ../../library/codecs.rst:664
msgid ""
"The *stream* argument must be a file-like object open for writing text or "
"binary data, as appropriate for the specific codec."
msgstr ""
"*stream* 引数は、特定の codec に対応して、テキストまたはバイナリデータの書き込みが可能なファイルライクオブジェクトである必要があります。"

#: ../../library/codecs.rst:667
msgid ""
"The :class:`StreamWriter` may implement different error handling schemes by "
"providing the *errors* keyword argument. See :ref:`error-handlers` for the "
"standard error handlers the underlying stream codec may support."
msgstr ""
":class:`StreamWriter` は、 *errors* "
"キーワード引数を提供することで、様々なエラー取扱方法を実装することができます。下層のストリーム codec がサポートできる標準エラーハンドラについては"
" :ref:`error-handlers` を参照してください。"

#: ../../library/codecs.rst:671
msgid ""
"The *errors* argument will be assigned to an attribute of the same name. "
"Assigning to this attribute makes it possible to switch between different "
"error handling strategies during the lifetime of the :class:`StreamWriter` "
"object."
msgstr ""
"*errors* 引数は、同名の属性に代入されます。この属性を変更すると、 :class:`StreamWriter` "
"オブジェクトが生きている間に、異なるエラー処理に変更できます。"

#: ../../library/codecs.rst:677
msgid "Writes the object's contents encoded to the stream."
msgstr "*object* の内容をエンコードしてストリームに書き出します。"

#: ../../library/codecs.rst:682
msgid ""
"Writes the concatenated list of strings to the stream (possibly by reusing "
"the :meth:`write` method). The standard bytes-to-bytes codecs do not support"
" this method."
msgstr ""
"文字列からなるリストを連結して、ストリームに書き出します (可能な場合には :meth:`write` を再利用します) 。バイト列からバイト列への標準"
" codecs は、このメソッドをサポートしません。"

#: ../../library/codecs.rst:689
msgid "Flushes and resets the codec buffers used for keeping state."
msgstr "状態保持に使われていた codec のバッファを強制的に出力してリセットします。"

#: ../../library/codecs.rst:691
msgid ""
"Calling this method should ensure that the data on the output is put into a "
"clean state that allows appending of new fresh data without having to rescan"
" the whole stream to recover state."
msgstr ""
"このメソッドが呼び出された場合、出力先データをきれいな状態にし、わざわざストリーム全体を再スキャンして状態を元に戻さなくても新しくデータを追加できるようにしなければなりません。"

#: ../../library/codecs.rst:696
msgid ""
"In addition to the above methods, the :class:`StreamWriter` must also "
"inherit all other methods and attributes from the underlying stream."
msgstr ""
"ここまでで挙げたメソッドの他にも、 :class:`StreamWriter` "
"では背後にあるストリームの他の全てのメソッドや属性を継承しなければなりません。"

#: ../../library/codecs.rst:703
msgid "StreamReader Objects"
msgstr "StreamReader オブジェクト"

#: ../../library/codecs.rst:705
msgid ""
"The :class:`StreamReader` class is a subclass of :class:`Codec` and defines "
"the following methods which every stream reader must define in order to be "
"compatible with the Python codec registry."
msgstr ""
":class:`StreamReader` クラスは :class:`Codec` "
"のサブクラスで、以下のメソッドを定義しています。全てのストリームリーダは、 Python の codec "
"レジストリとの互換性を保つために、これらのメソッドを定義する必要があります。"

#: ../../library/codecs.rst:712
msgid "Constructor for a :class:`StreamReader` instance."
msgstr ":class:`StreamReader` インスタンスのコンストラクタです。"

#: ../../library/codecs.rst:714
msgid ""
"All stream readers must provide this constructor interface. They are free to"
" add additional keyword arguments, but only the ones defined here are used "
"by the Python codec registry."
msgstr ""
"全てのストリームリーダはコンストラクタとしてこのインタフェースを提供しなければなりません。キーワード引数を追加しても構いませんが、Python の "
"codec レジストリはここで定義されている引数だけを使います。"

#: ../../library/codecs.rst:718
msgid ""
"The *stream* argument must be a file-like object open for reading text or "
"binary data, as appropriate for the specific codec."
msgstr ""
"*stream* 引数は、特定の codec に対応して、テキストまたはバイナリデータの読み出しが可能なファイルライクオブジェクトである必要があります。"

#: ../../library/codecs.rst:721
msgid ""
"The :class:`StreamReader` may implement different error handling schemes by "
"providing the *errors* keyword argument. See :ref:`error-handlers` for the "
"standard error handlers the underlying stream codec may support."
msgstr ""
":class:`StreamReader` は、 *errors* "
"キーワード引数を提供することで、様々なエラー取扱方法を実装することができます。下層のストリーム codec がサポートできる標準エラーハンドラについては"
" :ref:`error-handlers` を参照してください。"

#: ../../library/codecs.rst:725
msgid ""
"The *errors* argument will be assigned to an attribute of the same name. "
"Assigning to this attribute makes it possible to switch between different "
"error handling strategies during the lifetime of the :class:`StreamReader` "
"object."
msgstr ""
"*errors* 引数は、同名の属性に代入されます。この属性を変更すると、 :class:`StreamReader` "
"オブジェクトが生きている間に、異なるエラー処理に変更できます。"

#: ../../library/codecs.rst:729
msgid ""
"The set of allowed values for the *errors* argument can be extended with "
":func:`register_error`."
msgstr "*errors* 引数に許される値の集合は :func:`register_error` で拡張できます。"

#: ../../library/codecs.rst:735
msgid "Decodes data from the stream and returns the resulting object."
msgstr "ストリームからのデータをデコードし、デコード済のオブジェクトを返します。"

#: ../../library/codecs.rst:737
msgid ""
"The *chars* argument indicates the number of decoded code points or bytes to"
" return. The :func:`read` method will never return more data than requested,"
" but it might return less, if there is not enough available."
msgstr ""
"*chars* 引数は、いくつのデコードされたコードポイントまたはバイト列を返すかを表します。 :func:`read` "
"メソッドは、要求された数以上のデータを返すことはありませんが、データがそれより少ない場合には要求された数未満のデータを返す場合があります。"

#: ../../library/codecs.rst:742
msgid ""
"The *size* argument indicates the approximate maximum number of encoded "
"bytes or code points to read for decoding. The decoder can modify this "
"setting as appropriate. The default value -1 indicates to read and decode as"
" much as possible.  This parameter is intended to prevent having to decode "
"huge files in one step."
msgstr ""
"*size* "
"引数は、デコード用に読み込むエンコードされたバイト列またはコードポイントの、およその最大バイト数を表します。デコーダはこの値を適切な値に変更できます。デフォルト値"
" -1 の場合、可能な限り多くのデータを読み込みます。この引数の目的は、巨大なファイルの一括デコードを防ぐことにあります。"

#: ../../library/codecs.rst:749
msgid ""
"The *firstline* flag indicates that it would be sufficient to only return "
"the first line, if there are decoding errors on later lines."
msgstr "*firstline* フラグは、1行目さえ返せばその後の行でデコードエラーがあっても無視して十分だ、ということを示します。"

#: ../../library/codecs.rst:753
msgid ""
"The method should use a greedy read strategy meaning that it should read as "
"much data as is allowed within the definition of the encoding and the given "
"size, e.g.  if optional encoding endings or state markers are available on "
"the stream, these should be read too."
msgstr ""
"このメソッドは貪欲な読み込み戦略を取るべきです。すなわち、エンコーディング定義と size "
"の値が許す範囲で、できるだけ多くのデータを読むべきだということです。たとえば、ストリーム上にエンコーディングの終端や状態の目印があれば、それも読み込みます。"

#: ../../library/codecs.rst:761
msgid "Read one line from the input stream and return the decoded data."
msgstr "入力ストリームから1行読み込み、デコード済みのデータを返します。"

#: ../../library/codecs.rst:763
msgid ""
"*size*, if given, is passed as size argument to the stream's :meth:`read` "
"method."
msgstr "*size* が与えられた場合、ストリームの :meth:`read` メソッドに size 引数として渡されます。"

#: ../../library/codecs.rst:766
msgid ""
"If *keepends* is false line-endings will be stripped from the lines "
"returned."
msgstr "*keepends* が偽の場合には行末の改行が削除された行が返ります。"

#: ../../library/codecs.rst:772
msgid ""
"Read all lines available on the input stream and return them as a list of "
"lines."
msgstr "入力ストリームから全ての行を読み込み、行のリストとして返します。"

#: ../../library/codecs.rst:775
msgid ""
"Line-endings are implemented using the codec's decoder method and are "
"included in the list entries if *keepends* is true."
msgstr "*keepends* が真なら、改行は、codec のデコーダメソッドを使って実装され、リスト要素の中に含まれます。"

#: ../../library/codecs.rst:778
msgid ""
"*sizehint*, if given, is passed as the *size* argument to the stream's "
":meth:`read` method."
msgstr "*sizehint* が与えられた場合、ストリームの :meth:`read` メソッドに *size* 引数として渡されます。"

#: ../../library/codecs.rst:784
msgid "Resets the codec buffers used for keeping state."
msgstr "状態保持に使われた codec のバッファをリセットします。"

#: ../../library/codecs.rst:786
msgid ""
"Note that no stream repositioning should take place.  This method is "
"primarily intended to be able to recover from decoding errors."
msgstr "ストリームの読み位置を再設定してはならないので注意してください。このメソッドはデコードの際にエラーから復帰できるようにするためのものです。"

#: ../../library/codecs.rst:790
msgid ""
"In addition to the above methods, the :class:`StreamReader` must also "
"inherit all other methods and attributes from the underlying stream."
msgstr ""
"ここまでで挙げたメソッドの他にも、 :class:`StreamReader` "
"では背後にあるストリームの他の全てのメソッドや属性を継承しなければなりません。"

#: ../../library/codecs.rst:796
msgid "StreamReaderWriter Objects"
msgstr "StreamReaderWriter オブジェクト"

#: ../../library/codecs.rst:798
msgid ""
"The :class:`StreamReaderWriter` is a convenience class that allows wrapping "
"streams which work in both read and write modes."
msgstr ":class:`StreamReaderWriter` は、読み書き両方に使えるストリームをラップできる便利なクラスです。"

#: ../../library/codecs.rst:801 ../../library/codecs.rst:825
msgid ""
"The design is such that one can use the factory functions returned by the "
":func:`lookup` function to construct the instance."
msgstr ":func:`lookup` 関数が返すファクトリ関数を使って、インスタンスを生成するという設計です。"

#: ../../library/codecs.rst:807
msgid ""
"Creates a :class:`StreamReaderWriter` instance. *stream* must be a file-like"
" object. *Reader* and *Writer* must be factory functions or classes "
"providing the :class:`StreamReader` and :class:`StreamWriter` interface "
"resp. Error handling is done in the same way as defined for the stream "
"readers and writers."
msgstr ""
":class:`StreamReaderWriter` インスタンスを生成します。 *stream* はファイル類似のオブジェクトです。 "
"*Reader* と *Writer* は、それぞれ :class:`StreamReader` と :class:`StreamWriter` "
"インタフェースを提供するファクトリ関数かファクトリクラスでなければなりません。エラー処理は、ストリームリーダとライタで定義したものと同じように行われます。"

#: ../../library/codecs.rst:812
msgid ""
":class:`StreamReaderWriter` instances define the combined interfaces of "
":class:`StreamReader` and :class:`StreamWriter` classes. They inherit all "
"other methods and attributes from the underlying stream."
msgstr ""
":class:`StreamReaderWriter` インスタンスは、 :class:`StreamReader` クラスと "
":class:`StreamWriter` クラスを合わせたインタフェースを継承します。元になるストリームからは、他のメソッドや属性を継承します。"

#: ../../library/codecs.rst:820
msgid "StreamRecoder Objects"
msgstr "StreamRecoder オブジェクト"

#: ../../library/codecs.rst:822
msgid ""
"The :class:`StreamRecoder` translates data from one encoding to another, "
"which is sometimes useful when dealing with different encoding environments."
msgstr ""
":class:`StreamRecoder` "
"はデータをあるエンコーディングから別のエンコーディングに変換します。異なるエンコーディング環境を扱うとき、便利な場合があります。"

#: ../../library/codecs.rst:831
msgid ""
"Creates a :class:`StreamRecoder` instance which implements a two-way "
"conversion: *encode* and *decode* work on the frontend — the data visible to"
" code calling :meth:`read` and :meth:`write`, while *Reader* and *Writer* "
"work on the backend — the data in *stream*."
msgstr ""
"双方向変換を実装する :class:`StreamRecoder` インスタンスを生成します。 *encode* と *decode* はフロントエンド"
" (:meth:`read` および :meth:`write` を呼び出すコードから見えるデータ) ではたらき、 *Reader* と "
"*Writer* はバックエンド (*stream* 内のデータ) ではたらきます。"

#: ../../library/codecs.rst:836
msgid ""
"You can use these objects to do transparent transcodings from e.g. Latin-1 "
"to UTF-8 and back."
msgstr "これらのオブジェクトを使って、たとえば、 Latin-1 から UTF-8 への変換、あるいは逆向きの変換を、透過的に行うことができます。"

#: ../../library/codecs.rst:839
msgid "The *stream* argument must be a file-like object."
msgstr "*stream* 引数はファイルライクオブジェクトでなくてはなりません。"

#: ../../library/codecs.rst:841
msgid ""
"The *encode* and *decode* arguments must adhere to the :class:`Codec` "
"interface. *Reader* and *Writer* must be factory functions or classes "
"providing objects of the :class:`StreamReader` and :class:`StreamWriter` "
"interface respectively."
msgstr ""
"*encode* 引数と *decode* 引数は :class:`Codec` のインタフェースに忠実でなくてはなりません。*Reader* と "
"*Writer* は、それぞれ :class:`StreamReader` と :class:`StreamWriter` "
"のインターフェースを提供するオブジェクトのファクトリ関数かクラスでなくてはなりません。"

#: ../../library/codecs.rst:846
msgid ""
"Error handling is done in the same way as defined for the stream readers and"
" writers."
msgstr "エラー処理はストリーム・リーダやライタで定義されている方法と同じように行われます。"

#: ../../library/codecs.rst:850
msgid ""
":class:`StreamRecoder` instances define the combined interfaces of "
":class:`StreamReader` and :class:`StreamWriter` classes. They inherit all "
"other methods and attributes from the underlying stream."
msgstr ""
":class:`StreamRecoder` インスタンスは、 :class:`StreamReader` と "
":class:`StreamWriter` クラスを合わせたインタフェースを定義します。また、元のストリームのメソッドと属性も継承します。"

#: ../../library/codecs.rst:858
msgid "Encodings and Unicode"
msgstr "エンコーディングと Unicode"

#: ../../library/codecs.rst:860
msgid ""
"Strings are stored internally as sequences of code points in range "
"``0x0``--``0x10FFFF``.  (See :pep:`393` for more details about the "
"implementation.) Once a string object is used outside of CPU and memory, "
"endianness and how these arrays are stored as bytes become an issue.  As "
"with other codecs, serialising a string into a sequence of bytes is known as"
" *encoding*, and recreating the string from the sequence of bytes is known "
"as *decoding*. There are a variety of different text serialisation codecs, "
"which are collectivity referred to as :term:`text encodings <text "
"encoding>`."
msgstr ""
"文字列は内部的に ``0x0``--``0x10FFFF`` の範囲のコードポイントのシーケンスとして格納されます (実装に関する詳細については :pep:`393` を参照してください)。\n"
"文字列オブジェクトが CPU とメモリの外で使用されるようになると、エンディアンやこれらの配列をバイト列として格納する方法が問題になります。\n"
"他のコーデックでも同様ですが、文字列オブジェクトをバイト列に変換することは *エンコード* と呼ばれます。\n"
"また、バイト列から文字列オブジェクトを再生成することは *デコード* と呼ばれます。\n"
"テキストをシリアライズするコーデックには多くの種類があります。\n"
"それらは、集合的に term:`テキストエンコーディング <text encoding>` と呼ばれます。"

#: ../../library/codecs.rst:870
msgid ""
"The simplest text encoding (called ``'latin-1'`` or ``'iso-8859-1'``) maps "
"the code points 0--255 to the bytes ``0x0``--``0xff``, which means that a "
"string object that contains code points above ``U+00FF`` can't be encoded "
"with this codec. Doing so will raise a :exc:`UnicodeEncodeError` that looks "
"like the following (although the details of the error message may differ): "
"``UnicodeEncodeError: 'latin-1' codec can't encode character '\\u1234' in "
"position 3: ordinal not in range(256)``."
msgstr ""
"最も単純なテキストエンコーディング (``'latin-1'`` または ``'iso-8859-1'``) では、0--255 の範囲にあるコードポイントを ``0x0``--``0xff`` のバイトにマップします。\n"
"つまり、この codec では ``U+00FF`` 以上のコードポイントを含む文字列オブジェクトをエンコードすることはできません。\n"
"このようなエンコード処理をしようとすると、次のように :exc:`UnicodeEncodeError` が送出されます (エラーメッセージの細かところは異なる場合があります。): ``UnicodeEncodeError: 'latin-1' codec can't encode character '\\u1234' in position 3: ordinal not in range(256)`` 。"

#: ../../library/codecs.rst:878
msgid ""
"There's another group of encodings (the so called charmap encodings) that "
"choose a different subset of all Unicode code points and how these code "
"points are mapped to the bytes ``0x0``--``0xff``. To see how this is done "
"simply open e.g. :file:`encodings/cp1252.py` (which is an encoding that is "
"used primarily on Windows). There's a string constant with 256 characters "
"that shows you which character is mapped to which byte value."
msgstr ""
"他のエンコーディングの一群 (charmap エンコーディングと呼ばれます) があり、 Unicode コードポイントの別の部分集合と、それらから ``0x0``--``0xff`` のバイトへの対応付けを選択したものです。\n"
"これがどのように行なわれるかを知るには、単にたとえば :file:`encodings/cp1252.py` (主に Windows で使われるエンコーディングです) を開いてみてください。\n"
"256 文字のひとつの文字列定数があり、どの文字がどのバイト値へ対応付けられるかが示されています。"

#: ../../library/codecs.rst:885
msgid ""
"All of these encodings can only encode 256 of the 1114112 code points "
"defined in Unicode. A simple and straightforward way that can store each "
"Unicode code point, is to store each code point as four consecutive bytes. "
"There are two possibilities: store the bytes in big endian or in little "
"endian order. These two encodings are called ``UTF-32-BE`` and ``UTF-32-LE``"
" respectively. Their disadvantage is that if e.g. you use ``UTF-32-BE`` on a"
" little endian machine you will always have to swap bytes on encoding and "
"decoding. ``UTF-32`` avoids this problem: bytes will always be in natural "
"endianness. When these bytes are read by a CPU with a different endianness, "
"then bytes have to be swapped though. To be able to detect the endianness of"
" a ``UTF-16`` or ``UTF-32`` byte sequence, there's the so called BOM (\"Byte"
" Order Mark\"). This is the Unicode character ``U+FEFF``. This character can"
" be prepended to every ``UTF-16`` or ``UTF-32`` byte sequence. The byte "
"swapped version of this character (``0xFFFE``) is an illegal character that "
"may not appear in a Unicode text. So when the first character in an "
"``UTF-16`` or ``UTF-32`` byte sequence appears to be a ``U+FFFE`` the bytes "
"have to be swapped on decoding. Unfortunately the character ``U+FEFF`` had a"
" second purpose as a ``ZERO WIDTH NO-BREAK SPACE``: a character that has no "
"width and doesn't allow a word to be split. It can e.g. be used to give "
"hints to a ligature algorithm. With Unicode 4.0 using ``U+FEFF`` as a ``ZERO"
" WIDTH NO-BREAK SPACE`` has been deprecated (with ``U+2060`` (``WORD "
"JOINER``) assuming this role). Nevertheless Unicode software still must be "
"able to handle ``U+FEFF`` in both roles: as a BOM it's a device to determine"
" the storage layout of the encoded bytes, and vanishes once the byte "
"sequence has been decoded into a string; as a ``ZERO WIDTH NO-BREAK SPACE`` "
"it's a normal character that will be decoded like any other."
msgstr ""
"これらのエンコーディングはすべて、 Unicode に定義された 1114112 のコードポイントのうちの 256 だけをエンコードすることができます。"
" Unicode "
"のすべてのコードポイントを格納するための単純で直接的な方法は、各コードポイントを連続する4バイトとして格納することです。これには2つの可能性があります:"
" ビッグエンディアンまたはリトルエンディアンの順にバイトを格納することです。これら2つのエンコーディングはそれぞれ ``UTF-32-BE`` および "
"``UTF-32-LE`` と呼ばれます。それらのデメリットは、例えばリトルエンディアンのマシン上で ``UTF-32-BE`` "
"を使用すると、エンコードでもデコードでも常にバイト順を交換する必要があることです。``UTF-32`` はこの問題を回避します: "
"バイト順は、常に自然なエンディアンに従います。しかし、これらのバイト順が異なるエンディアン性を持つ CPU "
"によって読まれる場合、結局バイト順を交換しなければなりません。``UTF-16`` あるいは ``UTF-32`` "
"バイト列のエンディアン性を検出する目的で、いわゆる BOM (「バイト・オーダー・マーク」) があります。これは Unicode 文字 "
"``U+FEFF`` です。この文字はすべての ``UTF-16`` あるいは ``UTF-32`` "
"バイト列の前に置くことができます。この文字のバイトが交換されたバージョン (``0xFFFE``) は、 Unicode "
"テキストに現われてはならない不正な文字です。したがって、``UTF-16`` あるいは ``UTF-32`` バイト列中の最初の文字が "
"``U+FFFE`` であるように見える場合、デコードの際にバイトを交換しなければなりません。不運にも文字 ``U+FEFF`` は ``ZERO "
"WIDTH NO-BREAK SPACE`` として別の目的を持っていました: "
"幅を持たず、単語を分割することを許容しない文字。それは、例えばリガチャアルゴリズムにヒントを与えるために使用することができます。 Unicode  "
"4.0 で、``ZERO WIDTH NO-BREAK SPACE`` としての ``U+FEFF`` の使用は廃止予定になりました (この役割は "
"``U+2060`` (``WORD JOINER``) によって引き継がれました)。しかしながら、 Unicode "
"ソフトウェアは、依然として両方の役割の ``U+FEFF`` を扱うことができなければなりません: BOM "
"として、エンコードされたバイトのメモリレイアウトを決定する手段であり、一旦バイト列が文字列にデコードされたならば消えます; ``ZERO WIDTH "
"NO-BREAK SPACE`` として、他の任意の文字のようにデコードされる通常の文字です。"

#: ../../library/codecs.rst:911
msgid ""
"There's another encoding that is able to encoding the full range of Unicode "
"characters: UTF-8. UTF-8 is an 8-bit encoding, which means there are no "
"issues with byte order in UTF-8. Each byte in a UTF-8 byte sequence consists"
" of two parts: marker bits (the most significant bits) and payload bits. The"
" marker bits are a sequence of zero to four ``1`` bits followed by a ``0`` "
"bit. Unicode characters are encoded like this (with x being payload bits, "
"which when concatenated give the Unicode character):"
msgstr ""
"さらにもう一つ Unicode 文字全てをエンコードできるエンコーディングがあり、UTF-8 と呼ばれています。UTF-8 "
"は8ビットエンコーディングで、したがって UTF-8 にはバイト順の問題はありません。UTF-8 "
"バイト列の各バイトは二つのパートから成ります。二つはマーカ(上位数ビット)とペイロードです。マーカは0ビットから4ビットの ``1`` の列に "
"``0`` のビットが一つ続いたものです。Unicode 文字は次のようにエンコードされます (x はペイロードを表わし、連結されると一つの "
"Unicode 文字を表わします):"

#: ../../library/codecs.rst:920
msgid "Range"
msgstr "範囲"

#: ../../library/codecs.rst:920
msgid "Encoding"
msgstr "エンコーディング"

#: ../../library/codecs.rst:922
msgid "``U-00000000`` ... ``U-0000007F``"
msgstr "``U-00000000`` ... ``U-0000007F``"

#: ../../library/codecs.rst:922
msgid "0xxxxxxx"
msgstr "0xxxxxxx"

#: ../../library/codecs.rst:924
msgid "``U-00000080`` ... ``U-000007FF``"
msgstr "``U-00000080`` ... ``U-000007FF``"

#: ../../library/codecs.rst:924
msgid "110xxxxx 10xxxxxx"
msgstr "110xxxxx 10xxxxxx"

#: ../../library/codecs.rst:926
msgid "``U-00000800`` ... ``U-0000FFFF``"
msgstr "``U-00000800`` ... ``U-0000FFFF``"

#: ../../library/codecs.rst:926
msgid "1110xxxx 10xxxxxx 10xxxxxx"
msgstr "1110xxxx 10xxxxxx 10xxxxxx"

#: ../../library/codecs.rst:928
msgid "``U-00010000`` ... ``U-0010FFFF``"
msgstr "``U-00010000`` ... ``U-0010FFFF``"

#: ../../library/codecs.rst:928
msgid "11110xxx 10xxxxxx 10xxxxxx 10xxxxxx"
msgstr "11110xxx 10xxxxxx 10xxxxxx 10xxxxxx"

#: ../../library/codecs.rst:931
msgid ""
"The least significant bit of the Unicode character is the rightmost x bit."
msgstr "Unicode 文字の最下位ビットとは最も右にある x のビットです。"

#: ../../library/codecs.rst:933
msgid ""
"As UTF-8 is an 8-bit encoding no BOM is required and any ``U+FEFF`` "
"character in the decoded string (even if it's the first character) is "
"treated as a ``ZERO WIDTH NO-BREAK SPACE``."
msgstr ""
"UTF-8 は8ビットエンコーディングなので BOM は必要とせず、デコードされた文字列中の ``U+FEFF`` "
"は(たとえ最初の文字であったとしても) ``ZERO WIDTH NO-BREAK SPACE`` として扱われます。"

#: ../../library/codecs.rst:937
msgid ""
"Without external information it's impossible to reliably determine which "
"encoding was used for encoding a string. Each charmap encoding can decode "
"any random byte sequence. However that's not possible with UTF-8, as UTF-8 "
"byte sequences have a structure that doesn't allow arbitrary byte sequences."
" To increase the reliability with which a UTF-8 encoding can be detected, "
"Microsoft invented a variant of UTF-8 (that Python 2.5 calls "
"``\"utf-8-sig\"``) for its Notepad program: Before any of the Unicode "
"characters is written to the file, a UTF-8 encoded BOM (which looks like "
"this as a byte sequence: ``0xef``, ``0xbb``, ``0xbf``) is written. As it's "
"rather improbable that any charmap encoded file starts with these byte "
"values (which would e.g. map to"
msgstr ""
"外部からの情報無しには、文字列のエンコーディングにどのエンコーディングが使われたのか信頼できる形で決定することは不可能です。どの charmap "
"エンコーディングもどんなランダムなバイト列でもデコードできます。しかし UTF-8 "
"ではそれは可能ではありません。任意のバイト列を許さないような構造を持っているからです。UTF-8 "
"エンコーディングであることを検知する信頼性を向上させるために、Microsoft は Notepad プログラム用に UTF-8 の変種 (Python"
" 2.5 では ``\"utf-8-sig\"`` と呼んでいます) を考案しました。Unicode 文字がファイルに書き込まれる前に UTF-8 "
"でエンコードした BOM (バイト列では ``0xef``, ``0xbb``, ``0xbf`` のように見えます) "
"が書き込まれます。このようなバイト値で charmap エンコードされたファイルが始まることはほとんどあり得ない (たとえば iso-8859-1 では"

#: ../../library/codecs.rst:0
msgid "LATIN SMALL LETTER I WITH DIAERESIS"
msgstr "LATIN SMALL LETTER I WITH DIAERESIS"

#: ../../library/codecs.rst:0
msgid "RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK"
msgstr "RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK"

#: ../../library/codecs.rst:0
msgid "INVERTED QUESTION MARK"
msgstr "INVERTED QUESTION MARK"

#: ../../library/codecs.rst:953
msgid ""
"in iso-8859-1), this increases the probability that a ``utf-8-sig`` encoding"
" can be correctly guessed from the byte sequence. So here the BOM is not "
"used to be able to determine the byte order used for generating the byte "
"sequence, but as a signature that helps in guessing the encoding. On "
"encoding the utf-8-sig codec will write ``0xef``, ``0xbb``, ``0xbf`` as the "
"first three bytes to the file. On decoding ``utf-8-sig`` will skip those "
"three bytes if they appear as the first three bytes in the file.  In UTF-8, "
"the use of the BOM is discouraged and should generally be avoided."
msgstr ""
"のようになる)ので、``utf-8-sig`` エンコーディングがバイト列から正しく推測される確率を高めます。つまりここでは BOM "
"はバイト列を生成する際のバイト順を決定できるように使われているのではなく、エンコーディングを推測する助けになる印として使われているのです。``utf-8-sig``"
" codec はエンコーディングの際ファイルに最初の3文字として ``0xef``, ``0xbb``, ``0xbf`` "
"を書き込みます。デコーディングの際はファイルの先頭に現れたこれら3バイトはスキップします。UTF-8 では BOM "
"の使用は推奨されておらず、一般的には避けるべきです。"

#: ../../library/codecs.rst:966
msgid "Standard Encodings"
msgstr "標準エンコーディング"

#: ../../library/codecs.rst:968
msgid ""
"Python comes with a number of codecs built-in, either implemented as C "
"functions or with dictionaries as mapping tables. The following table lists "
"the codecs by name, together with a few common aliases, and the languages "
"for which the encoding is likely used. Neither the list of aliases nor the "
"list of languages is meant to be exhaustive. Notice that spelling "
"alternatives that only differ in case or use a hyphen instead of an "
"underscore are also valid aliases; therefore, e.g. ``'utf-8'`` is a valid "
"alias for the ``'utf_8'`` codec."
msgstr ""
"Python には数多くの codec が組み込みで付属します。これらは C "
"言語の関数、対応付けを行うテーブルの両方で提供されています。以下のテーブルでは codec "
"と、いくつかの良く知られている別名と、エンコーディングが使われる言語を列挙します。別名のリスト、言語のリストともしらみつぶしに網羅されているわけではありません。大文字と小文字、またはアンダースコアの代りにハイフンにしただけの綴りも有効な別名です;"
" そのため、例えば ``'utf-8'`` は ``'utf_8'`` codec の正当な別名です。"

#: ../../library/codecs.rst:978
msgid ""
"Some common encodings can bypass the codecs lookup machinery to improve "
"performance.  These optimization opportunities are only recognized by "
"CPython for a limited set of (case insensitive) aliases: utf-8, utf8, "
"latin-1, latin1, iso-8859-1, iso8859-1, mbcs (Windows only), ascii, us-"
"ascii, utf-16, utf16, utf-32, utf32, and the same using underscores instead "
"of dashes. Using alternative aliases for these encodings may result in "
"slower execution."
msgstr ""
"いくつかの一般的なエンコーディングは、パフォーマンスを改善するために codec の検索機構を回避することがあります。\n"
"このような最適化の機会を認識するのは、 CPython の限定された (大文字小文字を区別しない) 別名に対してのみです: utf-8, utf8, latin-1, latin1, iso-8859-1, iso8859-1, mbcs (Windows のみ), ascii, us-ascii, utf-16, utf16, utf-32, utf32 およびダッシュの代わりにアンダースコアを用いたもの。\n"
"これらのエンコーディングの別のつづりを使用すると実行時間の低下を招くかもしれません。"

#: ../../library/codecs.rst:986
msgid "Optimization opportunity recognized for us-ascii."
msgstr "us-ascii に対して最適化の機会が認識されるようになりました。"

#: ../../library/codecs.rst:989
msgid ""
"Many of the character sets support the same languages. They vary in "
"individual characters (e.g. whether the EURO SIGN is supported or not), and "
"in the assignment of characters to code positions. For the European "
"languages in particular, the following variants typically exist:"
msgstr ""
"多くの文字セットは同じ言語をサポートしています。これらの文字セットは個々の文字 (例えば、EURO SIGN がサポートされているかどうか) "
"や、文字のコード部分への割り付けが異なります。特に欧州言語では、典型的に以下の変種が存在します:"

#: ../../library/codecs.rst:994
msgid "an ISO 8859 codeset"
msgstr "ISO 8859 コードセット"

#: ../../library/codecs.rst:996
msgid ""
"a Microsoft Windows code page, which is typically derived from an 8859 "
"codeset, but replaces control characters with additional graphic characters"
msgstr ""
"Microsoft Windows コードページで、8859 コード形式から導出されているが、制御文字を追加のグラフィック文字と置き換えたもの"

#: ../../library/codecs.rst:999
msgid "an IBM EBCDIC code page"
msgstr "IBM EBCDIC コードページ"

#: ../../library/codecs.rst:1001
msgid "an IBM PC code page, which is ASCII compatible"
msgstr "ASCII 互換の IBM PC コードページ"

#: ../../library/codecs.rst:1006 ../../library/codecs.rst:1262
#: ../../library/codecs.rst:1335 ../../library/codecs.rst:1390
msgid "Codec"
msgstr "Codec"

#: ../../library/codecs.rst:1006 ../../library/codecs.rst:1262
#: ../../library/codecs.rst:1335 ../../library/codecs.rst:1390
msgid "Aliases"
msgstr "別名"

#: ../../library/codecs.rst:1006
msgid "Languages"
msgstr "言語"

#: ../../library/codecs.rst:1008
msgid "ascii"
msgstr "ascii"

#: ../../library/codecs.rst:1008
msgid "646, us-ascii"
msgstr "646, us-ascii"

#: ../../library/codecs.rst:1008 ../../library/codecs.rst:1014
#: ../../library/codecs.rst:1022
msgid "English"
msgstr "英語"

#: ../../library/codecs.rst:1010
msgid "big5"
msgstr "big5"

#: ../../library/codecs.rst:1010
msgid "big5-tw, csbig5"
msgstr "big5-tw, csbig5"

#: ../../library/codecs.rst:1010 ../../library/codecs.rst:1012
#: ../../library/codecs.rst:1070
msgid "Traditional Chinese"
msgstr "繁体字中国語"

#: ../../library/codecs.rst:1012
msgid "big5hkscs"
msgstr "big5hkscs"

#: ../../library/codecs.rst:1012
msgid "big5-hkscs, hkscs"
msgstr "big5-hkscs, hkscs"

#: ../../library/codecs.rst:1014
msgid "cp037"
msgstr "cp037"

#: ../../library/codecs.rst:1014
msgid "IBM037, IBM039"
msgstr "IBM037, IBM039"

#: ../../library/codecs.rst:1016
msgid "cp273"
msgstr "cp273"

#: ../../library/codecs.rst:1016
msgid "273, IBM273, csIBM273"
msgstr "273, IBM273, csIBM273"

#: ../../library/codecs.rst:1016
msgid "German"
msgstr "ドイツ語"

#: ../../library/codecs.rst:1020
msgid "cp424"
msgstr "cp424"

#: ../../library/codecs.rst:1020
msgid "EBCDIC-CP-HE, IBM424"
msgstr "EBCDIC-CP-HE, IBM424"

#: ../../library/codecs.rst:1020 ../../library/codecs.rst:1040
#: ../../library/codecs.rst:1050 ../../library/codecs.rst:1093
#: ../../library/codecs.rst:1161
msgid "Hebrew"
msgstr "ヘブライ語"

#: ../../library/codecs.rst:1022
msgid "cp437"
msgstr "cp437"

#: ../../library/codecs.rst:1022
msgid "437, IBM437"
msgstr "437, IBM437"

#: ../../library/codecs.rst:1024
msgid "cp500"
msgstr "cp500"

#: ../../library/codecs.rst:1024
msgid "EBCDIC-CP-BE, EBCDIC-CP-CH, IBM500"
msgstr "EBCDIC-CP-BE, EBCDIC-CP-CH, IBM500"

#: ../../library/codecs.rst:1024 ../../library/codecs.rst:1033
#: ../../library/codecs.rst:1044 ../../library/codecs.rst:1080
#: ../../library/codecs.rst:1087 ../../library/codecs.rst:1173
#: ../../library/codecs.rst:1200
msgid "Western Europe"
msgstr "西ヨーロッパ言語"

#: ../../library/codecs.rst:1027
msgid "cp720"
msgstr "cp720"

#: ../../library/codecs.rst:1027 ../../library/codecs.rst:1054
#: ../../library/codecs.rst:1095 ../../library/codecs.rst:1157
msgid "Arabic"
msgstr "アラビア語"

#: ../../library/codecs.rst:1029
msgid "cp737"
msgstr "cp737"

#: ../../library/codecs.rst:1029 ../../library/codecs.rst:1060
#: ../../library/codecs.rst:1064 ../../library/codecs.rst:1089
#: ../../library/codecs.rst:1159 ../../library/codecs.rst:1194
msgid "Greek"
msgstr "ギリシャ語"

#: ../../library/codecs.rst:1031
msgid "cp775"
msgstr "cp775"

#: ../../library/codecs.rst:1031
msgid "IBM775"
msgstr "IBM775"

#: ../../library/codecs.rst:1031 ../../library/codecs.rst:1097
#: ../../library/codecs.rst:1152 ../../library/codecs.rst:1169
msgid "Baltic languages"
msgstr "バルト沿岸国"

#: ../../library/codecs.rst:1033
msgid "cp850"
msgstr "cp850"

#: ../../library/codecs.rst:1033
msgid "850, IBM850"
msgstr "850, IBM850"

#: ../../library/codecs.rst:1035
msgid "cp852"
msgstr "cp852"

#: ../../library/codecs.rst:1035
msgid "852, IBM852"
msgstr "852, IBM852"

#: ../../library/codecs.rst:1035 ../../library/codecs.rst:1082
#: ../../library/codecs.rst:1148 ../../library/codecs.rst:1198
msgid "Central and Eastern Europe"
msgstr "中央および東ヨーロッパ"

#: ../../library/codecs.rst:1037
msgid "cp855"
msgstr "cp855"

#: ../../library/codecs.rst:1037
msgid "855, IBM855"
msgstr "855, IBM855"

#: ../../library/codecs.rst:1037 ../../library/codecs.rst:1084
#: ../../library/codecs.rst:1154 ../../library/codecs.rst:1191
msgid "Bulgarian, Byelorussian, Macedonian, Russian, Serbian"
msgstr "ブルガリア、ベラルーシ、マケドニア、ロシア、セルビア"

#: ../../library/codecs.rst:1040
msgid "cp856"
msgstr "cp856"

#: ../../library/codecs.rst:1042
msgid "cp857"
msgstr "cp857"

#: ../../library/codecs.rst:1042
msgid "857, IBM857"
msgstr "857, IBM857"

#: ../../library/codecs.rst:1042 ../../library/codecs.rst:1074
#: ../../library/codecs.rst:1091 ../../library/codecs.rst:1163
#: ../../library/codecs.rst:1202
msgid "Turkish"
msgstr "トルコ語"

#: ../../library/codecs.rst:1044
msgid "cp858"
msgstr "cp858"

#: ../../library/codecs.rst:1044
msgid "858, IBM858"
msgstr "858, IBM858"

#: ../../library/codecs.rst:1046
msgid "cp860"
msgstr "cp860"

#: ../../library/codecs.rst:1046
msgid "860, IBM860"
msgstr "860, IBM860"

#: ../../library/codecs.rst:1046
msgid "Portuguese"
msgstr "ポルトガル語"

#: ../../library/codecs.rst:1048
msgid "cp861"
msgstr "cp861"

#: ../../library/codecs.rst:1048
msgid "861, CP-IS, IBM861"
msgstr "861, CP-IS, IBM861"

#: ../../library/codecs.rst:1048 ../../library/codecs.rst:1196
msgid "Icelandic"
msgstr "アイスランド語"

#: ../../library/codecs.rst:1050
msgid "cp862"
msgstr "cp862"

#: ../../library/codecs.rst:1050
msgid "862, IBM862"
msgstr "862, IBM862"

#: ../../library/codecs.rst:1052
msgid "cp863"
msgstr "cp863"

#: ../../library/codecs.rst:1052
msgid "863, IBM863"
msgstr "863, IBM863"

#: ../../library/codecs.rst:1052
msgid "Canadian"
msgstr "カナダ"

#: ../../library/codecs.rst:1054
msgid "cp864"
msgstr "cp864"

#: ../../library/codecs.rst:1054
msgid "IBM864"
msgstr "IBM864"

#: ../../library/codecs.rst:1056
msgid "cp865"
msgstr "cp865"

#: ../../library/codecs.rst:1056
msgid "865, IBM865"
msgstr "865, IBM865"

#: ../../library/codecs.rst:1056
msgid "Danish, Norwegian"
msgstr "デンマーク、ノルウェー"

#: ../../library/codecs.rst:1058
msgid "cp866"
msgstr "cp866"

#: ../../library/codecs.rst:1058
msgid "866, IBM866"
msgstr "866, IBM866"

#: ../../library/codecs.rst:1058 ../../library/codecs.rst:1179
msgid "Russian"
msgstr "ロシア語"

#: ../../library/codecs.rst:1060
msgid "cp869"
msgstr "cp869"

#: ../../library/codecs.rst:1060
msgid "869, CP-GR, IBM869"
msgstr "869, CP-GR, IBM869"

#: ../../library/codecs.rst:1062
msgid "cp874"
msgstr "cp874"

#: ../../library/codecs.rst:1062
msgid "Thai"
msgstr "タイ語"

#: ../../library/codecs.rst:1064
msgid "cp875"
msgstr "cp875"

#: ../../library/codecs.rst:1066
msgid "cp932"
msgstr "cp932"

#: ../../library/codecs.rst:1066
msgid "932, ms932, mskanji, ms-kanji"
msgstr "932, ms932, mskanji, ms-kanji"

#: ../../library/codecs.rst:1066 ../../library/codecs.rst:1106
#: ../../library/codecs.rst:1108 ../../library/codecs.rst:1110
#: ../../library/codecs.rst:1127 ../../library/codecs.rst:1130
#: ../../library/codecs.rst:1135 ../../library/codecs.rst:1138
#: ../../library/codecs.rst:1140 ../../library/codecs.rst:1207
#: ../../library/codecs.rst:1210 ../../library/codecs.rst:1213
msgid "Japanese"
msgstr "日本語"

#: ../../library/codecs.rst:1068
msgid "cp949"
msgstr "cp949"

#: ../../library/codecs.rst:1068
msgid "949, ms949, uhc"
msgstr "949, ms949, uhc"

#: ../../library/codecs.rst:1068 ../../library/codecs.rst:1112
#: ../../library/codecs.rst:1142 ../../library/codecs.rst:1177
msgid "Korean"
msgstr "韓国語"

#: ../../library/codecs.rst:1070
msgid "cp950"
msgstr "cp950"

#: ../../library/codecs.rst:1070
msgid "950, ms950"
msgstr "950, ms950"

#: ../../library/codecs.rst:1072
msgid "cp1006"
msgstr "cp1006"

#: ../../library/codecs.rst:1072
msgid "Urdu"
msgstr "Urdu"

#: ../../library/codecs.rst:1074
msgid "cp1026"
msgstr "cp1026"

#: ../../library/codecs.rst:1074
msgid "ibm1026"
msgstr "ibm1026"

#: ../../library/codecs.rst:1076
msgid "cp1125"
msgstr "cp1125"

#: ../../library/codecs.rst:1076
msgid "1125, ibm1125, cp866u, ruscii"
msgstr "1125, ibm1125, cp866u, ruscii"

#: ../../library/codecs.rst:1076 ../../library/codecs.rst:1185
msgid "Ukrainian"
msgstr "ウクライナ語"

#: ../../library/codecs.rst:1080
msgid "cp1140"
msgstr "cp1140"

#: ../../library/codecs.rst:1080
msgid "ibm1140"
msgstr "ibm1140"

#: ../../library/codecs.rst:1082
msgid "cp1250"
msgstr "cp1250"

#: ../../library/codecs.rst:1082
msgid "windows-1250"
msgstr "windows-1250"

#: ../../library/codecs.rst:1084
msgid "cp1251"
msgstr "cp1251"

#: ../../library/codecs.rst:1084
msgid "windows-1251"
msgstr "windows-1251"

#: ../../library/codecs.rst:1087
msgid "cp1252"
msgstr "cp1252"

#: ../../library/codecs.rst:1087
msgid "windows-1252"
msgstr "windows-1252"

#: ../../library/codecs.rst:1089
msgid "cp1253"
msgstr "cp1253"

#: ../../library/codecs.rst:1089
msgid "windows-1253"
msgstr "windows-1253"

#: ../../library/codecs.rst:1091
msgid "cp1254"
msgstr "cp1254"

#: ../../library/codecs.rst:1091
msgid "windows-1254"
msgstr "windows-1254"

#: ../../library/codecs.rst:1093
msgid "cp1255"
msgstr "cp1255"

#: ../../library/codecs.rst:1093
msgid "windows-1255"
msgstr "windows-1255"

#: ../../library/codecs.rst:1095
msgid "cp1256"
msgstr "cp1256"

#: ../../library/codecs.rst:1095
msgid "windows-1256"
msgstr "windows-1256"

#: ../../library/codecs.rst:1097
msgid "cp1257"
msgstr "cp1257"

#: ../../library/codecs.rst:1097
msgid "windows-1257"
msgstr "windows-1257"

#: ../../library/codecs.rst:1099
msgid "cp1258"
msgstr "cp1258"

#: ../../library/codecs.rst:1099
msgid "windows-1258"
msgstr "windows-1258"

#: ../../library/codecs.rst:1099
msgid "Vietnamese"
msgstr "ベトナム"

#: ../../library/codecs.rst:1101
msgid "cp65001"
msgstr "cp65001"

#: ../../library/codecs.rst:1101
msgid "Windows only: Windows UTF-8 (``CP_UTF8``)"
msgstr "Windows のみ: Windows UTF-8 (``CP_UTF8``)"

#: ../../library/codecs.rst:1106
msgid "euc_jp"
msgstr "euc_jp"

#: ../../library/codecs.rst:1106
msgid "eucjp, ujis, u-jis"
msgstr "eucjp, ujis, u-jis"

#: ../../library/codecs.rst:1108
msgid "euc_jis_2004"
msgstr "euc_jis_2004"

#: ../../library/codecs.rst:1108
msgid "jisx0213, eucjis2004"
msgstr "jisx0213, eucjis2004"

#: ../../library/codecs.rst:1110
msgid "euc_jisx0213"
msgstr "euc_jisx0213"

#: ../../library/codecs.rst:1110
msgid "eucjisx0213"
msgstr "eucjisx0213"

#: ../../library/codecs.rst:1112
msgid "euc_kr"
msgstr "euc_kr"

#: ../../library/codecs.rst:1112
msgid "euckr, korean, ksc5601, ks_c-5601, ks_c-5601-1987, ksx1001, ks_x-1001"
msgstr "euckr, korean, ksc5601, ks_c-5601, ks_c-5601-1987, ksx1001, ks_x-1001"

#: ../../library/codecs.rst:1116
msgid "gb2312"
msgstr "gb2312"

#: ../../library/codecs.rst:1116
msgid ""
"chinese, csiso58gb231280, euc- cn, euccn, eucgb2312-cn, gb2312-1980, "
"gb2312-80, iso- ir-58"
msgstr ""
"chinese, csiso58gb231280, euc- cn, euccn, eucgb2312-cn, gb2312-1980, "
"gb2312-80, iso- ir-58"

#: ../../library/codecs.rst:1116 ../../library/codecs.rst:1125
msgid "Simplified Chinese"
msgstr "簡体字中国語"

#: ../../library/codecs.rst:1121
msgid "gbk"
msgstr "gbk"

#: ../../library/codecs.rst:1121
msgid "936, cp936, ms936"
msgstr "936, cp936, ms936"

#: ../../library/codecs.rst:1121 ../../library/codecs.rst:1123
msgid "Unified Chinese"
msgstr "Unified Chinese"

#: ../../library/codecs.rst:1123
msgid "gb18030"
msgstr "gb18030"

#: ../../library/codecs.rst:1123
msgid "gb18030-2000"
msgstr "gb18030-2000"

#: ../../library/codecs.rst:1125
msgid "hz"
msgstr "hz"

#: ../../library/codecs.rst:1125
msgid "hzgb, hz-gb, hz-gb-2312"
msgstr "hzgb, hz-gb, hz-gb-2312"

#: ../../library/codecs.rst:1127
msgid "iso2022_jp"
msgstr "iso2022_jp"

#: ../../library/codecs.rst:1127
msgid "csiso2022jp, iso2022jp, iso-2022-jp"
msgstr "csiso2022jp, iso2022jp, iso-2022-jp"

#: ../../library/codecs.rst:1130
msgid "iso2022_jp_1"
msgstr "iso2022_jp_1"

#: ../../library/codecs.rst:1130
msgid "iso2022jp-1, iso-2022-jp-1"
msgstr "iso2022jp-1, iso-2022-jp-1"

#: ../../library/codecs.rst:1132
msgid "iso2022_jp_2"
msgstr "iso2022_jp_2"

#: ../../library/codecs.rst:1132
msgid "iso2022jp-2, iso-2022-jp-2"
msgstr "iso2022jp-2, iso-2022-jp-2"

#: ../../library/codecs.rst:1132
msgid "Japanese, Korean, Simplified Chinese, Western Europe, Greek"
msgstr "日本語, 韓国語, 簡体字中国語, 西欧, ギリシャ語"

#: ../../library/codecs.rst:1135
msgid "iso2022_jp_2004"
msgstr "iso2022_jp_2004"

#: ../../library/codecs.rst:1135
msgid "iso2022jp-2004, iso-2022-jp-2004"
msgstr "iso2022jp-2004, iso-2022-jp-2004"

#: ../../library/codecs.rst:1138
msgid "iso2022_jp_3"
msgstr "iso2022_jp_3"

#: ../../library/codecs.rst:1138
msgid "iso2022jp-3, iso-2022-jp-3"
msgstr "iso2022jp-3, iso-2022-jp-3"

#: ../../library/codecs.rst:1140
msgid "iso2022_jp_ext"
msgstr "iso2022_jp_ext"

#: ../../library/codecs.rst:1140
msgid "iso2022jp-ext, iso-2022-jp-ext"
msgstr "iso2022jp-ext, iso-2022-jp-ext"

#: ../../library/codecs.rst:1142
msgid "iso2022_kr"
msgstr "iso2022_kr"

#: ../../library/codecs.rst:1142
msgid "csiso2022kr, iso2022kr, iso-2022-kr"
msgstr "csiso2022kr, iso2022kr, iso-2022-kr"

#: ../../library/codecs.rst:1145
msgid "latin_1"
msgstr "latin_1"

#: ../../library/codecs.rst:1145
msgid "iso-8859-1, iso8859-1, 8859, cp819, latin, latin1, L1"
msgstr "iso-8859-1, iso8859-1, 8859, cp819, latin, latin1, L1"

#: ../../library/codecs.rst:1145
msgid "West Europe"
msgstr "西ヨーロッパ"

#: ../../library/codecs.rst:1148
msgid "iso8859_2"
msgstr "iso8859_2"

#: ../../library/codecs.rst:1148
msgid "iso-8859-2, latin2, L2"
msgstr "iso-8859-2, latin2, L2"

#: ../../library/codecs.rst:1150
msgid "iso8859_3"
msgstr "iso8859_3"

#: ../../library/codecs.rst:1150
msgid "iso-8859-3, latin3, L3"
msgstr "iso-8859-3, latin3, L3"

#: ../../library/codecs.rst:1150
msgid "Esperanto, Maltese"
msgstr "エスペラント、マルタ"

#: ../../library/codecs.rst:1152
msgid "iso8859_4"
msgstr "iso8859_4"

#: ../../library/codecs.rst:1152
msgid "iso-8859-4, latin4, L4"
msgstr "iso-8859-4, latin4, L4"

#: ../../library/codecs.rst:1154
msgid "iso8859_5"
msgstr "iso8859_5"

#: ../../library/codecs.rst:1154
msgid "iso-8859-5, cyrillic"
msgstr "iso-8859-5, cyrillic"

#: ../../library/codecs.rst:1157
msgid "iso8859_6"
msgstr "iso8859_6"

#: ../../library/codecs.rst:1157
msgid "iso-8859-6, arabic"
msgstr "iso-8859-6, arabic"

#: ../../library/codecs.rst:1159
msgid "iso8859_7"
msgstr "iso8859_7"

#: ../../library/codecs.rst:1159
msgid "iso-8859-7, greek, greek8"
msgstr "iso-8859-7, greek, greek8"

#: ../../library/codecs.rst:1161
msgid "iso8859_8"
msgstr "iso8859_8"

#: ../../library/codecs.rst:1161
msgid "iso-8859-8, hebrew"
msgstr "iso-8859-8, hebrew"

#: ../../library/codecs.rst:1163
msgid "iso8859_9"
msgstr "iso8859_9"

#: ../../library/codecs.rst:1163
msgid "iso-8859-9, latin5, L5"
msgstr "iso-8859-9, latin5, L5"

#: ../../library/codecs.rst:1165
msgid "iso8859_10"
msgstr "iso8859_10"

#: ../../library/codecs.rst:1165
msgid "iso-8859-10, latin6, L6"
msgstr "iso-8859-10, latin6, L6"

#: ../../library/codecs.rst:1165
msgid "Nordic languages"
msgstr "北欧語"

#: ../../library/codecs.rst:1167
msgid "iso8859_11"
msgstr "iso8859_11"

#: ../../library/codecs.rst:1167
msgid "iso-8859-11, thai"
msgstr "iso-8859-11, thai"

#: ../../library/codecs.rst:1167
msgid "Thai languages"
msgstr "タイ語"

#: ../../library/codecs.rst:1169
msgid "iso8859_13"
msgstr "iso8859_13"

#: ../../library/codecs.rst:1169
msgid "iso-8859-13, latin7, L7"
msgstr "iso-8859-13, latin7, L7"

#: ../../library/codecs.rst:1171
msgid "iso8859_14"
msgstr "iso8859_14"

#: ../../library/codecs.rst:1171
msgid "iso-8859-14, latin8, L8"
msgstr "iso-8859-14, latin8, L8"

#: ../../library/codecs.rst:1171
msgid "Celtic languages"
msgstr "ケルト語"

#: ../../library/codecs.rst:1173
msgid "iso8859_15"
msgstr "iso8859_15"

#: ../../library/codecs.rst:1173
msgid "iso-8859-15, latin9, L9"
msgstr "iso-8859-15, latin9, L9"

#: ../../library/codecs.rst:1175
msgid "iso8859_16"
msgstr "iso8859_16"

#: ../../library/codecs.rst:1175
msgid "iso-8859-16, latin10, L10"
msgstr "iso-8859-16, latin10, L10"

#: ../../library/codecs.rst:1175
msgid "South-Eastern Europe"
msgstr "南東ヨーロッパ"

#: ../../library/codecs.rst:1177
msgid "johab"
msgstr "johab"

#: ../../library/codecs.rst:1177
msgid "cp1361, ms1361"
msgstr "cp1361, ms1361"

#: ../../library/codecs.rst:1179
msgid "koi8_r"
msgstr "koi8_r"

#: ../../library/codecs.rst:1181
msgid "koi8_t"
msgstr "koi8_t"

#: ../../library/codecs.rst:1181
msgid "Tajik"
msgstr "タジク"

#: ../../library/codecs.rst:1185
msgid "koi8_u"
msgstr "koi8_u"

#: ../../library/codecs.rst:1187
msgid "kz1048"
msgstr "kz1048"

#: ../../library/codecs.rst:1187
msgid "kz_1048, strk1048_2002, rk1048"
msgstr "kz_1048, strk1048_2002, rk1048"

#: ../../library/codecs.rst:1187 ../../library/codecs.rst:1204
msgid "Kazakh"
msgstr "カザフ"

#: ../../library/codecs.rst:1191
msgid "mac_cyrillic"
msgstr "mac_cyrillic"

#: ../../library/codecs.rst:1191
msgid "maccyrillic"
msgstr "maccyrillic"

#: ../../library/codecs.rst:1194
msgid "mac_greek"
msgstr "mac_greek"

#: ../../library/codecs.rst:1194
msgid "macgreek"
msgstr "macgreek"

#: ../../library/codecs.rst:1196
msgid "mac_iceland"
msgstr "mac_iceland"

#: ../../library/codecs.rst:1196
msgid "maciceland"
msgstr "maciceland"

#: ../../library/codecs.rst:1198
msgid "mac_latin2"
msgstr "mac_latin2"

#: ../../library/codecs.rst:1198
msgid "maclatin2, maccentraleurope"
msgstr "maclatin2, maccentraleurope"

#: ../../library/codecs.rst:1200
msgid "mac_roman"
msgstr "mac_roman"

#: ../../library/codecs.rst:1200
msgid "macroman, macintosh"
msgstr "macroman, macintosh"

#: ../../library/codecs.rst:1202
msgid "mac_turkish"
msgstr "mac_turkish"

#: ../../library/codecs.rst:1202
msgid "macturkish"
msgstr "macturkish"

#: ../../library/codecs.rst:1204
msgid "ptcp154"
msgstr "ptcp154"

#: ../../library/codecs.rst:1204
msgid "csptcp154, pt154, cp154, cyrillic-asian"
msgstr "csptcp154, pt154, cp154, cyrillic-asian"

#: ../../library/codecs.rst:1207
msgid "shift_jis"
msgstr "shift_jis"

#: ../../library/codecs.rst:1207
msgid "csshiftjis, shiftjis, sjis, s_jis"
msgstr "csshiftjis, shiftjis, sjis, s_jis"

#: ../../library/codecs.rst:1210
msgid "shift_jis_2004"
msgstr "shift_jis_2004"

#: ../../library/codecs.rst:1210
msgid "shiftjis2004, sjis_2004, sjis2004"
msgstr "shiftjis2004, sjis_2004, sjis2004"

#: ../../library/codecs.rst:1213
msgid "shift_jisx0213"
msgstr "shift_jisx0213"

#: ../../library/codecs.rst:1213
msgid "shiftjisx0213, sjisx0213, s_jisx0213"
msgstr "shiftjisx0213, sjisx0213, s_jisx0213"

#: ../../library/codecs.rst:1216
msgid "utf_32"
msgstr "utf_32"

#: ../../library/codecs.rst:1216
msgid "U32, utf32"
msgstr "U32, utf32"

#: ../../library/codecs.rst:1216 ../../library/codecs.rst:1218
#: ../../library/codecs.rst:1220 ../../library/codecs.rst:1222
#: ../../library/codecs.rst:1224 ../../library/codecs.rst:1226
#: ../../library/codecs.rst:1228 ../../library/codecs.rst:1230
#: ../../library/codecs.rst:1232
msgid "all languages"
msgstr "全ての言語"

#: ../../library/codecs.rst:1218
msgid "utf_32_be"
msgstr "utf_32_be"

#: ../../library/codecs.rst:1218
msgid "UTF-32BE"
msgstr "UTF-32BE"

#: ../../library/codecs.rst:1220
msgid "utf_32_le"
msgstr "utf_32_le"

#: ../../library/codecs.rst:1220
msgid "UTF-32LE"
msgstr "UTF-32LE"

#: ../../library/codecs.rst:1222
msgid "utf_16"
msgstr "utf_16"

#: ../../library/codecs.rst:1222
msgid "U16, utf16"
msgstr "U16, utf16"

#: ../../library/codecs.rst:1224
msgid "utf_16_be"
msgstr "utf_16_be"

#: ../../library/codecs.rst:1224
msgid "UTF-16BE"
msgstr "UTF-16BE"

#: ../../library/codecs.rst:1226
msgid "utf_16_le"
msgstr "utf_16_le"

#: ../../library/codecs.rst:1226
msgid "UTF-16LE"
msgstr "UTF-16LE"

#: ../../library/codecs.rst:1228
msgid "utf_7"
msgstr "utf_7"

#: ../../library/codecs.rst:1228
msgid "U7, unicode-1-1-utf-7"
msgstr "U7, unicode-1-1-utf-7"

#: ../../library/codecs.rst:1230
msgid "utf_8"
msgstr "utf_8"

#: ../../library/codecs.rst:1230
msgid "U8, UTF, utf8"
msgstr "U8, UTF, utf8"

#: ../../library/codecs.rst:1232
msgid "utf_8_sig"
msgstr "utf_8_sig"

#: ../../library/codecs.rst:1235
msgid ""
"The utf-16\\* and utf-32\\* encoders no longer allow surrogate code points "
"(``U+D800``--``U+DFFF``) to be encoded. The utf-32\\* decoders no longer "
"decode byte sequences that correspond to surrogate code points."
msgstr ""
"utf-16\\* と utf-32\\* のエンコーダは、サロゲートコードポイント (``U+D800``--``U+DFFF``)  "
"がエンコードされることを許可しなくなりました。utf-32\\* デコーダは、サロゲートコードポイントに対応するバイト列をデコードしなくなりました。"

#: ../../library/codecs.rst:1243
msgid "Python Specific Encodings"
msgstr "Python 特有のエンコーディング"

#: ../../library/codecs.rst:1245
msgid ""
"A number of predefined codecs are specific to Python, so their codec names "
"have no meaning outside Python.  These are listed in the tables below based "
"on the expected input and output types (note that while text encodings are "
"the most common use case for codecs, the underlying codec infrastructure "
"supports arbitrary data transforms rather than just text encodings).  For "
"asymmetric codecs, the stated purpose describes the encoding direction."
msgstr ""
"予め定義された codec のいくつかは Python 特有のものなので、それらの codec 名は Python "
"の外では無意味なものとなります。以下に、想定されている入出力のタイプに基づいて、それらを表にしました（テキストエンコーディングは codec "
"の最も一般的な使用例ですが、その根底にある codec "
"基盤は、ただのテキストエンコーディングというよりも、任意のデータの変換をサポートしていることに注意してください）。非対称的な codec "
"については、その目的がエンコーディングの方向を説明しています。"

#: ../../library/codecs.rst:1253
msgid "Text Encodings"
msgstr "テキストエンコーディング"

#: ../../library/codecs.rst:1255
msgid ""
"The following codecs provide :class:`str` to :class:`bytes` encoding and "
":term:`bytes-like object` to :class:`str` decoding, similar to the Unicode "
"text encodings."
msgstr ""
"次の codec では、 Unicode におけるテキストエンコーディングと同様に、 :class:`str` から :class:`bytes` "
"へのエンコードと、 :term:`bytes-like object` から :class:`str` へのデコードを提供します。"

#: ../../library/codecs.rst:1262 ../../library/codecs.rst:1335
#: ../../library/codecs.rst:1390
msgid "Purpose"
msgstr "目的"

#: ../../library/codecs.rst:1264
msgid "idna"
msgstr "idna"

#: ../../library/codecs.rst:1264
msgid ""
"Implements :rfc:`3490`, see also :mod:`encodings.idna`. Only "
"``errors='strict'`` is supported."
msgstr ""
":rfc:`3490` の実装です。 :mod:`encodings.idna` も参照してください。 ``errors='strict'`` "
"のみがサポートされています。"

#: ../../library/codecs.rst:1270
msgid "mbcs"
msgstr "mbcs"

#: ../../library/codecs.rst:1270
msgid "ansi, dbcs"
msgstr "ansi, dbcs"

#: ../../library/codecs.rst:1270
msgid "Windows only: Encode operand according to the ANSI codepage (CP_ACP)"
msgstr "Windows のみ: 被演算子を ANSI コードページ (CP_ACP) に従ってエンコードします"

#: ../../library/codecs.rst:1274
msgid "oem"
msgstr "oem"

#: ../../library/codecs.rst:1274
msgid "Windows only: Encode operand according to the OEM codepage (CP_OEMCP)"
msgstr "Windows のみ: 被演算子を OEM コードページ (CP_OEMCP) に従ってエンコードします"

#: ../../library/codecs.rst:1280
msgid "palmos"
msgstr "palmos"

#: ../../library/codecs.rst:1280
msgid "Encoding of PalmOS 3.5"
msgstr "PalmOS 3.5 のエンコーディングです"

#: ../../library/codecs.rst:1282
msgid "punycode"
msgstr "punycode"

#: ../../library/codecs.rst:1282
msgid "Implements :rfc:`3492`. Stateful codecs are not supported."
msgstr ":rfc:`3492` の実装です。ステートフル codecs は、サポートされません。"

#: ../../library/codecs.rst:1286
msgid "raw_unicode_escape"
msgstr "raw_unicode_escape"

#: ../../library/codecs.rst:1286
msgid ""
"Latin-1 encoding with ``\\uXXXX`` and ``\\UXXXXXXXX`` for other code points."
" Existing backslashes are not escaped in any way. It is used in the Python "
"pickle protocol."
msgstr ""
"別のコードポイントに ``\\uXXXX`` と ``\\UXXXXXXXX`` を使用する Latin-1 "
"エンコーディングです。既存のバックスラッシュは、いかなる方法でもエスケープされません。Python の pickle プロトコルで使用されます。"

#: ../../library/codecs.rst:1295
msgid "undefined"
msgstr "undefined"

#: ../../library/codecs.rst:1295
msgid ""
"Raise an exception for all conversions, even empty strings. The error "
"handler is ignored."
msgstr "空文字列を含む全ての変換に対して例外を送出します。エラーハンドラは無視されます。"

#: ../../library/codecs.rst:1300
msgid "unicode_escape"
msgstr "unicode_escape"

#: ../../library/codecs.rst:1300
msgid ""
"Encoding suitable as the contents of a Unicode literal in ASCII-encoded "
"Python source code, except that quotes are not escaped. Decodes from Latin-1"
" source code. Beware that Python source code actually uses UTF-8 by default."
msgstr ""
"ASCII でエンコードされた Python ソースコード内の、Unicode "
"リテラルに適したエンコーディングです。ただし、引用符はエスケープされません。Latin-1 ソースコードからデコードします。実際には、Python "
"のソースコードはデフォルトでは UTF-8 を使用することに注意してください。"

#: ../../library/codecs.rst:1311
msgid "unicode_internal"
msgstr "unicode_internal"

#: ../../library/codecs.rst:1311
msgid ""
"Return the internal representation of the operand. Stateful codecs are not "
"supported."
msgstr "被演算子の内部表現を返します。ステートフル codecs は、サポートされません。"

#: ../../library/codecs.rst:1316
msgid "This representation is obsoleted by :pep:`393`."
msgstr "この表現は :pep:`393` により廃止されました。"

#: ../../library/codecs.rst:1325
msgid "Binary Transforms"
msgstr "バイナリ変換 (Binary Transforms)"

#: ../../library/codecs.rst:1327
msgid ""
"The following codecs provide binary transforms: :term:`bytes-like object` to"
" :class:`bytes` mappings.  They are not supported by :meth:`bytes.decode` "
"(which only produces :class:`str` output)."
msgstr ""
"以下の codec は、:term:`bytes-like object` から :class:`bytes` "
"マッピングへのバイナリ変換を提供します。:meth:`bytes.decode` はこの変換をサポートしておらず、 :class:`str`  "
"を出力するだけです。"

#: ../../library/codecs.rst:1335
msgid "Encoder / decoder"
msgstr "エンコーダ / デコーダ"

#: ../../library/codecs.rst:1337
msgid "base64_codec [#b64]_"
msgstr "base64_codec [#b64]_"

#: ../../library/codecs.rst:1337
msgid "base64, base_64"
msgstr "base64, base_64"

#: ../../library/codecs.rst:1337
msgid ""
"Convert operand to multiline MIME base64 (the result always includes a "
"trailing ``'\\n'``)"
msgstr "被演算子をマルチラインの MIME base64 に変換します (結果は常に末尾の ``'\\n'`` を含みます)"

#: ../../library/codecs.rst:1342
msgid ""
"accepts any :term:`bytes-like object` as input for encoding and decoding"
msgstr "任意の :term:`bytes-like object` をエンコードとデコード用の入力として受け取ります。"

#: ../../library/codecs.rst:1337
msgid ":meth:`base64.encodebytes` / :meth:`base64.decodebytes`"
msgstr ":meth:`base64.encodebytes` / :meth:`base64.decodebytes`"

#: ../../library/codecs.rst:1348
msgid "bz2_codec"
msgstr "bz2_codec"

#: ../../library/codecs.rst:1348
msgid "bz2"
msgstr "bz2"

#: ../../library/codecs.rst:1348
msgid "Compress the operand using bz2"
msgstr "被演算子をbz2を使って圧縮します"

#: ../../library/codecs.rst:1348
msgid ":meth:`bz2.compress` / :meth:`bz2.decompress`"
msgstr ":meth:`bz2.compress` / :meth:`bz2.decompress`"

#: ../../library/codecs.rst:1351
msgid "hex_codec"
msgstr "hex_codec"

#: ../../library/codecs.rst:1351
msgid "hex"
msgstr "hex"

#: ../../library/codecs.rst:1351
msgid ""
"Convert operand to hexadecimal representation, with two digits per byte"
msgstr "被演算子をバイトあたり 2 桁の 16 進数の表現に変換します"

#: ../../library/codecs.rst:1351
msgid ":meth:`binascii.b2a_hex` / :meth:`binascii.a2b_hex`"
msgstr ":meth:`binascii.b2a_hex` / :meth:`binascii.a2b_hex`"

#: ../../library/codecs.rst:1356
msgid "quopri_codec"
msgstr "quopri_codec"

#: ../../library/codecs.rst:1356
msgid "quopri, quotedprintable, quoted_printable"
msgstr "quopri, quotedprintable, quoted_printable"

#: ../../library/codecs.rst:1356
msgid "Convert operand to MIME quoted printable"
msgstr "被演算子を MIME quoted printable 形式に変換します"

#: ../../library/codecs.rst:1356
msgid ":meth:`quopri.encode` with ``quotetabs=True`` / :meth:`quopri.decode`"
msgstr ""
"``quotetabs=True`` を指定した :meth:`quopri.encode` / :meth:`quopri.decode`"

#: ../../library/codecs.rst:1360
msgid "uu_codec"
msgstr "uu_codec"

#: ../../library/codecs.rst:1360
msgid "uu"
msgstr "uu"

#: ../../library/codecs.rst:1360
msgid "Convert the operand using uuencode"
msgstr "被演算子を uuencode を用いて変換します"

#: ../../library/codecs.rst:1360
msgid ":meth:`uu.encode` / :meth:`uu.decode`"
msgstr ":meth:`uu.encode` / :meth:`uu.decode`"

#: ../../library/codecs.rst:1363
msgid "zlib_codec"
msgstr "zlib_codec"

#: ../../library/codecs.rst:1363
msgid "zip, zlib"
msgstr "zip, zlib"

#: ../../library/codecs.rst:1363
msgid "Compress the operand using gzip"
msgstr "被演算子を gzip を用いて圧縮します"

#: ../../library/codecs.rst:1363
msgid ":meth:`zlib.compress` / :meth:`zlib.decompress`"
msgstr ":meth:`zlib.compress` / :meth:`zlib.decompress`"

#: ../../library/codecs.rst:1367
msgid ""
"In addition to :term:`bytes-like objects <bytes-like object>`, "
"``'base64_codec'`` also accepts ASCII-only instances of :class:`str` for "
"decoding"
msgstr ""
":term:`バイト様オブジェクト <bytes-like object>` に加えて、``'base64_codec'`` も "
":class:`str` の ASCII のみのインスタンスをデコード用に受け入れるようになりました"

#: ../../library/codecs.rst:1371
msgid "Restoration of the binary transforms."
msgstr "バイナリ変換が復活しました。(訳注: 2.x にはあったものが 3.0 で削除されていた。)"

#: ../../library/codecs.rst:1374
msgid "Restoration of the aliases for the binary transforms."
msgstr "バイナリ変換のエイリアスが復活しました。(訳注: 2.x にはあったエイリアス。3.2 でエイリアスは復活しなかった。)"

#: ../../library/codecs.rst:1381
msgid "Text Transforms"
msgstr "テキスト変換 (Text Transforms)"

#: ../../library/codecs.rst:1383
msgid ""
"The following codec provides a text transform: a :class:`str` to "
":class:`str` mapping.  It is not supported by :meth:`str.encode` (which only"
" produces :class:`bytes` output)."
msgstr ""
"以下の codec は、:class:`str` から :class:`str` "
"マッピングへのテキスト変換を提供します。:meth:`str.encode` はこの変換をサポートしておらず、 :class:`bytes`  "
"を出力するだけです。"

#: ../../library/codecs.rst:1392
msgid "rot_13"
msgstr "rot_13"

#: ../../library/codecs.rst:1392
msgid "rot13"
msgstr "rot13"

#: ../../library/codecs.rst:1392
msgid "Returns the Caesar-cypher encryption of the operand"
msgstr "被演算子のシーザー暗号 (Caesar-cypher) を返します"

#: ../../library/codecs.rst:1396
msgid "Restoration of the ``rot_13`` text transform."
msgstr "``rot_13`` テキスト変換が復活しました。(訳注: 2.x にはあったものが 3.0 で削除されていた。)"

#: ../../library/codecs.rst:1399
msgid "Restoration of the ``rot13`` alias."
msgstr "``rot13`` エイリアスが復活しました。(訳注: 2.x にはあったエイリアス。3.2 でエイリアスは復活しなかった。)"

#: ../../library/codecs.rst:1404
msgid ""
":mod:`encodings.idna` --- Internationalized Domain Names in Applications"
msgstr ":mod:`encodings.idna` --- アプリケーションにおける国際化ドメイン名 (IDNA)"

#: ../../library/codecs.rst:1410
msgid ""
"This module implements :rfc:`3490` (Internationalized Domain Names in "
"Applications) and :rfc:`3492` (Nameprep: A Stringprep Profile for "
"Internationalized Domain Names (IDN)). It builds upon the ``punycode`` "
"encoding and :mod:`stringprep`."
msgstr ""
"このモジュールでは :rfc:`3490` (アプリケーションにおける国際化ドメイン名、 IDNA: Internationalized Domain "
"Names in Applications) および :rfc:`3492` (Nameprep: 国際化ドメイン名 (IDN) のための "
"stringprep プロファイル) を実装しています。このモジュールは ``punycode`` エンコーディングおよび "
":mod:`stringprep` の上に構築されています。"

#: ../../library/codecs.rst:1415
msgid ""
"These RFCs together define a protocol to support non-ASCII characters in "
"domain names. A domain name containing non-ASCII characters (such as "
"``www.Alliancefrançaise.nu``) is converted into an ASCII-compatible encoding"
" (ACE, such as ``www.xn--alliancefranaise-npb.nu``). The ACE form of the "
"domain name is then used in all places where arbitrary characters are not "
"allowed by the protocol, such as DNS queries, HTTP :mailheader:`Host` "
"fields, and so on. This conversion is carried out in the application; if "
"possible invisible to the user: The application should transparently convert"
" Unicode domain labels to IDNA on the wire, and convert back ACE labels to "
"Unicode before presenting them to the user."
msgstr ""
"これらの RFC はともに、非 ASCII 文字の入ったドメイン名をサポートするためのプロトコルを定義しています。 "
"(``www.Alliancefrançaise.nu`` のような) 非 ASCII 文字を含むドメイン名は、 ASCII "
"と互換性のあるエンコーディング (ACE、 ``www.xn--alliancefranaise-npb.nu`` のような形式) "
"に変換されます。ドメイン名の ACE 形式は、 DNS クエリ、 HTTP :mailheader:`Host` "
"フィールドなどといった、プロトコル中で任意の文字を使えないような全ての局面で用いられます。この変換はアプリケーション内で行われます; "
"可能ならユーザからは不可視となります: アプリケーションは Unicode ドメインラベルをネットワークに載せる際に IDNA に、 ACE "
"ドメインラベルをユーザに提供する前に Unicode に、それぞれ透過的に変換しなければなりません。"

#: ../../library/codecs.rst:1426
msgid ""
"Python supports this conversion in several ways:  the ``idna`` codec "
"performs conversion between Unicode and ACE, separating an input string into"
" labels based on the separator characters defined in :rfc:`section 3.1 of "
"RFC 3490 <3490#section-3.1>` and converting each label to ACE as required, "
"and conversely separating an input byte string into labels based on the "
"``.`` separator and converting any ACE labels found into unicode.  "
"Furthermore, the :mod:`socket` module transparently converts Unicode host "
"names to ACE, so that applications need not be concerned about converting "
"host names themselves when they pass them to the socket module. On top of "
"that, modules that have host names as function parameters, such as "
":mod:`http.client` and :mod:`ftplib`, accept Unicode host names "
"(:mod:`http.client` then also transparently sends an IDNA hostname in the "
":mailheader:`Host` field if it sends that field at all)."
msgstr ""
"Python ではこの変換をいくつかの方法でサポートします: ``idna`` codec は Unicode と ACE 間の変換を行い、入力文字列を"
" :rfc:`RFC 3490 の section 3.1 <3490#section-3.1>` "
"で定義されている区切り文字に基づいてラベルに分解し、各ラベルを要求通りに ACE に変換します。逆に、入力のバイト文字列を ``.`` "
"区切り文字でラベルに分解し、 ACE ラベルを Unicode に変換します。さらに、 :mod:`socket` モジュールは Unicode "
"ホスト名を ACE に透過的に変換するため、アプリケーションはホスト名を :mod:`socket` "
"モジュールに渡す際にホスト名の変換に煩わされることがありません。その上で、ホスト名を関数パラメタとして持つ、 :mod:`http.client` や "
":mod:`ftplib` のようなモジュールでは Unicode ホスト名を受理します (:mod:`http.client` でもまた、 "
":mailheader:`Host` フィールドにある IDNA ホスト名を、フィールド全体を送信する場合に透過的に送信します)。"

#: ../../library/codecs.rst:1439
msgid ""
"When receiving host names from the wire (such as in reverse name lookup), no"
" automatic conversion to Unicode is performed: Applications wishing to "
"present such host names to the user should decode them to Unicode."
msgstr ""
"(逆引きなどによって) ネットワーク越しにホスト名を受信する際、Unicode への自動変換は行われません: "
"こうしたホスト名をユーザに提供したいアプリケーションでは、Unicode にデコードしてやる必要があります。"

#: ../../library/codecs.rst:1443
msgid ""
"The module :mod:`encodings.idna` also implements the nameprep procedure, "
"which performs certain normalizations on host names, to achieve case-"
"insensitivity of international domain names, and to unify similar "
"characters. The nameprep functions can be used directly if desired."
msgstr ""
":mod:`encodings.idna` ではまた、 nameprep 手続きを実装しています。 nameprep "
"はホスト名に対してある正規化を行って、国際化ドメイン名で大小文字を区別しないようにするとともに、類似の文字を一元化します。 nameprep "
"関数は必要なら直接使うこともできます。"

#: ../../library/codecs.rst:1451
msgid ""
"Return the nameprepped version of *label*. The implementation currently "
"assumes query strings, so ``AllowUnassigned`` is true."
msgstr ""
"*label* を nameprep したバージョンを返します。現在の実装ではクエリ文字列を仮定しているので、``AllowUnassigned`` "
"は真です。"

#: ../../library/codecs.rst:1457
msgid ""
"Convert a label to ASCII, as specified in :rfc:`3490`. ``UseSTD3ASCIIRules``"
" is assumed to be false."
msgstr ""
":rfc:`3490` 仕様に従ってラベルを ASCIIに変換します。 ``UseSTD3ASCIIRules`` は偽であると仮定します。"

#: ../../library/codecs.rst:1463
msgid "Convert a label to Unicode, as specified in :rfc:`3490`."
msgstr ":rfc:`3490` 仕様に従ってラベルを Unicode に変換します。"

#: ../../library/codecs.rst:1467
msgid ":mod:`encodings.mbcs` --- Windows ANSI codepage"
msgstr ":mod:`encodings.mbcs` --- Windows ANSI コードページ"

#: ../../library/codecs.rst:1472
msgid "Encode operand according to the ANSI codepage (CP_ACP)."
msgstr "ANSI コードページ (CP_ACP) に対応するエンコードオペランド。"

#: ../../library/codecs.rst:1474
msgid "Availability: Windows only."
msgstr "利用可能な環境: Windows のみ。"

#: ../../library/codecs.rst:1476
msgid "Support any error handler."
msgstr "任意のエラーハンドラのサポート。"

#: ../../library/codecs.rst:1479
msgid ""
"Before 3.2, the *errors* argument was ignored; ``'replace'`` was always used"
" to encode, and ``'ignore'`` to decode."
msgstr ""
"3.2 以前は *errors* 引数は無視されました; エンコードには常に ``'replace'`` が、デコードには ``'ignore'`` "
"が使われました。"

#: ../../library/codecs.rst:1485
msgid ":mod:`encodings.utf_8_sig` --- UTF-8 codec with BOM signature"
msgstr ":mod:`encodings.utf_8_sig` --- BOM 印付き UTF-8"

#: ../../library/codecs.rst:1491
msgid ""
"This module implements a variant of the UTF-8 codec: On encoding a UTF-8 "
"encoded BOM will be prepended to the UTF-8 encoded bytes. For the stateful "
"encoder this is only done once (on the first write to the byte stream).  For"
" decoding an optional UTF-8 encoded BOM at the start of the data will be "
"skipped."
msgstr ""
"このモジュールは UTF-8 codec の変種を実装します。エンコーディング時は、UTF-8 でエンコードしたバイト列の前に UTF-8 "
"でエンコードした BOM を追加します。これは内部状態を持つエンコーダで、この動作は (バイトストリームの最初の書き込み時に) "
"一度だけ行なわれます。デコーディング時は、データの最初に UTF-8 でエンコードされた BOM があれば、それをスキップします。"