codecs.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# tomo, 2017
# 秘湯 <xwhhsprings@gmail.com>, 2016
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 01:01+0900\n"
"PO-Revision-Date: 2019-09-01 05:18+0000\n"
"Last-Translator: tomo\n"
"Language-Team: Japanese (http://www.transifex.com/python-doc/python-27/"
"language/ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

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

#: ../../library/codecs.rst:20
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."
msgstr ""
"このモジュールでは、内部的な Python codec レジストリに対するアクセス手段を提"
"供しています。codec レジストリは、標準の Python codec(エンコーダとデコーダ)の"
"基底クラスを定義し、 codec およびエラー処理の検索手順を管理しています。"

#: ../../library/codecs.rst:24
msgid "It defines the following functions:"
msgstr ":mod:`codecs` では以下の関数を定義しています:"

#: ../../library/codecs.rst:28
msgid ""
"Encodes *obj* using the codec registered for *encoding*. The default "
"encoding is ``'ascii'``."
msgstr ""
"*encoding* に記載された codec を使用して *obj* をエンコードします。デフォルト"
"のエンコーディングは ``'ascii'`` です。"

#: ../../library/codecs.rst:31
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:41
msgid ""
"Decodes *obj* using the codec registered for *encoding*. The default "
"encoding is ``'ascii'``."
msgstr ""
"*encoding* に記載された codec を使用して *obj* をデコードします。デフォルトの"
"エンコーディングは ``'ascii'`` です。"

#: ../../library/codecs.rst:44
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:54
msgid ""
"Register a codec search function. Search functions are expected to take one "
"argument, the encoding name in all lower case letters, and return a :class:"
"`CodecInfo` object having the following attributes:"
msgstr ""
"codec 検索関数を登録します。検索関数は第 1 引数にアルファベットの小文字から成"
"るエンコーディング名を取り、以下の属性を持つ :class:`CodecInfo` オブジェクト"
"を返します:"

#: ../../library/codecs.rst:58
msgid "``name`` The name of the encoding;"
msgstr "``name`` エンコーディング名;"

#: ../../library/codecs.rst:60
msgid "``encode`` The stateless encoding function;"
msgstr "``encode`` 内部状態を持たないエンコード関数;"

#: ../../library/codecs.rst:62
msgid "``decode`` The stateless decoding function;"
msgstr "``decode`` 内部状態を持たないデコード関数;"

#: ../../library/codecs.rst:64
msgid ""
"``incrementalencoder`` An incremental encoder class or factory function;"
msgstr "``incrementalencoder`` 漸増的エンコーダクラスまたはファクトリ関数;"

#: ../../library/codecs.rst:66
msgid ""
"``incrementaldecoder`` An incremental decoder class or factory function;"
msgstr "``incrementaldecoder`` 漸増的デコーダクラスまたはファクトリ関数;"

#: ../../library/codecs.rst:68
msgid "``streamwriter`` A stream writer class or factory function;"
msgstr "``streamwriter`` ストリームライタクラスまたはファクトリ関数;"

#: ../../library/codecs.rst:70
msgid "``streamreader`` A stream reader class or factory function."
msgstr "``streamreader`` ストリームリーダクラスまたはファクトリ関数。"

#: ../../library/codecs.rst:72
msgid "The various functions or classes take the following arguments:"
msgstr "種々の関数やクラスが以下の引数をとります:"

#: ../../library/codecs.rst:74
msgid ""
"*encode* and *decode*: These must be functions or methods which have the "
"same interface as the :meth:`~Codec.encode`/:meth:`~Codec.decode` methods of "
"Codec instances (see :ref:`Codec Interface <codec-objects>`). The functions/"
"methods are expected to work in a stateless mode."
msgstr ""
"*encode* と *decode*: これらの引数は、 Codec インスタンスの :meth:`~Codec."
"encode` と :meth:`~Codec.decode` と同じインタフェースを持つ関数、またはメソッ"
"ドでなければなりません (:ref:`Codec Interface <codec-objects>` 参照) 。これら"
"の関数・メソッドは内部状態を持たずに動作する (stateless mode) と想定されてい"
"ます。"

#: ../../library/codecs.rst:79
msgid ""
"*incrementalencoder* and *incrementaldecoder*: These have to be factory "
"functions providing the following interface:"
msgstr ""
"*incrementalencoder* と *incrementaldecoder*: これらは以下のインタフェースを"
"持つファクトリ関数でなければなりません:"

#: ../../library/codecs.rst:82
msgid "``factory(errors='strict')``"
msgstr "``factory(errors='strict')``"

#: ../../library/codecs.rst:84
msgid ""
"The factory functions must return objects providing the interfaces defined "
"by the base classes :class:`IncrementalEncoder` and :class:"
"`IncrementalDecoder`, respectively. Incremental codecs can maintain state."
msgstr ""
"ファクトリ関数は、それぞれ基底クラスの :class:`IncrementalEncoder` や :class:"
"`IncrementalDecoder` が定義しているインタフェースを提供するオブジェクトを返さ"
"なければなりません。漸増的 codecs は内部状態を維持できます。"

