"codecs" --- 编解码器注册和相关基类
***********************************

**源代码：** Lib/codecs.py

======================================================================

这个模块定义了标准 Python 编解码器（编码器和解码器）的基类，并提供接口
用来访问内部的 Python 编解码器注册表，该注册表负责管理编解码器和错误处
理的查找过程。 大多数标准编解码器都属于 *文本编码*，它们可将文本编码为
字节串，但也提供了一些编解码器可将文本编码为文本，以及字节串编码为字节
串。 自定义编解码器可以在任意类型间进行编码和解码，但某些模块特性仅适
用于 *文本编码* 或将数据编码为 "字节串" 的编解码器。

该模块定义了以下用于使用任何编解码器进行编码和解码的函数：

codecs.encode(obj, encoding='utf-8', errors='strict')

   使用为 *encoding* 注册的编解码器对 *obj* 进行编码。

   可以给定 *Errors* 以设置所需要的错误处理方案。 默认的错误处理方案
   "'strict'" 表示编码错误将引发 "ValueError" (或更特定编解码器相关的
   子类，例如 "UnicodeEncodeError")。 请参阅 编解码器基类 了解有关编解
   码器错误处理的更多信息。

codecs.decode(obj, encoding='utf-8', errors='strict')

   使用为 *encoding* 注册的编解码器对 *obj* 进行解码。

   可以给定 *Errors* 以设置所需要的错误处理方案。 默认的错误处理方案
   "'strict'" 表示编码错误将引发 "ValueError" (或更特定编解码器相关的
   子类，例如 "UnicodeDecodeError")。 请参阅 编解码器基类 了解有关编解
   码器错误处理的更多信息。

每种编解码器的完整细节也可以直接查找获取：

codecs.lookup(encoding)

   在 Python 编解码器注册表中查找编解码器信息，并返回一个 "CodecInfo"
   对象，其定义见下文。

   首先将会在注册表缓存中查找编码，如果未找到，则会扫描注册的搜索函数
   列表。 如果没有找到 "CodecInfo" 对象，则将引发 "LookupError"。 否则
   ，"CodecInfo" 对象将被存入缓存并返回给调用者。

class codecs.CodecInfo(encode, decode, streamreader=None, streamwriter=None, incrementalencoder=None, incrementaldecoder=None, name=None)

   查找编解码器注册表所得到的编解码器细节信息。 构造器参数将保存为同名
   的属性：

   name

      编码名称

   encode
   decode

      无状态的编码和解码函数。 它们必须是具有与 Codec 的 "encode()" 和
      "decode()" 方法相同接口的函数或方法 (参见 Codec 接口)。 这些函数
      或方法应当工作于无状态的模式。

   incrementalencoder
   incrementaldecoder

      增量式的编码器和解码器类或工厂函数。 这些函数必须分别提供由基类
      "IncrementalEncoder" 和 "IncrementalDecoder" 所定义的接口。 增量
      式编解码器可以保持状态。

   streamwriter
   streamreader

      流式写入器和读取器类或工厂函数。 这些函数必须分别提供由基类
      "StreamWriter" 和 "StreamReader" 所定义的接口。 流式编解码器可以
      保持状态。

为了简化对各种编解码器组件的访问，本模块提供了以下附加函数，它们使用
"lookup()" 来执行编解码器查找：

codecs.getencoder(encoding)

   查找给定编码的编解码器并返回其编码器函数。

   在编码无法找到时将引发 "LookupError"。

codecs.getdecoder(encoding)

   查找给定编码的编解码器并返回其解码器函数。

   在编码无法找到时将引发 "LookupError"。

codecs.getincrementalencoder(encoding)

   查找给定编码的编解码器并返回其增量式编码器类或工厂函数。

   在编码无法找到或编解码器不支持增量式编码器时将引发 "LookupError"。

codecs.getincrementaldecoder(encoding)

   查找给定编码的编解码器并返回其增量式解码器类或工厂函数。

   在编码无法找到或编解码器不支持增量式解码器时将引发 "LookupError"。

codecs.getreader(encoding)

   查找给定编码的编解码器并返回其 "StreamReader" 类或工厂函数。

   在编码无法找到时将引发 "LookupError"。

codecs.getwriter(encoding)

   查找给定编码的编解码器并返回其 "StreamWriter" 类或工厂函数。

   在编码无法找到时将引发 "LookupError"。

自定义编解码器的启用是通过注册适当的编解码器搜索函数：

codecs.register(search_function)

   注册一个编解码器搜索函数。 搜索函数预期接收一个参数，即全部以小写字
   母表示的编码名称，并返回一个 "CodecInfo" 对象。 在搜索函数无法找到
   给定编码的情况下，它应当返回 "None"。

   注解: 搜索函数的注册目前是不可逆的，这在某些情况下可能导致问题，
     例如单 元测试或模块重载等。

虽然内置的 "open()" 和相关联的 "io" 模块是操作已编码文本文件的推荐方式
，但本模块也提供了额外的工具函数和类，允许在操作二进制文件时使用更多各
类的编解码器：

codecs.open(filename, mode='r', encoding=None, errors='strict', buffering=-1)

   使用给定的 *mode* 打开已编码的文件并返回一个 "StreamReaderWriter"
   的实例，提供透明的编码/解码。 默认的文件模式为 "'r'"，表示以读取模
   式打开文件。

   注解: 下层的已编码文件总是以二进制模式打开。 在读取和写入时不会自
     动执行 "'\n'" 的转换。 *mode* 参数可以是内置 "open()" 函数所接受
     的任意二 进制模式；"'b'" 会被自动添加。

   *encoding* 指定文件所要使用的编码格式。 允许任何编码为字节串或从字
   节串解码的编码格式，而文件方法所支持的数据类型则取决于所使用的编解
   码器。

   可以指定 *errors* 来定义错误处理方案。 默认值 "'strict'" 表示在出现
   编码错误时引发 "ValueError"。

   *buffering* has the same meaning as for the built-in "open()"
   function. It defaults to -1 which means that the default buffer
   size will be used.

