codecs.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# tomo, 2019
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 18:48+0900\n"
"PO-Revision-Date: 2018-06-29 17:39+0000\n"
"Last-Translator: tomo, 2019\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../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:324
#: ../../library/codecs.rst:357
msgid "Value"
msgstr "値"

#: ../../library/codecs.rst:301 ../../library/codecs.rst:324
#: ../../library/codecs.rst:357
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:326
msgid "``'replace'``"
msgstr "``'replace'``"

#: ../../library/codecs.rst:326
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:333
msgid "``'xmlcharrefreplace'``"
msgstr "``'xmlcharrefreplace'``"

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

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

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

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

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

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

#: ../../library/codecs.rst:345
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:354
msgid ""
"In addition, the following error handler is specific to the given codecs:"
msgstr "さらに、次のエラーハンドラは与えられた codec に特有です:"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:437
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:444
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:450
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:460
msgid "Stateless Encoding and Decoding"
msgstr "ステートレスなエンコードとデコード"

#: ../../library/codecs.rst:462
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:468
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:473 ../../library/codecs.rst:495
msgid ""
"The *errors* argument defines the error handling to apply. It defaults to "
"``'strict'`` handling."
msgstr ""
"*errors* 引数は適用するエラー処理を定義します。``'strict'`` 処理がデフォルト"
"です。"

#: ../../library/codecs.rst:476
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:480
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:486
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:491
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:498
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:502
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:507
msgid "Incremental Encoding and Decoding"
msgstr "インクリメンタルなエンコードとデコード"

#: ../../library/codecs.rst:509
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:517
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:526
msgid "IncrementalEncoder Objects"
msgstr "IncrementalEncoder オブジェクト"

#: ../../library/codecs.rst:528
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:535
msgid "Constructor for an :class:`IncrementalEncoder` instance."
msgstr ":class:`IncrementalEncoder` インスタンスのコンストラクタ。"

#: ../../library/codecs.rst:537
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:541
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:545
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:553
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:560
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:567
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:576
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:583
msgid "IncrementalDecoder Objects"
msgstr "IncrementalDecoder オブジェクト"

#: ../../library/codecs.rst:585
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:592
msgid "Constructor for an :class:`IncrementalDecoder` instance."
msgstr ":class:`IncrementalDecoder` インスタンスのコンストラクタ。"

#: ../../library/codecs.rst:594
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:598
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:602
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:610
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:621
msgid "Reset the decoder to the initial state."
msgstr "デコーダを初期状態にリセットします。"

#: ../../library/codecs.rst:626
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:641
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:646
msgid "Stream Encoding and Decoding"
msgstr "ストリームのエンコードとデコード"

#: ../../library/codecs.rst:649
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:657
msgid "StreamWriter Objects"
msgstr "StreamWriter オブジェクト"

#: ../../library/codecs.rst:659
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:666
msgid "Constructor for a :class:`StreamWriter` instance."
msgstr ":class:`StreamWriter` インスタンスのコンストラクタです。"

#: ../../library/codecs.rst:668
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:672
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:675
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:679
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:685
msgid "Writes the object's contents encoded to the stream."
msgstr "*object* の内容をエンコードしてストリームに書き出します。"

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

#: ../../library/codecs.rst:699
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:704
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:711
msgid "StreamReader Objects"
msgstr "StreamReader オブジェクト"

#: ../../library/codecs.rst:713
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:720
msgid "Constructor for a :class:`StreamReader` instance."
msgstr ":class:`StreamReader` インスタンスのコンストラクタです。"

#: ../../library/codecs.rst:722
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:726
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:729
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:733
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:737
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:743
msgid "Decodes data from the stream and returns the resulting object."
msgstr ""
"ストリームからのデータをデコードし、デコード済のオブジェクトを返します。"

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

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

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

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

#: ../../library/codecs.rst:783
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:786
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:792
msgid "Resets the codec buffers used for keeping state."
msgstr "状態保持に使われた codec のバッファをリセットします。"

#: ../../library/codecs.rst:794
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:798
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:804
msgid "StreamReaderWriter Objects"
msgstr "StreamReaderWriter オブジェクト"

#: ../../library/codecs.rst:806
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:809 ../../library/codecs.rst:833
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:815
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:820
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:828
msgid "StreamRecoder Objects"
msgstr "StreamRecoder オブジェクト"

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

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

#: ../../library/codecs.rst:858
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:866
msgid "Encodings and Unicode"
msgstr "エンコーディングと Unicode"

#: ../../library/codecs.rst:868
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:878
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:886
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:893
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:919
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:928
msgid "Range"
msgstr "範囲"

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:941
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:945
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:961
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:974
msgid "Standard Encodings"
msgstr "標準エンコーディング"

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

#: ../../library/codecs.rst:997
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:1002
msgid "an ISO 8859 codeset"
msgstr "ISO 8859 コードセット"

#: ../../library/codecs.rst:1004
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:1007
msgid "an IBM EBCDIC code page"
msgstr "IBM EBCDIC コードページ"

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

#: ../../library/codecs.rst:1014 ../../library/codecs.rst:1270
#: ../../library/codecs.rst:1343 ../../library/codecs.rst:1398
msgid "Codec"
msgstr "Codec"

#: ../../library/codecs.rst:1014 ../../library/codecs.rst:1270
#: ../../library/codecs.rst:1343 ../../library/codecs.rst:1398
msgid "Aliases"
msgstr "別名"

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

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

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

#: ../../library/codecs.rst:1016 ../../library/codecs.rst:1022
#: ../../library/codecs.rst:1030
msgid "English"
msgstr "英語"

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

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