#: ../../library/codecs.rst:88
msgid ""
"*streamreader* and *streamwriter*: These have to be factory functions "
"providing the following interface:"
msgstr ""
"*streamreader* と *streamwriter*: これらの引数は、次のようなインタフェースを"
"持つファクトリ関数でなければなりません:"

#: ../../library/codecs.rst:91
msgid "``factory(stream, errors='strict')``"
msgstr "``factory(stream, errors='strict')``"

#: ../../library/codecs.rst:93
msgid ""
"The factory functions must return objects providing the interfaces defined "
"by the base classes :class:`StreamReader` and :class:`StreamWriter`, "
"respectively. Stream codecs can maintain state."
msgstr ""
"ファクトリ関数は、それぞれ基底クラスの :class:`StreamReader` や :class:"
"`StreamWriter` が定義しているインタフェースを提供するオブジェクトを返さねばな"
"りません。ストリーム codecs は内部状態を維持できます。"

#: ../../library/codecs.rst:97
msgid "Possible values for errors are"
msgstr "*errors* が取り得る値は"

#: ../../library/codecs.rst:99
msgid "``'strict'``: raise an exception in case of an encoding error"
msgstr "``'strict'`` エンコーディングエラーの際に例外を発生"

#: ../../library/codecs.rst:100
msgid ""
"``'replace'``: replace malformed data with a suitable replacement marker, "
"such as ``'?'`` or ``'\\ufffd'``"
msgstr ""
"``'replace'`` 奇形データを ``'?'`` や ``'\\ufffd'`` 等の適切な文字で置換"

#: ../../library/codecs.rst:102
msgid "``'ignore'``: ignore malformed data and continue without further notice"
msgstr "``'ignore'`` 奇形データを無視し何も通知せずに処理を継続"

#: ../../library/codecs.rst:103
msgid ""
"``'xmlcharrefreplace'``: replace with the appropriate XML character "
"reference (for encoding only)"
msgstr ""
"``'xmlcharrefreplace'`` 適切な XML 文字参照で置換 (エンコーディングのみ))"

#: ../../library/codecs.rst:105
msgid ""
"``'backslashreplace'``: replace with backslashed escape sequences (for "
"encoding only)"
msgstr ""
"``'backslashreplace'`` (バックスラッシュつきのエスケープシーケンス (エンコー"
"ディングのみ))"

#: ../../library/codecs.rst:108
msgid ""
"as well as any other error handling name defined via :func:`register_error`."
msgstr "と :func:`register_error` で定義されたその他のエラー処理名になります。"

#: ../../library/codecs.rst:110
msgid ""
"In case a search function cannot find a given encoding, it should return "
"``None``."
msgstr ""
"検索関数は、与えられたエンコーディングを見つけられなかった場合、 ``None`` を"
"返さなければなりません。"

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

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

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

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

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

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

#: ../../library/codecs.rst:147
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:155
msgid ""
"Look up the codec for the given encoding and return its incremental decoder "
"class or factory function."
msgstr ""
"与えられたエンコーディングに対する codec を検索し、漸増的デコーダクラスまたは"
"ファクトリ関数を返します。"

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

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

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

#: ../../library/codecs.rst:186
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 encoder will encode the "
"replacement and continue encoding the original input at the specified "
"position. Negative position values will be treated as being relative to the "
"end of the input string. If the resulting position is out of bound an :exc:"
"`IndexError` will be raised."
msgstr ""
"エンコード時の *error_handler* はエラーの場所に関する情報の入った :exc:"
"`UnicodeEncodeError` インスタンスとともに呼び出されます。エラー処理関数はこの"
"例外を送出するか、別の例外を送出するか、または入力のエンコードができなかった"
"部分の代替文字列とエンコードを再開する場所の指定が入ったタプルを返すかしなけ"
"ればなりません。最後の場合、エンコーダは代替文字列をエンコードし、元の入力中"
"の指定位置からエンコードを再開します。位置を負の値にすると、入力文字列の末端"
"からの相対位置として扱われます。境界の外側にある位置を返した場合には :exc:"
"`IndexError` が送出されます。"

#: ../../library/codecs.rst:195
msgid ""
"Decoding and translating works similar, 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:202
msgid "Return the error handler previously registered under the name *name*."
msgstr "名前 *name* で登録済みのエラー処理関数を返します。"

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

#: ../../library/codecs.rst:209
msgid ""
"Implements the ``strict`` error handling: each encoding or decoding error "
"raises a :exc:`UnicodeError`."
msgstr ""
"``strict`` エラー処理の実装です: エンコード又はデコードエラーは各々 :exc:"
"`UnicodeError` を送出します."

#: ../../library/codecs.rst:215
msgid ""
"Implements the ``replace`` error handling: malformed data is replaced with a "
"suitable replacement character such as ``'?'`` in bytestrings and "
"``'\\ufffd'`` in Unicode strings."
msgstr ""
"``replace`` エラー処理の実装です: 奇形データは適切な文字列に置換されます。バ"
"イト文字列では ``'?'`` 、 Unicode 文字列では ``'\\ufffd'`` に置換されます。"