codecs.EncodedFile(file, data_encoding, file_encoding=None, errors='strict')

   返回一个 "StreamRecoder" 实例，它提供了 *file* 的透明转码包装版本。
   当包装版本被关闭时原始文件也会被关闭。

   写入已包装文件的数据会根据给定的 *data_encoding* 解码，然后以使用
   *file_encoding* 的字节形式写入原始文件。 从原始文件读取的字节串将根
   据 *file_encoding* 解码，其结果将使用 *data_encoding* 进行编码。

   如果 *file_encoding* 未给定，则默认为 *data_encoding*。

   可以指定 *errors* 来定义错误处理方案。 默认值 "'strict'" 表示在出现
   编码错误时引发 "ValueError"。

codecs.iterencode(iterator, encoding, errors='strict', **kwargs)

   使用增量式编码器通过迭代来编码由 *iterator* 所提供的输入。 此函数属
   于 *generator*。 *errors* 参数（以及任何其他关键字参数）会被传递给
   增量式编码器。

   此函数要求编解码器接受 "str" 对象形式的文本进行编码。 因此它不支持
   字节到字节的编码器，例如 "base64_codec"。

codecs.iterdecode(iterator, encoding, errors='strict', **kwargs)

   使用增量式解码器通过迭代来解码由 *iterator* 所提供的输入。 此函数属
   于 *generator*。 *errors* 参数（以及任何其他关键字参数）会被传递给
   增量式解码器。

   此函数要求编解码器接受 "bytes" 对象进行解码。 因此它不支持文本到文
   本的编码器，例如 "rot_13"，但是 "rot_13" 可以通过同样效果的
   "iterencode()" 来使用。

本模块还提供了以下常量，适用于读取和写入依赖于平台的文件：

codecs.BOM
codecs.BOM_BE
codecs.BOM_LE
codecs.BOM_UTF8
codecs.BOM_UTF16
codecs.BOM_UTF16_BE
codecs.BOM_UTF16_LE
codecs.BOM_UTF32
codecs.BOM_UTF32_BE
codecs.BOM_UTF32_LE

   这些常量定义了多种字节序列，即一些编码格式的 Unicode 字节顺序标记（
   BOM）。 它们在 UTF-16 和 UTF-32 数据流中被用以指明所使用的字节顺序
   ，并在 UTF-8 中被用作 Unicode 签名。 "BOM_UTF16" 是 "BOM_UTF16_BE"
   或 "BOM_UTF16_LE"，具体取决于平台的本机字节顺序，"BOM" 是
   "BOM_UTF16" 的别名, "BOM_LE" 是 "BOM_UTF16_LE" 的别名，"BOM_BE" 是
   "BOM_UTF16_BE" 的别名。 其他序列则表示 UTF-8 和 UTF-32 编码格式中的
   BOM。


编解码器基类
============

"codecs" 模块定义了一系列基类用来定义配合编解码器对象进行工作的接口，
并且也可用作定制编解码器实现的基础。

每种编解码器必须定义四个接口以便用作 Python 中的编解码器：无状态编码器
、无状态解码器、流读取器和流写入器。 流读取器和写入器通常会重用无状态
编码器/解码器来实现文件协议。 编解码器作者还需要定义编解码器将如何处理
编码和解码错误。


错误处理方案
------------

为了简化和标准化错误处理，编解码器可以通过接受 *errors* 字符串参数来实
现不同的错误处理方案。 所有标准的 Python 编解码器都定义并实现了以下字
符串值：

+---------------------------+-------------------------------------------------+
| 值                        | 含义                                            |
|===========================|=================================================|
| "'strict'"                | 引发 "UnicodeError" (或其子类)；这是默认的方案  |
|                           | 。 在 "strict_errors()" 中实现。                |
+---------------------------+-------------------------------------------------+
| "'ignore'"                | 忽略错误格式的数据并且不加进一步通知就继续执行  |
|                           | 。 在 "ignore_errors()" 中实现。                |
+---------------------------+-------------------------------------------------+

以下错误处理方案仅适用于 *文本编码*:

+---------------------------+-------------------------------------------------+
| 值                        | 含义                                            |
|===========================|=================================================|
| "'replace'"               | 使用适当的替换标记进行替换；Python 内置编解码器 |
|                           | 将在解码时使用官方 "U+FFFD" 替换字符，而在编码  |
|                           | 时使用 '?'。 在 "replace_errors()" 中实现。     |
+---------------------------+-------------------------------------------------+
| "'xmlcharrefreplace'"     | 使用适当的 XML 字符引用进行替换（仅在编码时）。 |
|                           | 在 "xmlcharrefreplace_errors()" 中实现。        |
+---------------------------+-------------------------------------------------+
| "'backslashreplace'"      | 使用带反斜杠的转义序列进行替换。 在             |
|                           | "backslashreplace_errors()" 中实现 。           |
+---------------------------+-------------------------------------------------+
| "'namereplace'"           | 使用 "\N{...}" 转义序列进行替换（仅在编码时）。 |
|                           | 在 "namereplace_errors()" 中实现。              |
+---------------------------+-------------------------------------------------+
| "'surrogateescape'"       | 在解码时，将字节替换为 "U+DC80" 至 "U+DCFF" 范  |
|                           | 围内的单个代理代码。 当 在编码数据时使用        |
|                           | "'surrogateescape'" 错误处理方案时，此代理将被  |
|                           | 转换回 相同的字节。 （请参阅 **PEP 383** 了解详 |
|                           | 情。）                                          |
+---------------------------+-------------------------------------------------+

此外，以下错误处理方案被专门用于指定的编解码器：

+---------------------+--------------------------+---------------------------------------------+
| 值                  | 编解码器                 | 含义                                        |
|=====================|==========================|=============================================|
| "'surrogatepass'"   | utf-8, utf-16, utf-32,   | 允许编码和解码代理代码。 这些编解码器通常会 |
|                     | utf-16-be, utf-16-le,    | 将出现的代理代码视为错误。                  |
|                     | utf-32-be, utf-32-le     |                                             |
+---------------------+--------------------------+---------------------------------------------+

3.1 新版功能: "'surrogateescape'" 和 "'surrogatepass'" 错误处理方案。

在 3.4 版更改: "'surrogatepass'" 错误处理方案现在适用于 utf-16* 和
utf-32* 编解码器。

3.5 新版功能: "'namereplace'" 错误处理方案。

在 3.5 版更改: "'backslashreplace'" 错误处理方案现在适用于解码和转换。

