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 编解码器都定义并实现了以下字符串值:
值 |
含义 |
---|---|
|
引发 |
|
忽略错误格式的数据并且不加进一步通知就继续执行。 在 |
以下错误处理方案仅适用于 文本编码:
值 |
含义 |
---|---|
|
使用适当的替换标记进行替换;Python 内置编解码器将在解码时使用官方 |
|
使用适当的 XML 字符引用进行替换(仅在编码时)。 在 |
|
使用带反斜杠的转义序列进行替换。 在 |
|
使用 |
|
在解码时,将字节替换为 |
此外,以下错误处理方案被专门用于指定的编解码器:
值 |
编解码器 |
含义 |
---|---|---|
|
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 字符引用进行替换。
无状态的编码和解码¶
基本 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 is0
it must be possible to set the decoder to the state which has no input buffered and0
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 theStreamReader
andStreamWriter
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 callingread()
andwrite()
, 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 theStreamReader
andStreamWriter
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):
范围 |
编码 |
---|---|
|
0xxxxxxx |
|
110xxxxx 10xxxxxx |
|
1110xxxx 10xxxxxx 10xxxxxx |
|
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 DIAERESISRIGHT-POINTING DOUBLE ANGLE QUOTATION MARKINVERTED 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
|
|
mbcs |
ansi, dbcs |
Windows only: Encode 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
|
|
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
MIME base64 (the result
always includes a trailing
在 3.4 版更改: accepts any bytes-like object as input for encoding and decoding |
|
bz2_codec |
bz2 |
使用bz2压缩操作数 |
|
hex_codec |
hex |
将操作数转换为十六进制表示,每个字节有两位数 |
|
quopri_codec |
quopri, quotedprintable, quoted_printable |
Convert operand to MIME quoted printable |
|
uu_codec |
uu |
使用uuencode转换操作数 |
|
zlib_codec |
zip, zlib |
使用gzip压缩操作数 |
- 1
In addition to bytes-like objects,
'base64_codec'
also accepts ASCII-only instances ofstr
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.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.