#: ../../library/codecs.rst:222
msgid ""
"Implements the ``ignore`` error handling: malformed data is ignored and "
"encoding or decoding is continued without further notice."
msgstr ""
"``ignore`` エラー処理の実装です: 奇形データは無視されエンコード又はデコードは"
"何も通知せず、継続されます。"

#: ../../library/codecs.rst:228
msgid ""
"Implements the ``xmlcharrefreplace`` error handling (for encoding only): the "
"unencodable character is replaced by an appropriate XML character reference."
msgstr ""
"``xmlcharrefreplace`` エラー処理の実装です(エンコードのみ): エンコードできな"
"かった文字は適切な XML 文字参照に置き換えます。"

#: ../../library/codecs.rst:234
msgid ""
"Implements the ``backslashreplace`` error handling (for encoding only): the "
"unencodable character is replaced by a backslashed escape sequence."
msgstr ""
"``backslashreplace`` エラー処理の実装です (エンコードのみ): エンコードできな"
"かった文字はバックスラッシュつきのエスケープシーケンスに置き換えられます。"

#: ../../library/codecs.rst:237
msgid ""
"To simplify working with encoded files or stream, the module also defines "
"these utility functions:"
msgstr ""
"エンコードされたファイルやストリームの処理を簡便化するため、このモジュールは"
"次のようなユーティリティ関数を定義しています:"

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

#: ../../library/codecs.rst:249
msgid ""
"The wrapped version will only accept the object format defined by the "
"codecs, i.e. Unicode objects for most built-in codecs.  Output is also codec-"
"dependent and will usually be Unicode as well."
msgstr ""
"ラップされたバージョンは、該当する codec が定義している形式のオブジェクトだけ"
"を受け付けます。多くの組み込み codec では Unicode オブジェクトです。関数の戻"
"り値も codec に依存し、通常は Unicode オブジェクトです。"

#: ../../library/codecs.rst:255
msgid ""
"Files are always opened in binary mode, even if no binary mode was "
"specified.  This is done to avoid data loss due to encodings using 8-bit "
"values.  This means that no automatic conversion of ``'\\n'`` is done on "
"reading and writing."
msgstr ""
"非バイナリモードが指定されても、ファイルは常にバイナリモードで開かれます。こ"
"れは、 8-bit の値を使うエンコーディングでデータが消失するのを防ぐためです。つ"
"まり、読み出しや書き込み時に、 ```'\\n'`` の自動変換はされないということで"
"す。"

#: ../../library/codecs.rst:260
msgid "*encoding* specifies the encoding which is to be used for the file."
msgstr "*encoding* にはファイルのエンコーディングを指定します。"

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

#: ../../library/codecs.rst:271
msgid ""
"Return a wrapped version of file which provides transparent encoding "
"translation."
msgstr ""
"ラップしたファイルオブジェクトを返します。このオブジェクトは透過なエンコード"
"変換を提供します。"

#: ../../library/codecs.rst:274
msgid ""
"Strings written to the wrapped file are interpreted according to the given "
"*input* encoding and then written to the original file as strings using the "
"*output* encoding. The intermediate encoding will usually be Unicode but "
"depends on the specified codecs."
msgstr ""
"ラップされたファイルに書かれた文字列は、 *input* に指定したエンコーディングに"
"従って変換され、 *output* に指定したエンコーディングを使って string 型に変換"
"され、元のファイルに書き込まれます。中間エンコーディングは指定された codecs "
"に依存しますが、普通は Unicode です。"

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

#: ../../library/codecs.rst:281
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:287
msgid ""
"Uses an incremental encoder to iteratively encode the input provided by "
"*iterable*. This function is a :term:`generator`.  *errors* (as well as any "
"other keyword argument) is passed through to the incremental encoder."
msgstr ""
"漸増的エンコーダを使って、 *iterable* から供給される入力を反復的にエンコード"
"します。この関数は :term:`generator` です。 *errors* は (そして他のキーワード"
"引数も同様に) 漸増的エンコーダにそのまま引き渡されます。"

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

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

#: ../../library/codecs.rst:317
msgid ""
"These constants define various encodings of the Unicode byte order mark "
"(BOM) used in UTF-16 and UTF-32 data streams to indicate the byte order used "
"in the stream or file 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 signature として使われま"
"す。 :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:330
msgid "Codec Base Classes"
msgstr "Codec 基底クラス"

#: ../../library/codecs.rst:332
msgid ""
"The :mod:`codecs` module defines a set of base classes which define the "
"interface and can also be used to easily write your own codecs for use in "
"Python."
msgstr ""
":mod:`codecs` モジュールでは、 codec のインタフェースを定義する一連の基底クラ"
"スを用意して、 Python 用 codec を簡単に自作できるようにしています。"

#: ../../library/codecs.rst:336
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."
msgstr ""
"Python で何らかの codec を使えるようにするには、状態なしエンコーダ、状態なし"
"デコーダ、ストリームリーダ、ストリームライタの 4 つのインタフェースを定義しな"
"ければなりません。通常は、状態なしエンコーダとデコーダを再利用してストリーム"
"リーダとライタのファイル・プロトコルを実装します。"