允许的值集合可以通过注册新命名的错误处理方案来扩展：

codecs.register_error(name, error_handler)

   在名称 *name* 之下注册错误处理函数 *error_handler*。 当 *name* 被指
   定为错误形参时，*error_handler* 参数所指定的对象将在编码和解码期间
   发生错误的情况下被调用，

   对于编码操作，将会调用 *error_handler* 并传入一个
   "UnicodeEncodeError" 实例，其中包含有关错误位置的信息。 错误处理程
   序必须引发此异常或别的异常，或者也可以返回一个元组，其中包含输入的
   不可编码部分的替换对象，以及应当继续进行编码的位置。 替换对象可以为
   "str" 或 "bytes" 类型。 如果替换对象为字节串，编码器将简单地将其复
   制到输出缓冲区。 如果替换对象为字符串，编码器将对替换对象进行编码。
   对原始输入的编码操作会在指定位置继续进行。 负的位置值将被视为相对于
   输入字符串的末尾。 如果结果位置超出范围则将引发 "IndexError"。

   解码和转换的做法很相似，不同之处在于将把 "UnicodeDecodeError" 或
   "UnicodeTranslateError" 传给处理程序，并且来自错误处理程序的替换对
   象将被直接放入输出。

之前注册的错误处理方案（包括标准错误处理方案）可通过名称进行查找：

codecs.lookup_error(name)

   返回之前在名称 *name* 之下注册的错误处理方案。

   在处理方案无法找到时将引发 "LookupError"。

以下标准错误处理方案也可通过模块层级函数的方式来使用：

codecs.strict_errors(exception)

   实现 "'strict'" 错误处理方案：每个编码或解码错误都会引发
   "UnicodeError"。

codecs.replace_errors(exception)

   实现 "'replace'" 错误处理方案 (仅用于 *文本编码*)：编码错误替换为
   "'?'" (并由编解码器编码)，解码错误替换为 "'\ufffd'" (Unicode 替换字
   符)。

codecs.ignore_errors(exception)

   实现 "'ignore'" 错误处理方案：忽略错误格式的数据并且不加进一步通知
   就继续执行。

codecs.xmlcharrefreplace_errors(exception)

   实现 "'xmlcharrefreplace'" 错误处理方案 (仅用于 *文本编码* 的编码过
   程)：不可编码的字符将以适当的 XML 字符引用进行替换。

codecs.backslashreplace_errors(exception)

   实现 "'backslashreplace'" 错误处理方案 (仅用于 *文本编码*)：错误格
   式的数据将以带反斜杠的转义序列进行替换。

codecs.namereplace_errors(exception)

   实现 "'namereplace'" 错误处理方案 (仅用于 *文本编码* 的编码过程)：
   不可编码的字符将以 "\N{...}" 转义序列进行替换。

   3.5 新版功能.


无状态的编码和解码
------------------

基本 "Codec" 类定义了这些方法，同时还定义了无状态编码器和解码器的函数
接口：

Codec.encode(input[, errors])

   编码 *input* 对象并返回一个元组 (输出对象, 消耗长度)。 例如，*text
   encoding* 会使用特定的字符集编码格式 (例如 "cp1252" 或
   "iso-8859-1") 将字符串转换为字节串对象。

   *errors* 参数定义了要应用的错误处理方案。 默认为 "'strict'" 处理方
   案。

   此方法不一定会在 "Codec" 实例中保存状态。 可使用必须保存状态的
   "StreamWriter" 作为编解码器以便高效地进行编码。

   编码器必须能够处理零长度的输入并在此情况下返回输出对象类型的空对象
   。

Codec.decode(input[, errors])

   解码 *input* 对象并返回一个元组 (输出对象, 消耗长度)。 例如，*text
   encoding* 的解码操作会使用特定的字符集编码格式将字节串对象转换为字
   符串对象。

   对于文本编码格式和字节到字节编解码器，*input* 必须为一个字节串对象
   或提供了只读缓冲区接口的对象 -- 例如，缓冲区对象和映射到内存的文件
   。

   *errors* 参数定义了要应用的错误处理方案。 默认为 "'strict'" 处理方
   案。

   此方法不一定会在 "Codec" 实例中保存状态。 可使用必须保存状态的
   "StreamReader" 作为编解码器以便高效地进行解码。

   The decoder must be able to handle zero length input and return an
   empty object of the output object type in this situation.


Incremental Encoding and Decoding
---------------------------------

The "IncrementalEncoder" and "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
"encode()"/"decode()" method of the incremental encoder/decoder. The
incremental encoder/decoder keeps track of the encoding/decoding
process during method calls.

The joined output of calls to the "encode()"/"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.


IncrementalEncoder Objects
~~~~~~~~~~~~~~~~~~~~~~~~~~

The "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.

class codecs.IncrementalEncoder(errors='strict')

   Constructor for an "IncrementalEncoder" instance.

   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.

   The "IncrementalEncoder" may implement different error handling
   schemes by providing the *errors* keyword argument. See 错误处理方
   案 for possible values.

   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 "IncrementalEncoder" object.

   encode(object[, final])

      Encodes *object* (taking the current state of the encoder into
      account) and returns the resulting encoded object. If this is
      the last call to "encode()" *final* must be true (the default is
      false).

   reset()

      Reset the encoder to the initial state. The output is discarded:
      call ".encode(object, final=True)", passing an empty byte or
      text string if necessary, to reset the encoder and to get the
      output.

   getstate()

      Return the current state of the encoder which must be an
      integer. The implementation should make sure that "0" is the
      most common state. (States that are more complicated than
      integers can be converted into an integer by marshaling/pickling
      the state and encoding the bytes of the resulting string into an
      integer).

   setstate(state)

      Set the state of the encoder to *state*. *state* must be an
      encoder state returned by "getstate()".


IncrementalDecoder Objects
~~~~~~~~~~~~~~~~~~~~~~~~~~

The "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.

