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:
# mnamihdk, 2017
# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2017
# Nozomu Kaneko <nozom.kaneko@gmail.com>, 2017
# Inada Naoki <songofacandy@gmail.com>, 2017
# Shun Sakurai, 2017
# 秘湯 <xwhhsprings@gmail.com>, 2017
# Masato HASHIMOTO <cabezon.hashimoto@gmail.com>, 2017
# Arihiro TAKASE, 2017
# Osamu NAKAMURA, 2017
# tomo, 2019
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-02-09 12:40+0000\n"
"PO-Revision-Date: 2017-02-16 23:02+0000\n"
"Last-Translator: tomo, 2019\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:197
msgid ""
"*buffering* has the same meaning as for the built-in :func:`open` function. "
"It defaults to -1 which means that the default buffer size will be used."
msgstr ""

#: ../../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 ""

#: ../../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 ../../library/codecs.rst:1268
#: ../../library/codecs.rst:1335 ../../library/codecs.rst:1390
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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 decoder to *state*. *state* must be a decoder state "
"returned by :meth:`getstate`."
msgstr ""
"デコーダの状態を *state* にセットします。\n"
"*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 ""

#: ../../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 :meth:`decode` method and are"
" included in the list entries if *keepends* is true."
msgstr ""

#: ../../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, e.g., from Latin-1"
" to UTF-8 and back."
msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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:1268
#: ../../library/codecs.rst:1335 ../../library/codecs.rst:1390
msgid "Codec"
msgstr "Codec"

#: ../../library/codecs.rst:1014 ../../library/codecs.rst:1268
#: ../../library/codecs.rst:1335 ../../library/codecs.rst:1390
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:1164
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:1148
#: ../../library/codecs.rst:1176 ../../library/codecs.rst:1203
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:1160
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:1162 ../../library/codecs.rst:1197
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:1155 ../../library/codecs.rst:1172
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:1151 ../../library/codecs.rst:1201
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:1157 ../../library/codecs.rst:1194
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:1166
#: ../../library/codecs.rst:1205
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:1199
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:1182
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:1109
#: ../../library/codecs.rst:1111 ../../library/codecs.rst:1113
#: ../../library/codecs.rst:1130 ../../library/codecs.rst:1133
#: ../../library/codecs.rst:1138 ../../library/codecs.rst:1141
#: ../../library/codecs.rst:1143 ../../library/codecs.rst:1210
#: ../../library/codecs.rst:1213 ../../library/codecs.rst:1216
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:1115
#: ../../library/codecs.rst:1145 ../../library/codecs.rst:1180
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:1188
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 "euc_jp"
msgstr "euc_jp"

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1124 ../../library/codecs.rst:1126
msgid "Unified Chinese"
msgstr "Unified Chinese"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1148
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:1151
msgid "iso8859_2"
msgstr "iso8859_2"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1190 ../../library/codecs.rst:1207
msgid "Kazakh"
msgstr "カザフ"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1219 ../../library/codecs.rst:1221
#: ../../library/codecs.rst:1223 ../../library/codecs.rst:1225
#: ../../library/codecs.rst:1227 ../../library/codecs.rst:1229
#: ../../library/codecs.rst:1231 ../../library/codecs.rst:1233
#: ../../library/codecs.rst:1235
msgid "all languages"
msgstr "全ての言語"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1238
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:1244
msgid "``cp65001`` is now an alias to ``utf_8``."
msgstr ""

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

#: ../../library/codecs.rst:1251
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 meaning describes the encoding direction."
msgstr ""

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

#: ../../library/codecs.rst:1261
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
msgid "idna"
msgstr "idna"

#: ../../library/codecs.rst:1270
msgid ""
"Implement :rfc:`3490`, see also :mod:`encodings.idna`. Only "
"``errors='strict'`` is supported."
msgstr ""

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

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

#: ../../library/codecs.rst:1276
msgid ""
"Windows only: Encode the operand according to the ANSI codepage (CP_ACP)."
msgstr ""

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

#: ../../library/codecs.rst:1280
msgid ""
"Windows only: Encode the operand according to the OEM codepage (CP_OEMCP)."
msgstr ""

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

#: ../../library/codecs.rst:1286
msgid "Encoding of PalmOS 3.5."
msgstr ""

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

#: ../../library/codecs.rst:1288
msgid "Implement :rfc:`3492`. Stateful codecs are not supported."
msgstr ""

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

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

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

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

#: ../../library/codecs.rst:1306
msgid ""
"Encoding suitable as the contents of a Unicode literal in ASCII-encoded "
"Python source code, except that quotes are not escaped. Decode from Latin-1 "
"source code. Beware that Python source code actually uses UTF-8 by default."
msgstr ""

#: ../../library/codecs.rst:1318
msgid "\"unicode_internal\" codec is removed."
msgstr ""

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

#: ../../library/codecs.rst:1327
msgid ""
"The following codecs provide binary transforms: :term:`bytes-like object` to"
" :class:`bytes` mappings. They are not supported by :meth:`bytes.decode` "
"(which only produces :class:`str` output)."
msgstr ""

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

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

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

#: ../../library/codecs.rst:1337
msgid ""
"Convert the operand to multiline MIME base64 (the result always includes a "
"trailing ``'\\n'``)."
msgstr ""

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

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

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

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

#: ../../library/codecs.rst:1348
msgid "Compress the operand using bz2."
msgstr ""

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

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

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

#: ../../library/codecs.rst:1351
msgid ""
"Convert the operand to hexadecimal representation, with two digits per byte."
msgstr ""

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

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

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

#: ../../library/codecs.rst:1356
msgid "Convert the operand to MIME quoted printable."
msgstr ""

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

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

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

#: ../../library/codecs.rst:1360
msgid "Convert the operand using uuencode."
msgstr ""

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

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

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

#: ../../library/codecs.rst:1363
msgid "Compress the operand using gzip."
msgstr ""

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

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

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

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

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

#: ../../library/codecs.rst:1383
msgid ""
"The following codec provides a text transform: a :class:`str` to "
":class:`str` mapping. It is not supported by :meth:`str.encode` (which only "
"produces :class:`bytes` output)."
msgstr ""

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

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

#: ../../library/codecs.rst:1392
msgid "Return the Caesar-cypher encryption of the operand."
msgstr ""

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

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

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

#: ../../library/codecs.rst:1411
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:1416
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:1427
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 ""

#: ../../library/codecs.rst:1440
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 ""

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

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

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

#: ../../library/codecs.rst:1473
msgid "This module implements the ANSI codepage (CP_ACP)."
msgstr ""

#: ../../library/codecs.rst:1476
msgid ":ref:`Availability <availability>`: Windows only."
msgstr ":ref:`利用可能な環境 <availability>`: Windows のみ。"

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

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

#: ../../library/codecs.rst:1492
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). On "
"decoding, an optional UTF-8 encoded BOM at the start of the data will be "
"skipped."
msgstr ""