#: ../../library/codecs.rst:341
msgid ""
"The :class:`Codec` class defines the interface for stateless encoders/"
"decoders."
msgstr ""
":class:`Codec` クラスは、状態なしエンコーダ・デコーダのインタフェースを定義し"
"ています。"

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

#: ../../library/codecs.rst:351
msgid "Value"
msgstr "``値``"

#: ../../library/codecs.rst:351
msgid "Meaning"
msgstr "意味"

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

#: ../../library/codecs.rst:353
msgid "Raise :exc:`UnicodeError` (or a subclass); this is the default."
msgstr ""
":exc:`UnicodeError` (または、そのサブクラス) を送出します -- デフォルトの動作"
"です。"

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

#: ../../library/codecs.rst:356
msgid "Ignore the character and continue with the next."
msgstr "その文字を無視し、次の文字から変換を再開します。"

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

#: ../../library/codecs.rst:359
msgid ""
"Replace with a suitable replacement character; Python will use the official "
"U+FFFD REPLACEMENT CHARACTER for the built-in Unicode codecs on decoding and "
"'?' on encoding."
msgstr ""
"適当な文字で置換します -- Python の組み込み Unicode codec のデコード時には公"
"式の U+FFFD REPLACEMENT CHARACTER を、エンコード時には '?' を使います。"

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

#: ../../library/codecs.rst:365
msgid ""
"Replace with the appropriate XML character reference (only for encoding)."
msgstr "適切な XML 文字参照で置換します (エンコードのみ)。"

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

#: ../../library/codecs.rst:368
msgid "Replace with backslashed escape sequences (only for encoding)."
msgstr ""
"バックスラッシュつきのエスケープシーケンスで置換します (エンコードのみ)。"

#: ../../library/codecs.rst:372
msgid "The set of allowed values can be extended via :meth:`register_error`."
msgstr ""
"codecs がエラーハンドラとして受け入れる値は :meth:`register_error` を使って追"
"加できます。"

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

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

#: ../../library/codecs.rst:386
msgid ""
"Encodes the object *input* and returns a tuple (output object, length "
"consumed). While codecs are not restricted to use with Unicode, in a Unicode "
"context, encoding converts a Unicode object to a plain string using a "
"particular character set encoding (e.g., ``cp1252`` or ``iso-8859-1``)."
msgstr ""
"オブジェクト *input* エンコードし、(出力オブジェクト, 消費した長さ) のタプル"
"を返します。 codecs は Unicode 専用ではありませんが、 Unicode の文脈では、エ"
"ンコーディングは Unicode オブジェクトを特定の文字集合エンコーディング(たとえ"
"ば ``cp1252`` や ``iso-8859-1``) を使ってバイト文字列オブジェクトに変換しま"
"す。"

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

#: ../../library/codecs.rst:394
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:398
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:404
msgid ""
"Decodes the object *input* and returns a tuple (output object, length "
"consumed). In a Unicode context, decoding converts a plain string encoded "
"using a particular character set encoding to a Unicode object."
msgstr ""
"オブジェクト *input* をデコードし、(出力オブジェクト, 消費した長さ) のタプル"
"を返します。 Unicode の文脈では、デコードは特定の文字集合エンコーディングでエ"
"ンコードされた文字列を Unicode オブジェクトに変換します。"

#: ../../library/codecs.rst:408
msgid ""
"*input* must be an object which provides the ``bf_getreadbuf`` buffer slot. "
"Python strings, buffer objects and memory mapped files are examples of "
"objects providing this slot."
msgstr ""
"*input* は ``bf_getreadbuf`` バッファスロットを提供するオブジェクトでなければ"
"なりません。バッファスロットを提供しているオブジェクトには Python 文字列オブ"
"ジェクト、バッファオブジェクト、メモリマップファイルがあります。"

#: ../../library/codecs.rst:415
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:419
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:422
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:430
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:439
msgid "IncrementalEncoder Objects"
msgstr "IncrementalEncoder オブジェクト"

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

#: ../../library/codecs.rst:452
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:456
msgid ""
"The :class:`IncrementalEncoder` may implement different error handling "
"schemes by providing the *errors* keyword argument. These parameters are "
"predefined:"
msgstr ""
":class:`IncrementalEncoder` は *errors* キーワード引数を提供して異なったエ"
"ラー取扱方法を実装することもできます。あらかじめ定義されているパラメータは以"
"下の通りです:"

#: ../../library/codecs.rst:459 ../../library/codecs.rst:511
#: ../../library/codecs.rst:570 ../../library/codecs.rst:635
msgid ""
"``'strict'`` Raise :exc:`ValueError` (or a subclass); this is the default."
msgstr ""
"``'strict'`` :exc:`ValueError` (またはそのサブクラス) を送出します。これがデ"
"フォルトです。"

#: ../../library/codecs.rst:461 ../../library/codecs.rst:513
#: ../../library/codecs.rst:572 ../../library/codecs.rst:637
msgid "``'ignore'`` Ignore the character and continue with the next."
msgstr "``'ignore'`` 一文字無視して次に進みます。"

#: ../../library/codecs.rst:463 ../../library/codecs.rst:574
msgid "``'replace'`` Replace with a suitable replacement character"
msgstr "``'replace'`` 適当な代替文字で置き換えます。"