class codecs.IncrementalDecoder(errors='strict')

   Constructor for an "IncrementalDecoder" instance.

   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.

   The "IncrementalDecoder" may implement different error handling
   schemes by providing the *errors* keyword argument. See 错误处理方
   案 for possible values.

   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 "IncrementalDecoder" object.

   decode(object[, final])

      Decodes *object* (taking the current state of the decoder into
      account) and returns the resulting decoded object. If this is
      the last call to "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).

   reset()

      Reset the decoder to the initial state.

   getstate()

      Return the current state of the decoder. This must be a tuple
      with two items, the first must be the buffer containing the
      still undecoded input. The second must be an integer and can be
      additional state info. (The implementation should make sure that
      "0" is the most common additional state info.) If this
      additional state info is "0" it must be possible to set the
      decoder to the state which has no input buffered and "0" as the
      additional state info, so that feeding the previously buffered
      input to the decoder returns it to the previous state without
      producing any output. (Additional state info that is more
      complicated than integers can be converted into an integer by
      marshaling/pickling the info and encoding the bytes of the
      resulting string into an integer.)

   setstate(state)

      Set the state of the decoder to *state*. *state* must be a
      decoder state returned by "getstate()".


Stream Encoding and Decoding
----------------------------

The "StreamWriter" and "StreamReader" classes provide generic working
interfaces which can be used to implement new encoding submodules very
easily. See "encodings.utf_8" for an example of how this is done.


StreamWriter Objects
~~~~~~~~~~~~~~~~~~~~

The "StreamWriter" class is a subclass of "Codec" and defines the
following methods which every stream writer must define in order to be
compatible with the Python codec registry.

class codecs.StreamWriter(stream, errors='strict')

   Constructor for a "StreamWriter" instance.

   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.

   The *stream* argument must be a file-like object open for writing
   text or binary data, as appropriate for the specific codec.

   The "StreamWriter" may implement different error handling schemes
   by providing the *errors* keyword argument. See 错误处理方案 for
   the standard error handlers the underlying stream codec may
   support.

   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 "StreamWriter" object.

   write(object)

      Writes the object's contents encoded to the stream.

   writelines(list)

      Writes the concatenated list of strings to the stream (possibly
      by reusing the "write()" method). The standard bytes-to-bytes
      codecs do not support this method.

   reset()

      Flushes and resets the codec buffers used for keeping state.

      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.

In addition to the above methods, the "StreamWriter" must also inherit
all other methods and attributes from the underlying stream.


StreamReader Objects
~~~~~~~~~~~~~~~~~~~~

The "StreamReader" class is a subclass of "Codec" and defines the
following methods which every stream reader must define in order to be
compatible with the Python codec registry.

class codecs.StreamReader(stream, errors='strict')

   Constructor for a "StreamReader" instance.

   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.

   The *stream* argument must be a file-like object open for reading
   text or binary data, as appropriate for the specific codec.

   The "StreamReader" may implement different error handling schemes
   by providing the *errors* keyword argument. See 错误处理方案 for
   the standard error handlers the underlying stream codec may
   support.

   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 "StreamReader" object.

   The set of allowed values for the *errors* argument can be extended
   with "register_error()".

   read([size[, chars[, firstline]]])

      Decodes data from the stream and returns the resulting object.

      The *chars* argument indicates the number of decoded code points
      or bytes to return. The "read()" method will never return more
      data than requested, but it might return less, if there is not
      enough available.

      The *size* argument indicates the approximate maximum number of
      encoded bytes or code points to read for decoding. The decoder
      can modify this setting as appropriate. The default value -1
      indicates to read and decode as much as possible.  This
      parameter is intended to prevent having to decode huge files in
      one step.

      The *firstline* flag indicates that it would be sufficient to
      only return the first line, if there are decoding errors on
      later lines.

      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.

   readline([size[, keepends]])

      Read one line from the input stream and return the decoded data.

      *size*, if given, is passed as size argument to the stream's
      "read()" method.

      If *keepends* is false line-endings will be stripped from the
      lines returned.

   readlines([sizehint[, keepends]])

      Read all lines available on the input stream and return them as
      a list of lines.

      Line-endings are implemented using the codec's decoder method
      and are included in the list entries if *keepends* is true.

      *sizehint*, if given, is passed as the *size* argument to the
      stream's "read()" method.

   reset()

      Resets the codec buffers used for keeping state.

      Note that no stream repositioning should take place.  This
      method is primarily intended to be able to recover from decoding
      errors.

In addition to the above methods, the "StreamReader" must also inherit
all other methods and attributes from the underlying stream.


StreamReaderWriter Objects
~~~~~~~~~~~~~~~~~~~~~~~~~~

The "StreamReaderWriter" is a convenience class that allows wrapping
streams which work in both read and write modes.

The design is such that one can use the factory functions returned by
the "lookup()" function to construct the instance.

class codecs.StreamReaderWriter(stream, Reader, Writer, errors='strict')

   Creates a "StreamReaderWriter" instance. *stream* must be a file-
   like object. *Reader* and *Writer* must be factory functions or
   classes providing the "StreamReader" and "StreamWriter" interface
   resp. Error handling is done in the same way as defined for the
   stream readers and writers.

"StreamReaderWriter" instances define the combined interfaces of
"StreamReader" and "StreamWriter" classes. They inherit all other
methods and attributes from the underlying stream.


StreamRecoder Objects
~~~~~~~~~~~~~~~~~~~~~

The "StreamRecoder" translates data from one encoding to another,
which is sometimes useful when dealing with different encoding
environments.

The design is such that one can use the factory functions returned by
the "lookup()" function to construct the instance.

class codecs.StreamRecoder(stream, encode, decode, Reader, Writer, errors='strict')

   Creates a "StreamRecoder" instance which implements a two-way
   conversion: *encode* and *decode* work on the frontend — the data
   visible to code calling "read()" and "write()", while *Reader* and
   *Writer* work on the backend — the data in *stream*.

   You can use these objects to do transparent transcodings from e.g.
   Latin-1 to UTF-8 and back.

   The *stream* argument must be a file-like object.

   The *encode* and *decode* arguments must adhere to the "Codec"
   interface. *Reader* and *Writer* must be factory functions or
   classes providing objects of the "StreamReader" and "StreamWriter"
   interface respectively.

   Error handling is done in the same way as defined for the stream
   readers and writers.

"StreamRecoder" instances define the combined interfaces of
"StreamReader" and "StreamWriter" classes. They inherit all other
methods and attributes from the underlying stream.


Encodings and Unicode
=====================