#: ../../library/codecs.rst:1018 ../../library/codecs.rst:1020
#: ../../library/codecs.rst:1078
msgid "Traditional Chinese"
msgstr "繁体字中国語"

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1028 ../../library/codecs.rst:1048
#: ../../library/codecs.rst:1058 ../../library/codecs.rst:1101
#: ../../library/codecs.rst:1169
msgid "Hebrew"
msgstr "ヘブライ語"

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

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

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

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

#: ../../library/codecs.rst:1032 ../../library/codecs.rst:1041
#: ../../library/codecs.rst:1052 ../../library/codecs.rst:1088
#: ../../library/codecs.rst:1095 ../../library/codecs.rst:1181
#: ../../library/codecs.rst:1208
msgid "Western Europe"
msgstr "西ヨーロッパ言語"

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

#: ../../library/codecs.rst:1035 ../../library/codecs.rst:1062
#: ../../library/codecs.rst:1103 ../../library/codecs.rst:1165
msgid "Arabic"
msgstr "アラビア語"

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

#: ../../library/codecs.rst:1037 ../../library/codecs.rst:1068
#: ../../library/codecs.rst:1072 ../../library/codecs.rst:1097
#: ../../library/codecs.rst:1167 ../../library/codecs.rst:1202
msgid "Greek"
msgstr "ギリシャ語"

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

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

#: ../../library/codecs.rst:1039 ../../library/codecs.rst:1105
#: ../../library/codecs.rst:1160 ../../library/codecs.rst:1177
msgid "Baltic languages"
msgstr "バルト沿岸国"

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

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

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

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

#: ../../library/codecs.rst:1043 ../../library/codecs.rst:1090
#: ../../library/codecs.rst:1156 ../../library/codecs.rst:1206
msgid "Central and Eastern Europe"
msgstr "中央および東ヨーロッパ"

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

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

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

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

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

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

#: ../../library/codecs.rst:1050 ../../library/codecs.rst:1082
#: ../../library/codecs.rst:1099 ../../library/codecs.rst:1171
#: ../../library/codecs.rst:1210
msgid "Turkish"
msgstr "トルコ語"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1066 ../../library/codecs.rst:1187
msgid "Russian"
msgstr "ロシア語"

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1074 ../../library/codecs.rst:1114
#: ../../library/codecs.rst:1116 ../../library/codecs.rst:1118
#: ../../library/codecs.rst:1135 ../../library/codecs.rst:1138
#: ../../library/codecs.rst:1143 ../../library/codecs.rst:1146
#: ../../library/codecs.rst:1148 ../../library/codecs.rst:1215
#: ../../library/codecs.rst:1218 ../../library/codecs.rst:1221
msgid "Japanese"
msgstr "日本語"

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

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

#: ../../library/codecs.rst:1076 ../../library/codecs.rst:1120
#: ../../library/codecs.rst:1150 ../../library/codecs.rst:1185
msgid "Korean"
msgstr "韓国語"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1120
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:1124
msgid "gb2312"
msgstr "gb2312"

#: ../../library/codecs.rst:1124
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:1124 ../../library/codecs.rst:1133
msgid "Simplified Chinese"
msgstr "簡体字中国語"

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

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

#: ../../library/codecs.rst:1129 ../../library/codecs.rst:1131
msgid "Unified Chinese"
msgstr "Unified Chinese"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1153
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:1153
msgid "West Europe"
msgstr "西ヨーロッパ"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1195 ../../library/codecs.rst:1212
msgid "Kazakh"
msgstr "カザフ"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1224 ../../library/codecs.rst:1226
#: ../../library/codecs.rst:1228 ../../library/codecs.rst:1230
#: ../../library/codecs.rst:1232 ../../library/codecs.rst:1234
#: ../../library/codecs.rst:1236 ../../library/codecs.rst:1238
#: ../../library/codecs.rst:1240
msgid "all languages"
msgstr "全ての言語"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1243
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:1251
msgid "Python Specific Encodings"
msgstr "Python 特有のエンコーディング"

#: ../../library/codecs.rst:1253
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:1261
msgid "Text Encodings"
msgstr "テキストエンコーディング"

#: ../../library/codecs.rst:1263
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:1270 ../../library/codecs.rst:1343
#: ../../library/codecs.rst:1398
msgid "Purpose"
msgstr "目的"

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

#: ../../library/codecs.rst:1272
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:1278
msgid "mbcs"
msgstr "mbcs"

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1294
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:1303
msgid "undefined"
msgstr "undefined"

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

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

#: ../../library/codecs.rst:1308
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:1319
msgid "unicode_internal"
msgstr "unicode_internal"

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

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

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

#: ../../library/codecs.rst:1335
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:1343
msgid "Encoder / decoder"
msgstr "エンコーダ / デコーダ"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1391
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:1400
msgid "rot_13"
msgstr "rot_13"

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

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

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

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

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

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

#: ../../library/codecs.rst:1465
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:1471
msgid "Convert a label to Unicode, as specified in :rfc:`3490`."
msgstr ":rfc:`3490` 仕様に従ってラベルを Unicode に変換します。"

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

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

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

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

#: ../../library/codecs.rst:1487
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:1493
msgid ":mod:`encodings.utf_8_sig` --- UTF-8 codec with BOM signature"
msgstr ":mod:`encodings.utf_8_sig` --- BOM 印付き UTF-8"

#: ../../library/codecs.rst:1499
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 があれば、それをスキップします。"