#: ../../library/codecs.rst:465 ../../library/codecs.rst:576
msgid ""
"``'xmlcharrefreplace'`` Replace with the appropriate XML character reference"
msgstr "``'xmlcharrefreplace'`` 適切な XML 文字参照に置き換えます。"

#: ../../library/codecs.rst:467 ../../library/codecs.rst:578
msgid "``'backslashreplace'`` Replace with backslashed escape sequences."
msgstr ""
"``'backslashreplace'`` バックスラッシュ付きのエスケープシーケンスで置き換えま"
"す。"

#: ../../library/codecs.rst:469
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:474 ../../library/codecs.rst:522
#: ../../library/codecs.rst:584 ../../library/codecs.rst:645
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:480
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:487
msgid "Reset the encoder to the initial state."
msgstr "エンコーダを初期状態にリセットします。"

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

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

#: ../../library/codecs.rst:504
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:508
msgid ""
"The :class:`IncrementalDecoder` may implement different error handling "
"schemes by providing the *errors* keyword argument. These parameters are "
"predefined:"
msgstr ""
":class:`IncrementalDecoder` は *errors* キーワード引数を提供して異なったエ"
"ラー取扱方法を実装することもできます。あらかじめ定義されているパラメータは以"
"下の通りです:"

#: ../../library/codecs.rst:515 ../../library/codecs.rst:639
msgid "``'replace'`` Replace with a suitable replacement character."
msgstr "``'replace'`` 適切な置換文字で置換します。"

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

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

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

#: ../../library/codecs.rst:561
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:565
msgid "*stream* must be a file-like object open for writing binary data."
msgstr ""
"*stream* は、(バイナリで) 書き込み可能なファイル類似のオブジェクトでなくては"
"なりません。"

#: ../../library/codecs.rst:567
msgid ""
"The :class:`StreamWriter` may implement different error handling schemes by "
"providing the *errors* keyword argument. These parameters are predefined:"
msgstr ""
":class:`StreamWriter` は、 *errors* キーワード引数を受けて、異なったエラー処"
"理の仕組みを実装しても構いません。定義済みのパラメタを以下に示します:"

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

#: ../../library/codecs.rst:595
msgid ""
"Writes the concatenated list of strings to the stream (possibly by reusing "
"the :meth:`write` method)."
msgstr ""
"文字列からなるリストを連結して、(必要に応じて :meth:`write` を何度も使って) "
"ストリームに書き出します。"

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

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

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

#: ../../library/codecs.rst:626
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:630
msgid "*stream* must be a file-like object open for reading (binary) data."
msgstr ""
"*stream* は、(バイナリで) 読み出し可能なファイル類似のオブジェクトでなくては"
"なりません。"

#: ../../library/codecs.rst:632
msgid ""
"The :class:`StreamReader` may implement different error handling schemes by "
"providing the *errors* keyword argument. These parameters are defined:"
msgstr ""
":class:`StreamReader` は、 *errors* キーワード引数を受けて、異なったエラー処"
"理の仕組みを実装しても構いません。定義済みのパラメタを以下に示します:"

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

#: ../../library/codecs.rst:653
msgid ""
"*chars* indicates the number of characters to read from the stream. :func:"
"`read` will never return more than *chars* characters, but it might return "
"less, if there are not enough characters available."
msgstr ""
"*chars* はストリームから読み込む文字数です。 :func:`read` は *chars* 以上の文"
"字を返しませんが、それより少ない文字しか取得できない場合には *chars* 以下の文"
"字を返します。"

#: ../../library/codecs.rst:657
msgid ""
"*size* indicates the approximate maximum number of bytes to read from the "
"stream for decoding purposes. The decoder can modify this setting as "
"appropriate. The default value -1 indicates to read and decode as much as "
"possible.  *size* is intended to prevent having to decode huge files in one "
"step."
msgstr ""
"*size* は、デコードするためにストリームから読み込む、およその最大バイト数を意"
"味します。デコーダはこの値を適切な値に変更できます。デフォルト値 -1 にすると"
"可能な限りたくさんのデータを読み込みます。 *size* の目的は、巨大なファイルの"
"一括デコードを防ぐことにあります。"

#: ../../library/codecs.rst:663
msgid ""
"*firstline* 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:666
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:671
msgid "*chars* argument added."
msgstr "*chars* 引数を追加しました."

#: ../../library/codecs.rst:674
msgid "*firstline* argument added."
msgstr "*firstline* 引数を追加しました."

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

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

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

#: ../../library/codecs.rst:688
msgid "*keepends* argument added."
msgstr "*keepends* 引数を追加しました."

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

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

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

#: ../../library/codecs.rst:708
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:712
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:715
msgid ""
"The next two base classes are included for convenience. They are not needed "
"by the codec registry, but may provide useful in practice."
msgstr ""
"次に挙げる2つの基底クラスは、利便性のために含まれています。codec レジストリ"
"は、これらを必要としませんが、実際のところ、あると有用なものでしょう。"

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