Strings are stored internally as sequences of code points in range
"0x0"--"0x10FFFF".  (See **PEP 393** for more details about the
implementation.) Once a string object is used outside of CPU and
memory, endianness and how these arrays are stored as bytes become an
issue.  As with other codecs, serialising a string into a sequence of
bytes is known as *encoding*, and recreating the string from the
sequence of bytes is known as *decoding*. There are a variety of
different text serialisation codecs, which are collectivity referred
to as *text encodings*.

The simplest text encoding (called "'latin-1'" or "'iso-8859-1'") maps
the code points 0--255 to the bytes "0x0"--"0xff", which means that a
string object that contains code points above "U+00FF" can't be
encoded with this codec. Doing so will raise a "UnicodeEncodeError"
that looks like the following (although the details of the error
message may differ): "UnicodeEncodeError: 'latin-1' codec can't encode
character '\u1234' in position 3: ordinal not in range(256)".

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. "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.

All of these encodings can only encode 256 of the 1114112 code points
defined in Unicode. A simple and straightforward way that can store
each Unicode code point, is to store each code point as four
consecutive bytes. There are two possibilities: store the bytes in big
endian or in little endian order. These two encodings are called
"UTF-32-BE" and "UTF-32-LE" respectively. Their disadvantage is that
if e.g. you use "UTF-32-BE" on a little endian machine you will always
have to swap bytes on encoding and decoding. "UTF-32" avoids this
problem: bytes will always be in natural endianness. When these bytes
are read by a CPU with a different endianness, then bytes have to be
swapped though. To be able to detect the endianness of a "UTF-16" or
"UTF-32" byte sequence, there's the so called BOM ("Byte Order Mark").
This is the Unicode character "U+FEFF". This character can be
prepended to every "UTF-16" or "UTF-32" byte sequence. The byte
swapped version of this character ("0xFFFE") is an illegal character
that may not appear in a Unicode text. So when the first character in
an "UTF-16" or "UTF-32" byte sequence appears to be a "U+FFFE" the
bytes have to be swapped on decoding. Unfortunately the character
"U+FEFF" had a second purpose as a "ZERO WIDTH NO-BREAK SPACE": a
character that has no width and doesn't allow a word to be split. It
can e.g. be used to give hints to a ligature algorithm. With Unicode
4.0 using "U+FEFF" as a "ZERO WIDTH NO-BREAK SPACE" has been
deprecated (with "U+2060" ("WORD JOINER") assuming this role).
Nevertheless Unicode software still must be able to handle "U+FEFF" in
both roles: as a BOM it's a device to determine the storage layout of
the encoded bytes, and vanishes once the byte sequence has been
decoded into a string; as a "ZERO WIDTH NO-BREAK SPACE" it's a normal
character that will be decoded like any other.

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):

+-------------------------------------+------------------------------------------------+
| 范围                                | 编码                                           |
|=====================================|================================================|
| "U-00000000" ... "U-0000007F"       | 0xxxxxxx                                       |
+-------------------------------------+------------------------------------------------+
| "U-00000080" ... "U-000007FF"       | 110xxxxx 10xxxxxx                              |
+-------------------------------------+------------------------------------------------+
| "U-00000800" ... "U-0000FFFF"       | 1110xxxx 10xxxxxx 10xxxxxx                     |
+-------------------------------------+------------------------------------------------+
| "U-00010000" ... "U-0010FFFF"       | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx            |
+-------------------------------------+------------------------------------------------+

The least significant bit of the Unicode character is the rightmost x
bit.