#: ../../library/codecs.rst:724
msgid ""
"The :class:`StreamReaderWriter` allows wrapping streams which work in both "
"read and write modes."
msgstr ""
":class:`StreamReaderWriter` を使って、読み書き両方に使えるストリームをラップ"
"できます。"

#: ../../library/codecs.rst:727 ../../library/codecs.rst:751
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:733
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:738
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:746
msgid "StreamRecoder Objects"
msgstr "StreamRecoder オブジェクト"

#: ../../library/codecs.rst:748
msgid ""
"The :class:`StreamRecoder` provide a frontend - backend view of encoding "
"data which is sometimes useful when dealing with different encoding "
"environments."
msgstr ""
":class:`StreamRecoder` はエンコーディングデータの、フロントエンド-バックエン"
"ドを観察する機能を提供します。異なるエンコーディング環境を扱うとき、便利な場"
"合があります。"

#: ../../library/codecs.rst:757
msgid ""
"Creates a :class:`StreamRecoder` instance which implements a two-way "
"conversion: *encode* and *decode* work on the frontend (the input to :meth:"
"`read` and output of :meth:`write`) while *Reader* and *Writer* work on the "
"backend (reading and writing to the stream)."
msgstr ""
"双方向変換を実装する :class:`StreamRecoder` インスタンスを生成します。 "
"*encode* と *decode* はフロントエンド (:meth:`read` への入力と :meth:`write` "
"からの出力) を処理し、 *Reader* と *Writer* はバックエンド (ストリームに対す"
"る読み書き) を処理します。"

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

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

#: ../../library/codecs.rst:767
msgid ""
"*encode*, *decode* must adhere to the :class:`Codec` interface. *Reader*, "
"*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:771
msgid ""
"*encode* and *decode* are needed for the frontend translation, *Reader* and "
"*Writer* for the backend translation.  The intermediate format used is "
"determined by the two sets of codecs, e.g. the Unicode codecs will use "
"Unicode as the intermediate encoding."
msgstr ""
"*encode* と *decode* はフロントエンドの変換に必要で、 *Reader* と *Writer* は"
"バックエンドの変換に必要です。中間のフォーマットはコデックの組み合わせによっ"
"て決定されます。たとえば、 Unicode コデックは中間エンコーディングに Unicode "
"を使います。"

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

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

#: ../../library/codecs.rst:790
msgid ""
"Unicode strings are stored internally as sequences of code points (to be "
"precise as :c:type:`Py_UNICODE` arrays). Depending on the way Python is "
"compiled (either via ``--enable-unicode=ucs2`` or ``--enable-unicode=ucs4``, "
"with the former being the default) :c:type:`Py_UNICODE` is either a 16-bit "
"or 32-bit data type. Once a Unicode object is used outside of CPU and "
"memory, CPU endianness and how these arrays are stored as bytes become an "
"issue.  Transforming a unicode object into a sequence of bytes is called "
"encoding and recreating the unicode object from the sequence of bytes is "
"known as decoding.  There are many different methods for how this "
"transformation can be done (these methods are also called encodings). The "
"simplest method is to map the code points 0--255 to the bytes ``0x0``--"
"``0xff``. This means that a unicode object that contains code points above "
"``U+00FF`` can't be encoded with this method (which is called ``'latin-1'`` "
"or ``'iso-8859-1'``). :func:`unicode.encode` will raise a :exc:"
"`UnicodeEncodeError` that looks like this: ``UnicodeEncodeError: 'latin-1' "
"codec can't encode character u'\\u1234' in position 3: ordinal not in "
"range(256)``."
msgstr ""
"Unicode 文字列は内部的にはコードポイントのシーケンスとして格納されます (正確"
"に言えば :c:type:`Py_UNICODE` 配列です)。 Python がどのようにコンパイルされた"
"か (デフォルトである ``--enable-unicode=ucs2`` かまたは ``--enable-"
"unicode=ucs4`` のどちらか) によって、 :c:type:`Py_UNICODE` は16ビットまたは32"
"ビットのデータ型です。 Unicode オブジェクトが CPU とメモリの外で使われること"
"になると、 CPU のエンディアンやこれらの配列がバイト列としてどのように格納され"
"るかが問題になってきます。 Unicode オブジェクトをバイト列に変換することをエン"
"コーディングと呼び、バイト列から Unicode オブジェクトを再生することをデコー"
"ディングと呼びます。どのようにこの変換を行うかには多くの異なった方法がありま"
"す (これらの方法のこともエンコーディングと言います) 。最も単純な方法はコード"
"ポイント 0--255 をバイト ``0x0``--``0xff`` に写すことです。これは ``U+00FF`` "
"より上のコードポイントを持つ Unicode オブジェクトはこの方法ではエンコードでき"
"ないということを意味します (この方法を ``'latin-1'`` とか ``'iso-8859-1'`` と"
"呼びます)。 :func:`unicode.encode` は次のような :exc:`UnicodeEncodeError` を"
"送出することになります: ``UnicodeEncodeError: 'latin-1' codec can't encode "
"character u'\\u1234' in position 3: ordinal not in range(256)``"

#: ../../library/codecs.rst:807
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`` のバイトに写されるかを選んだものです。これがどのように行なわれるかを"
"知るには、単にたとえば :file:`encodings/cp1252.py` (主に Windows で使われるエ"
"ンコーディングです) を開いてみてください。256 文字のひとつの文字列定数があり"
"どの文字がどのバイト値に写されるかを示しています。"

#: ../../library/codecs.rst:814
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 Unicode 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:840
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:849
msgid "Range"
msgstr "範囲"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:922 ../../library/codecs.rst:1147
#: ../../library/codecs.rst:1196
msgid "Codec"
msgstr "Codec"

#: ../../library/codecs.rst:922 ../../library/codecs.rst:1147
#: ../../library/codecs.rst:1196
msgid "Aliases"
msgstr "別名"

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

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

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

#: ../../library/codecs.rst:924 ../../library/codecs.rst:930
#: ../../library/codecs.rst:934
msgid "English"
msgstr "英語"

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

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

#: ../../library/codecs.rst:926 ../../library/codecs.rst:928
#: ../../library/codecs.rst:982
msgid "Traditional Chinese"
msgstr "繁体字中国語"

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

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

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

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

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

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

#: ../../library/codecs.rst:932 ../../library/codecs.rst:952
#: ../../library/codecs.rst:962 ../../library/codecs.rst:1001
#: ../../library/codecs.rst:1064
msgid "Hebrew"
msgstr "ヘブライ語"

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

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

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

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

#: ../../library/codecs.rst:936 ../../library/codecs.rst:945
#: ../../library/codecs.rst:956 ../../library/codecs.rst:988
#: ../../library/codecs.rst:995 ../../library/codecs.rst:1076
#: ../../library/codecs.rst:1095
msgid "Western Europe"
msgstr "西ヨーロッパ言語"

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

#: ../../library/codecs.rst:939 ../../library/codecs.rst:966
#: ../../library/codecs.rst:1003 ../../library/codecs.rst:1060
msgid "Arabic"
msgstr "アラビア語"

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

#: ../../library/codecs.rst:941 ../../library/codecs.rst:972
#: ../../library/codecs.rst:976 ../../library/codecs.rst:997
#: ../../library/codecs.rst:1062 ../../library/codecs.rst:1089
msgid "Greek"
msgstr "ギリシャ語"

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

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

#: ../../library/codecs.rst:943 ../../library/codecs.rst:1005
#: ../../library/codecs.rst:1055 ../../library/codecs.rst:1072
msgid "Baltic languages"
msgstr "バルト沿岸国"

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

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

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

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

#: ../../library/codecs.rst:947 ../../library/codecs.rst:990
#: ../../library/codecs.rst:1051 ../../library/codecs.rst:1093
msgid "Central and Eastern Europe"
msgstr "中央および東ヨーロッパ"

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

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

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

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

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

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

#: ../../library/codecs.rst:954 ../../library/codecs.rst:986
#: ../../library/codecs.rst:999 ../../library/codecs.rst:1066
#: ../../library/codecs.rst:1097
msgid "Turkish"
msgstr "トルコ語"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:970 ../../library/codecs.rst:1082
msgid "Russian"
msgstr "ロシア語"

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

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

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

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

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

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

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

#: ../../library/codecs.rst:978 ../../library/codecs.rst:1009
#: ../../library/codecs.rst:1011 ../../library/codecs.rst:1013
#: ../../library/codecs.rst:1030 ../../library/codecs.rst:1033
#: ../../library/codecs.rst:1038 ../../library/codecs.rst:1041
#: ../../library/codecs.rst:1043 ../../library/codecs.rst:1102
#: ../../library/codecs.rst:1105 ../../library/codecs.rst:1108
msgid "Japanese"
msgstr "日本語"

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

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

#: ../../library/codecs.rst:980 ../../library/codecs.rst:1015
#: ../../library/codecs.rst:1045 ../../library/codecs.rst:1080
msgid "Korean"
msgstr "韓国語"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1024 ../../library/codecs.rst:1026
msgid "Unified Chinese"
msgstr "Unified Chinese"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1111 ../../library/codecs.rst:1113
#: ../../library/codecs.rst:1115 ../../library/codecs.rst:1117
#: ../../library/codecs.rst:1123 ../../library/codecs.rst:1125
#: ../../library/codecs.rst:1127
msgid "all languages"
msgstr "全ての言語"

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1119 ../../library/codecs.rst:1121
msgid "all languages (BMP only)"
msgstr "全ての言語 (BMP のみ)"

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1140
msgid ""
"The following codecs provide unicode-to-str encoding [#encoding-note]_ and "
"str-to-unicode decoding [#decoding-note]_, similar to the Unicode text "
"encodings."
msgstr ""
"以下の codec では Unicode から文字列へのエンコーディング [#encoding-note]_ 、"
"文字列から Unicode へのデコーディング [#decoding-note]_ を、Unicode テキスト"
"エンコーディング同様に提供しています。"

#: ../../library/codecs.rst:1147 ../../library/codecs.rst:1196
msgid "Purpose"
msgstr "目的"

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

#: ../../library/codecs.rst:1149
msgid "Implements :rfc:`3490`, see also :mod:`encodings.idna`"
msgstr ":rfc:`3490` の実装です。 :mod:`encodings.idna` も参照してください。"

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

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

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

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

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

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