As UTF-8 is an 8-bit encoding no BOM is required and any "U+FEFF"
character in the decoded string (even if it's the first character) is
treated as a "ZERO WIDTH NO-BREAK SPACE".

Without external information it's impossible to reliably determine
which encoding was used for encoding a string. Each charmap encoding
can decode any random byte sequence. However that's not possible with
UTF-8, as UTF-8 byte sequences have a structure that doesn't allow
arbitrary byte sequences. To increase the reliability with which a
UTF-8 encoding can be detected, Microsoft invented a variant of UTF-8
(that Python 2.5 calls ""utf-8-sig"") for its Notepad program: Before
any of the Unicode characters is written to the file, a UTF-8 encoded
BOM (which looks like this as a byte sequence: "0xef", "0xbb", "0xbf")
is written. As it's rather improbable that any charmap encoded file
starts with these byte values (which would e.g. map to

      LATIN SMALL LETTER I WITH DIAERESIS
      RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
      INVERTED QUESTION MARK

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.


标准编码
========

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.

**CPython implementation detail:** Some common encodings can bypass
the codecs lookup machinery to improve performance.  These
optimization opportunities are only recognized by CPython for a
limited set of (case insensitive) aliases: utf-8, utf8, latin-1,
latin1, iso-8859-1, iso8859-1, mbcs (Windows only), ascii, us-ascii,
utf-16, utf16, utf-32, utf32, and the same using underscores instead
of dashes. Using alternative aliases for these encodings may result in
slower execution.

在 3.6 版更改: Optimization opportunity recognized for us-ascii.

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:

* an ISO 8859 codeset

* a Microsoft Windows code page, which is typically derived from an
  8859 codeset, but replaces control characters with additional
  graphic characters

* an IBM EBCDIC code page

* an IBM PC code page, which is ASCII compatible

+-------------------+----------------------------------+----------------------------------+
| 编码              | 别名                             | 语言                             |
|===================|==================================|==================================|
| ascii             | 646, us-ascii                    | 英语                             |
+-------------------+----------------------------------+----------------------------------+
| big5              | big5-tw, csbig5                  | 繁体中文                         |
+-------------------+----------------------------------+----------------------------------+
| big5hkscs         | big5-hkscs, hkscs                | 繁体中文                         |
+-------------------+----------------------------------+----------------------------------+
| cp037             | IBM037, IBM039                   | 英语                             |
+-------------------+----------------------------------+----------------------------------+
| cp273             | 273, IBM273, csIBM273            | 德语  3.4 新版功能.              |
+-------------------+----------------------------------+----------------------------------+
| cp424             | EBCDIC-CP-HE, IBM424             | 希伯来语                         |
+-------------------+----------------------------------+----------------------------------+
| cp437             | 437, IBM437                      | 英语                             |
+-------------------+----------------------------------+----------------------------------+
| cp500             | EBCDIC-CP-BE, EBCDIC-CP-CH,      | 西欧                             |
|                   | IBM500                           |                                  |
+-------------------+----------------------------------+----------------------------------+
| cp720             |                                  | 阿拉伯语                         |
+-------------------+----------------------------------+----------------------------------+
| cp737             |                                  | 希腊语                           |
+-------------------+----------------------------------+----------------------------------+
| cp775             | IBM775                           | 波罗的海语言                     |
+-------------------+----------------------------------+----------------------------------+
| cp850             | 850, IBM850                      | 西欧                             |
+-------------------+----------------------------------+----------------------------------+
| cp852             | 852, IBM852                      | 中欧和东欧                       |
+-------------------+----------------------------------+----------------------------------+
| cp855             | 855, IBM855                      | 保加利亚语，白俄罗斯语，马其顿语 |
|                   |                                  | ，俄语，塞尔维亚语               |
+-------------------+----------------------------------+----------------------------------+
| cp856             |                                  | 希伯来语                         |
+-------------------+----------------------------------+----------------------------------+
| cp857             | 857, IBM857                      | 土耳其语                         |
+-------------------+----------------------------------+----------------------------------+
| cp858             | 858, IBM858                      | 西欧                             |
+-------------------+----------------------------------+----------------------------------+
| cp860             | 860, IBM860                      | 葡萄牙语                         |
+-------------------+----------------------------------+----------------------------------+
| cp861             | 861, CP-IS, IBM861               | 冰岛语                           |
+-------------------+----------------------------------+----------------------------------+
| cp862             | 862, IBM862                      | 希伯来语                         |
+-------------------+----------------------------------+----------------------------------+
| cp863             | 863, IBM863                      | 加拿大语                         |
+-------------------+----------------------------------+----------------------------------+
| cp864             | IBM864                           | 阿拉伯语                         |
+-------------------+----------------------------------+----------------------------------+
| cp865             | 865, IBM865                      | 丹麦语/挪威语                    |
+-------------------+----------------------------------+----------------------------------+
| cp866             | 866, IBM866                      | 俄语                             |
+-------------------+----------------------------------+----------------------------------+
| cp869             | 869, CP-GR, IBM869               | 希腊语                           |
+-------------------+----------------------------------+----------------------------------+
| cp874             |                                  | 泰语                             |
+-------------------+----------------------------------+----------------------------------+
| cp875             |                                  | 希腊语                           |
+-------------------+----------------------------------+----------------------------------+
| cp932             | 932, ms932, mskanji, ms-kanji    | 日语                             |
+-------------------+----------------------------------+----------------------------------+
| cp949             | 949, ms949, uhc                  | 韩语                             |
+-------------------+----------------------------------+----------------------------------+
| cp950             | 950, ms950                       | 繁体中文                         |
+-------------------+----------------------------------+----------------------------------+
| cp1006            |                                  | 乌尔都语                         |
+-------------------+----------------------------------+----------------------------------+
| cp1026            | ibm1026                          | 土耳其语                         |
+-------------------+----------------------------------+----------------------------------+
| cp1125            | 1125, ibm1125, cp866u, ruscii    | 乌克兰语  3.4 新版功能.          |
+-------------------+----------------------------------+----------------------------------+
| cp1140            | ibm1140                          | 西欧                             |
+-------------------+----------------------------------+----------------------------------+
| cp1250            | windows-1250                     | 中欧和东欧                       |
+-------------------+----------------------------------+----------------------------------+
| cp1251            | windows-1251                     | 保加利亚语，白俄罗斯语，马其顿语 |
|                   |                                  | ，俄语，塞尔维亚语               |
+-------------------+----------------------------------+----------------------------------+
| cp1252            | windows-1252                     | 西欧                             |
+-------------------+----------------------------------+----------------------------------+
| cp1253            | windows-1253                     | 希腊语                           |
+-------------------+----------------------------------+----------------------------------+
| cp1254            | windows-1254                     | 土耳其语                         |
+-------------------+----------------------------------+----------------------------------+
| cp1255            | windows-1255                     | 希伯来语                         |
+-------------------+----------------------------------+----------------------------------+
| cp1256            | windows-1256                     | 阿拉伯语                         |
+-------------------+----------------------------------+----------------------------------+
| cp1257            | windows-1257                     | 波罗的海语言                     |
+-------------------+----------------------------------+----------------------------------+
| cp1258            | windows-1258                     | 越南语                           |
+-------------------+----------------------------------+----------------------------------+
| euc_jp            | eucjp, ujis, u-jis               | 日语                             |
+-------------------+----------------------------------+----------------------------------+
| euc_jis_2004      | jisx0213, eucjis2004             | 日语                             |
+-------------------+----------------------------------+----------------------------------+
| euc_jisx0213      | eucjisx0213                      | 日语                             |
+-------------------+----------------------------------+----------------------------------+
| euc_kr            | euckr, korean, ksc5601,          | 韩语                             |
|                   | ks_c-5601, ks_c-5601-1987,       |                                  |
|                   | ksx1001, ks_x-1001               |                                  |
+-------------------+----------------------------------+----------------------------------+
| gb2312            | chinese, csiso58gb231280, euc-   | 简体中文                         |
|                   | cn, euccn, eucgb2312-cn,         |                                  |
|                   | gb2312-1980, gb2312-80, iso-     |                                  |
|                   | ir-58                            |                                  |
+-------------------+----------------------------------+----------------------------------+
| gbk               | 936, cp936, ms936                | 统一汉语                         |
+-------------------+----------------------------------+----------------------------------+
| gb18030           | gb18030-2000                     | 统一汉语                         |
+-------------------+----------------------------------+----------------------------------+
| hz                | hzgb, hz-gb, hz-gb-2312          | 简体中文                         |
+-------------------+----------------------------------+----------------------------------+
| iso2022_jp        | csiso2022jp, iso2022jp,          | 日语                             |
|                   | iso-2022-jp                      |                                  |
+-------------------+----------------------------------+----------------------------------+
| iso2022_jp_1      | iso2022jp-1, iso-2022-jp-1       | 日语                             |
+-------------------+----------------------------------+----------------------------------+
| iso2022_jp_2      | iso2022jp-2, iso-2022-jp-2       | 日语，韩语，简体中文，西欧，希腊 |
|                   |                                  | 语                               |
+-------------------+----------------------------------+----------------------------------+
| iso2022_jp_2004   | iso2022jp-2004, iso-2022-jp-2004 | 日语                             |
+-------------------+----------------------------------+----------------------------------+
| iso2022_jp_3      | iso2022jp-3, iso-2022-jp-3       | 日语                             |
+-------------------+----------------------------------+----------------------------------+
| iso2022_jp_ext    | iso2022jp-ext, iso-2022-jp-ext   | 日语                             |
+-------------------+----------------------------------+----------------------------------+
| iso2022_kr        | csiso2022kr, iso2022kr,          | 韩语                             |
|                   | iso-2022-kr                      |                                  |
+-------------------+----------------------------------+----------------------------------+
| latin_1           | iso-8859-1, iso8859-1, 8859,     | 西欧                             |
|                   | cp819, latin, latin1, L1         |                                  |
+-------------------+----------------------------------+----------------------------------+
| iso8859_2         | iso-8859-2, latin2, L2           | 中欧和东欧                       |
+-------------------+----------------------------------+----------------------------------+
| iso8859_3         | iso-8859-3, latin3, L3           | 世界语，马耳他语                 |
+-------------------+----------------------------------+----------------------------------+
| iso8859_4         | iso-8859-4, latin4, L4           | 波罗的海语言                     |
+-------------------+----------------------------------+----------------------------------+
| iso8859_5         | iso-8859-5, cyrillic             | 保加利亚语，白俄罗斯语，马其顿语 |
|                   |                                  | ，俄语，塞尔维亚语               |
+-------------------+----------------------------------+----------------------------------+
| iso8859_6         | iso-8859-6, arabic               | 阿拉伯语                         |
+-------------------+----------------------------------+----------------------------------+
| iso8859_7         | iso-8859-7, greek, greek8        | 希腊语                           |
+-------------------+----------------------------------+----------------------------------+
| iso8859_8         | iso-8859-8, hebrew               | 希伯来语                         |
+-------------------+----------------------------------+----------------------------------+
| iso8859_9         | iso-8859-9, latin5, L5           | 土耳其语                         |
+-------------------+----------------------------------+----------------------------------+
| iso8859_10        | iso-8859-10, latin6, L6          | 北欧语言                         |
+-------------------+----------------------------------+----------------------------------+
| iso8859_11        | iso-8859-11, thai                | 泰语                             |
+-------------------+----------------------------------+----------------------------------+
| iso8859_13        | iso-8859-13, latin7, L7          | 波罗的海语言                     |
+-------------------+----------------------------------+----------------------------------+
| iso8859_14        | iso-8859-14, latin8, L8          | 凯尔特语                         |
+-------------------+----------------------------------+----------------------------------+
| iso8859_15        | iso-8859-15, latin9, L9          | 西欧                             |
+-------------------+----------------------------------+----------------------------------+
| iso8859_16        | iso-8859-16, latin10, L10        | 东南欧                           |
+-------------------+----------------------------------+----------------------------------+
| johab             | cp1361, ms1361                   | 韩语                             |
+-------------------+----------------------------------+----------------------------------+
| koi8_r            |                                  | 俄语                             |
+-------------------+----------------------------------+----------------------------------+
| koi8_t            |                                  | 塔吉克  3.5 新版功能.            |
+-------------------+----------------------------------+----------------------------------+
| koi8_u            |                                  | 乌克兰语                         |
+-------------------+----------------------------------+----------------------------------+
| kz1048            | kz_1048, strk1048_2002, rk1048   | 哈萨克语  3.5 新版功能.          |
+-------------------+----------------------------------+----------------------------------+
| mac_cyrillic      | maccyrillic                      | 保加利亚语，白俄罗斯语，马其顿语 |
|                   |                                  | ，俄语，塞尔维亚语               |
+-------------------+----------------------------------+----------------------------------+
| mac_greek         | macgreek                         | 希腊语                           |
+-------------------+----------------------------------+----------------------------------+
| mac_iceland       | maciceland                       | 冰岛语                           |
+-------------------+----------------------------------+----------------------------------+
| mac_latin2        | maclatin2, maccentraleurope      | 中欧和东欧                       |
+-------------------+----------------------------------+----------------------------------+
| mac_roman         | macroman, macintosh              | 西欧                             |
+-------------------+----------------------------------+----------------------------------+
| mac_turkish       | macturkish                       | 土耳其语                         |
+-------------------+----------------------------------+----------------------------------+
| ptcp154           | csptcp154, pt154, cp154,         | 哈萨克语                         |
|                   | cyrillic-asian                   |                                  |
+-------------------+----------------------------------+----------------------------------+
| shift_jis         | csshiftjis, shiftjis, sjis,      | 日语                             |
|                   | s_jis                            |                                  |
+-------------------+----------------------------------+----------------------------------+
| shift_jis_2004    | shiftjis2004, sjis_2004,         | 日语                             |
|                   | sjis2004                         |                                  |
+-------------------+----------------------------------+----------------------------------+
| shift_jisx0213    | shiftjisx0213, sjisx0213,        | 日语                             |
|                   | s_jisx0213                       |                                  |
+-------------------+----------------------------------+----------------------------------+
| utf_32            | U32, utf32                       | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+
| utf_32_be         | UTF-32BE                         | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+
| utf_32_le         | UTF-32LE                         | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+
| utf_16            | U16, utf16                       | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+
| utf_16_be         | UTF-16BE                         | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+
| utf_16_le         | UTF-16LE                         | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+
| utf_7             | U7, unicode-1-1-utf-7            | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+
| utf_8             | U8, UTF, utf8, cp65001           | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+
| utf_8_sig         |                                  | 所有语言                         |
+-------------------+----------------------------------+----------------------------------+

在 3.4 版更改: The utf-16* and utf-32* encoders no longer allow
surrogate code points ("U+D800"--"U+DFFF") to be encoded. The utf-32*
decoders no longer decode byte sequences that correspond to surrogate
code points.

在 3.8 版更改: "cp65001" is now an alias to "utf_8".


Python Specific Encodings
=========================

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.


文字编码
--------

The following codecs provide "str" to "bytes" encoding and *bytes-like
object* to "str" decoding, similar to the Unicode text encodings.

+----------------------+-----------+-----------------------------+
| 编码                 | 别名      | 目的                        |
|======================|===========|=============================|
| idna                 |           | Implements **RFC 3490**,    |
|                      |           | see also "encodings.idna".  |
|                      |           | Only "errors='strict'" is   |
|                      |           | supported.                  |
+----------------------+-----------+-----------------------------+
| mbcs                 | ansi,     | Windows only: Encode        |
|                      | dbcs      | operand according to the    |
|                      |           | ANSI codepage (CP_ACP)      |
+----------------------+-----------+-----------------------------+
| oem                  |           | Windows only: Encode        |
|                      |           | operand according to the    |
|                      |           | OEM codepage (CP_OEMCP)     |
|                      |           | 3.6 新版功能.               |
+----------------------+-----------+-----------------------------+
| palmos               |           | Encoding of PalmOS 3.5      |
+----------------------+-----------+-----------------------------+
| punycode             |           | Implements **RFC 3492**.    |
|                      |           | Stateful codecs are not     |
|                      |           | supported.                  |
+----------------------+-----------+-----------------------------+
| raw_unicode_escape   |           | Latin-1 encoding with       |
|                      |           | "\uXXXX" and "\UXXXXXXXX"   |
|                      |           | for other code points.      |
|                      |           | Existing backslashes are    |
|                      |           | not escaped in any way. It  |
|                      |           | is used in the Python       |
|                      |           | pickle protocol.            |
+----------------------+-----------+-----------------------------+
| undefined            |           | Raise an exception for all  |
|                      |           | conversions, even empty     |
|                      |           | strings. The error handler  |
|                      |           | is ignored.                 |
+----------------------+-----------+-----------------------------+
| unicode_escape       |           | Encoding suitable as the    |
|                      |           | contents of a Unicode       |
|                      |           | literal in ASCII- encoded   |
|                      |           | Python source code, except  |
|                      |           | that quotes are not         |
|                      |           | escaped. Decodes from       |
|                      |           | Latin-1 source code. Beware |
|                      |           | that Python source code     |
|                      |           | actually uses UTF-8 by      |
|                      |           | default.                    |
+----------------------+-----------+-----------------------------+

在 3.8 版更改: "unicode_internal" codec is removed.


二进制转换
----------

The following codecs provide binary transforms: *bytes-like object* to
"bytes" mappings.  They are not supported by "bytes.decode()" (which
only produces "str" output).

+------------------------+--------------------+--------------------------------+--------------------------------+
| 编码                   | 别名               | 目的                           | 编码器/解码器                  |
|========================|====================|================================|================================|
| base64_codec [1]       | base64, base_64    | Convert operand to multiline   | "base64.encodebytes()" /       |
|                        |                    | MIME base64 (the result always | "base64.decodebytes()"         |
|                        |                    | includes a trailing "'\n'")    |                                |
|                        |                    | 在 3.4 版更改: accepts any     |                                |
|                        |                    | *bytes-like object* as input   |                                |
|                        |                    | for encoding and decoding      |                                |
+------------------------+--------------------+--------------------------------+--------------------------------+
| bz2_codec              | bz2                | 使用bz2压缩操作数              | "bz2.compress()" /             |
|                        |                    |                                | "bz2.decompress()"             |
+------------------------+--------------------+--------------------------------+--------------------------------+
| hex_codec              | hex                | 将操作数转换为十六进制表示，每 | "binascii.b2a_hex()" /         |
|                        |                    | 个字节有两位数                 | "binascii.a2b_hex()"           |
+------------------------+--------------------+--------------------------------+--------------------------------+
| quopri_codec           | quopri,            | Convert operand to MIME quoted | "quopri.encode()" with         |
|                        | quotedprintable,   | printable                      | "quotetabs=True" /             |
|                        | quoted_printable   |                                | "quopri.decode()"              |
+------------------------+--------------------+--------------------------------+--------------------------------+
| uu_codec               | uu                 | 使用uuencode转换操作数         | "uu.encode()" / "uu.decode()"  |
+------------------------+--------------------+--------------------------------+--------------------------------+
| zlib_codec             | zip, zlib          | 使用gzip压缩操作数             | "zlib.compress()" /            |
|                        |                    |                                | "zlib.decompress()"            |
+------------------------+--------------------+--------------------------------+--------------------------------+

[1] In addition to *bytes-like objects*, "'base64_codec'" also
    accepts ASCII-only instances of "str" for decoding

3.2 新版功能: 恢复二进制转换。

在 3.4 版更改: 恢复二进制转换的别名。


文字转换
--------

The following codec provides a text transform: a "str" to "str"
mapping.  It is not supported by "str.encode()" (which only produces
"bytes" output).

+----------------------+-----------+-----------------------------+
| 编码                 | 别名      | 目的                        |
|======================|===========|=============================|
| rot_13               | rot13     | Returns the Caesar-cypher   |
|                      |           | encryption of the operand   |
+----------------------+-----------+-----------------------------+

3.2 新版功能: Restoration of the "rot_13" text transform.

在 3.4 版更改: Restoration of the "rot13" alias.


"encodings.idna" --- 应用程序中的国际化域名
===========================================

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 "stringprep".

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
*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.

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 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 "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 "http.client" and "ftplib", accept
Unicode host names ("http.client" then also transparently sends an
IDNA hostname in the *Host* field if it sends that field at all).

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.

The module "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.

encodings.idna.nameprep(label)

   Return the nameprepped version of *label*. The implementation
   currently assumes query strings, so "AllowUnassigned" is true.

encodings.idna.ToASCII(label)

   Convert a label to ASCII, as specified in **RFC 3490**.
   "UseSTD3ASCIIRules" is assumed to be false.

encodings.idna.ToUnicode(label)

   Convert a label to Unicode, as specified in **RFC 3490**.


"encodings.mbcs" --- Windows ANSI代码页
=======================================

根据ANSI代码页（CP_ACP）对操作数进行编码。

Availability: 仅Windows可用

在 3.3 版更改: 支持任何错误处理

在 3.2 版更改: Before 3.2, the *errors* argument was ignored;
"'replace'" was always used to encode, and "'ignore'" to decode.


"encodings.utf_8_sig" --- 带BOM签名的UTF-8编解码器
==================================================

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.