#: ../../library/codecs.rst:1159
msgid "Implements :rfc:`3492`"
msgstr ":rfc:`3492` を実装しています。"

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

#: ../../library/codecs.rst:1161
msgid ""
"Produce a string that is suitable as raw Unicode literal in Python source "
"code"
msgstr ""
"Python ソースコードにおける raw Unicode リテラルとして適切な文字列を生成しま"
"す。"

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

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

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

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

#: ../../library/codecs.rst:1169
msgid ""
"Raise an exception for all conversions. Can be used as the system encoding "
"if no automatic :term:`coercion` between byte and Unicode strings is desired."
msgstr ""
"全ての変換に対して例外を送出します。バイト列と Unicode 文字列との間で :term:"
"`coercion` (強制型変換) をおこないたくない時にシステムエンコーディングとして"
"使うことができます。"

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

#: ../../library/codecs.rst:1177
msgid ""
"Produce a string that is suitable as Unicode literal in Python source code"
msgstr ""
"Python ソースコードにおける Unicode リテラルとして適切な文字列を生成します。"

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

#: ../../library/codecs.rst:1182
msgid "Return the internal representation of the operand"
msgstr "被演算子の内部表現を返します。"

#: ../../library/codecs.rst:1187
msgid "The ``idna`` and ``punycode`` encodings."
msgstr "``idna``, ``punycode`` エンコーディングの追加。"

#: ../../library/codecs.rst:1190
msgid ""
"The following codecs provide str-to-str encoding and decoding [#decoding-"
"note]_."
msgstr ""
"以下の codec では文字列から文字列へのエンコーディングとデコーディング "
"[#decoding-note]_ を提供しています。"

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

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

#: ../../library/codecs.rst:1198
msgid "base64, base-64"
msgstr "base64, base-64"

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

#: ../../library/codecs.rst:1198
msgid ":meth:`base64.encodestring`, :meth:`base64.decodestring`"
msgstr ":meth:`base64.encodestring`, :meth:`base64.decodestring`"

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

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1211
msgid "quopri, quoted-printable, quotedprintable"
msgstr "quopri, quoted-printable, quotedprintable"

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

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

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

#: ../../library/codecs.rst:1215
msgid ""
"Produce a string that is suitable as string literal in Python source code"
msgstr ""
"Python ソースコードにおける文字列リテラルとして適切な文字列を生成します。"

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

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

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

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

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

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

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

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

#: ../../library/codecs.rst:1227
msgid ""
"str objects are also accepted as input in place of unicode objects.  They "
"are implicitly converted to unicode by decoding them using the default "
"encoding.  If this conversion fails, it may lead to encoding operations "
"raising :exc:`UnicodeDecodeError`."
msgstr ""
"unicode オブジェクトを入力として受け容れる場所では str オブジェクトも許容され"
"ます。この場合デフォルトエンコーディングを使って暗黙に unicode に変換されま"
"す。この変換が失敗した場合はエンコード操作が :exc:`UnicodeDecodeError` を起こ"
"します。"

#: ../../library/codecs.rst:1232
msgid ""
"unicode objects are also accepted as input in place of str objects.  They "
"are implicitly converted to str by encoding them using the default "
"encoding.  If this conversion fails, it may lead to decoding operations "
"raising :exc:`UnicodeEncodeError`."
msgstr ""
"str オブジェクトを入力として受け容れる場所では unicode オブジェクトも許容され"
"ます。この場合デフォルトエンコーディングを使って暗黙に str に変換されます。こ"
"の変換が失敗した場合はデコード操作が :exc:`UnicodeEncodeError` を起こします。"

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

#: ../../library/codecs.rst:1247
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:1252
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:1263
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 `section 3.1`_ (1) of :"
"rfc:`3490` 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:`httplib` and :mod:`ftplib`, "
"accept Unicode host names (:mod:`httplib` then also transparently sends an "
"IDNA hostname in the :mailheader:`Host` field if it sends that field at all)."
msgstr ""
"Python ではこの変換をいくつかの方法でサポートします: ``idna`` codec は "
"Unicode と ACE 間の変換を行い、入力文字列を :rfc:`3490` の `section 3.1`_ "
"(1) で定義されている区切り文字に基づいてラベルに分解し、各ラベルを要求通りに "
"ACE に変換します。逆に、入力のバイト文字列を ``.`` 区切り文字でラベルに分解"
"し、 ACE ラベルを Unicode に変換します。さらに、 :mod:`socket` モジュールは "
"Unicode ホスト名を ACE に透過的に変換するため、アプリケーションはホスト名を :"
"mod:`socket` モジュールに渡す際にホスト名の変換に煩わされることがありません。"
"その上で、ホスト名を関数パラメタとして持つ、 :mod:`httplib` や :mod:`ftplib` "
"のようなモジュールでは Unicode ホスト名を受理します (:mod:`httplib` でもま"
"た、 ``Host:`` フィールドにある IDNA ホスト名を、フィールド全体を送信する場合"
"に透過的に送信します)。"

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

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

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

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

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