# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.9\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-01-03 16:35+0000\n"

"PO-Revision-Date: 2025-09-22 17:54+0000\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/codecs.rst:2

msgid ":mod:`codecs` --- Codec registry and base classes"

msgstr ":mod:`codecs` --- 编解码器注册和相关基类"

#: ../../library/codecs.rst:11

msgid "**Source code:** :source:`Lib/codecs.py`"

msgstr "**源代码：** :source:`Lib/codecs.py`"

#: ../../library/codecs.rst:23

msgid ""

"This module defines base classes for standard Python codecs (encoders and "

"decoders) and provides access to the internal Python codec registry, which "

"manages the codec and error handling lookup process. Most standard codecs "

"are :term:`text encodings <text encoding>`, which encode text to bytes (and "

"decode bytes to text), but there are also codecs provided that encode text "

"to text, and bytes to bytes. Custom codecs may encode and decode between "

"arbitrary types, but some module features are restricted to be used "

"specifically with :term:`text encodings <text encoding>` or with codecs that"

" encode to :class:`bytes`."

msgstr ""

"这个模块定义了标准 Python 编解码器（编码器和解码器）的基类并提供对内部 Python "

"编解码器注册表的访问，该注册表负责管理编解码器和错误处理的查找过程。 大多数标准编解码器都属于 :term:`文本编码格式 <text "

"encoding>`，它们可将文本编码为字节串（以及将字节串解码为文本），但也提供了一些将文本编码为文本，以及将字节串编码为字节串的编解码器。 "

"自定义编解码器可以在任意类型间进行编码和解码，但某些模块特性被限制为仅适用于 :term:`文本编码格式 <text encoding>` "

"或将数据编码为 :class:`bytes` 的编解码器。"

#: ../../library/codecs.rst:33

msgid ""

"The module defines the following functions for encoding and decoding with "

"any codec:"

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

#: ../../library/codecs.rst:38

msgid "Encodes *obj* using the codec registered for *encoding*."

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

#: ../../library/codecs.rst:40

msgid ""

"*Errors* may be given to set the desired error handling scheme. The default "

"error handler is ``'strict'`` meaning that encoding errors raise "

":exc:`ValueError` (or a more codec specific subclass, such as "

":exc:`UnicodeEncodeError`). Refer to :ref:`codec-base-classes` for more "

"information on codec error handling."

msgstr ""

"可以给定 *Errors* 以设置所需要的错误处理方案。 默认的错误处理方案 ``'strict'`` 表示编码错误将引发 "

":exc:`ValueError` (或更特定编解码器相关的子类，例如 :exc:`UnicodeEncodeError`)。 请参阅 "

":ref:`codec-base-classes` 了解有关编解码器错误处理的更多信息。"

#: ../../library/codecs.rst:48

msgid "Decodes *obj* using the codec registered for *encoding*."

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

#: ../../library/codecs.rst:50

msgid ""

"*Errors* may be given to set the desired error handling scheme. The default "

"error handler is ``'strict'`` meaning that decoding errors raise "

":exc:`ValueError` (or a more codec specific subclass, such as "

":exc:`UnicodeDecodeError`). Refer to :ref:`codec-base-classes` for more "

"information on codec error handling."

msgstr ""

"可以给定 *Errors* 以设置所需要的错误处理方案。 默认的错误处理方案 ``'strict'`` 表示编码错误将引发 "

":exc:`ValueError` (或更特定编解码器相关的子类，例如 :exc:`UnicodeDecodeError`)。 请参阅 "

":ref:`codec-base-classes` 了解有关编解码器错误处理的更多信息。"

#: ../../library/codecs.rst:56

msgid "The full details for each codec can also be looked up directly:"

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

#: ../../library/codecs.rst:60

msgid ""

"Looks up the codec info in the Python codec registry and returns a "

":class:`CodecInfo` object as defined below."

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

#: ../../library/codecs.rst:63

msgid ""

"Encodings are first looked up in the registry's cache. If not found, the "

"list of registered search functions is scanned. If no :class:`CodecInfo` "

"object is found, a :exc:`LookupError` is raised. Otherwise, the "

":class:`CodecInfo` object is stored in the cache and returned to the caller."

msgstr ""

"首先将会在注册表缓存中查找编码，如果未找到，则会扫描注册的搜索函数列表。 如果没有找到 :class:`CodecInfo` 对象，则将引发 "

":exc:`LookupError`。 否则，:class:`CodecInfo` 对象将被存入缓存并返回给调用者。"

#: ../../library/codecs.rst:70

msgid ""

"Codec details when looking up the codec registry. The constructor arguments "

"are stored in attributes of the same name:"

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

#: ../../library/codecs.rst:76

msgid "The name of the encoding."

msgstr "编码名称"

#: ../../library/codecs.rst:82

msgid ""

"The stateless encoding and decoding functions. These must be functions or "

"methods which have the same interface as the :meth:`~Codec.encode` and "

":meth:`~Codec.decode` methods of Codec instances (see :ref:`Codec Interface "

"<codec-objects>`). The functions or methods are expected to work in a "

"stateless mode."

msgstr ""

"无状态的编码和解码函数。 它们必须是具有与 Codec 的 :meth:`~Codec.encode` 和 :meth:`~Codec.decode` "

"方法相同接口的函数或方法 (参见 :ref:`Codec 接口 <codec-objects>`)。 这些函数或方法应当工作于无状态的模式。"

#: ../../library/codecs.rst:92

msgid ""

"Incremental encoder and decoder classes or factory functions. These have to "

"provide the interface defined by the base classes "

":class:`IncrementalEncoder` and :class:`IncrementalDecoder`, respectively. "

"Incremental codecs can maintain state."

msgstr ""

"增量式的编码器和解码器类或工厂函数。 这些函数必须分别提供由基类 :class:`IncrementalEncoder` 和 "

":class:`IncrementalDecoder` 所定义的接口。 增量式编解码器可以保持状态。"

#: ../../library/codecs.rst:101

msgid ""

"Stream writer and reader classes or factory functions. These have to provide"

" the interface defined by the base classes :class:`StreamWriter` and "

":class:`StreamReader`, respectively. Stream codecs can maintain state."

msgstr ""

"流式写入器和读取器类或工厂函数。 这些函数必须分别提供由基类 :class:`StreamWriter` 和 :class:`StreamReader`"

" 所定义的接口。 流式编解码器可以保持状态。"

#: ../../library/codecs.rst:106

msgid ""

"To simplify access to the various codec components, the module provides "

"these additional functions which use :func:`lookup` for the codec lookup:"

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

#: ../../library/codecs.rst:111

msgid ""

"Look up the codec for the given encoding and return its encoder function."

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

#: ../../library/codecs.rst:113 ../../library/codecs.rst:120

#: ../../library/codecs.rst:146 ../../library/codecs.rst:154

msgid "Raises a :exc:`LookupError` in case the encoding cannot be found."

msgstr "在编码无法找到时将引发 :exc:`LookupError`。"

#: ../../library/codecs.rst:118

msgid ""

"Look up the codec for the given encoding and return its decoder function."

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

#: ../../library/codecs.rst:125

msgid ""

"Look up the codec for the given encoding and return its incremental encoder "

"class or factory function."

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

#: ../../library/codecs.rst:128

msgid ""

"Raises a :exc:`LookupError` in case the encoding cannot be found or the "

"codec doesn't support an incremental encoder."

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

#: ../../library/codecs.rst:134

msgid ""

"Look up the codec for the given encoding and return its incremental decoder "

"class or factory function."

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

#: ../../library/codecs.rst:137

msgid ""

"Raises a :exc:`LookupError` in case the encoding cannot be found or the "

"codec doesn't support an incremental decoder."

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

#: ../../library/codecs.rst:143

msgid ""

"Look up the codec for the given encoding and return its "

":class:`StreamReader` class or factory function."

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

#: ../../library/codecs.rst:151

msgid ""

"Look up the codec for the given encoding and return its "

":class:`StreamWriter` class or factory function."

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

#: ../../library/codecs.rst:156

msgid ""

"Custom codecs are made available by registering a suitable codec search "

"function:"

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

#: ../../library/codecs.rst:161

msgid ""

"Register a codec search function. Search functions are expected to take one "

"argument, being the encoding name in all lower case letters with hyphens and"

" spaces converted to underscores, and return a :class:`CodecInfo` object. In"

" case a search function cannot find a given encoding, it should return "

"``None``."

msgstr ""

"注册一个编解码器搜索函数。 搜索函数预期接收一个参数，即全部以小写字母表示的编码格式名称，其中中连字符和空格会被转换为下划线，并返回一个 "

":class:`CodecInfo` 对象。 在搜索函数无法找到给定编码格式的情况下，它应当返回 ``None``。"

#: ../../library/codecs.rst:167

msgid "Hyphens and spaces are converted to underscore."

msgstr "连字符和空格会被转换为下划线。"

#: ../../library/codecs.rst:172

msgid ""

"Search function registration is not currently reversible, which may cause "

"problems in some cases, such as unit testing or module reloading."

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

#: ../../library/codecs.rst:176

msgid ""

"While the builtin :func:`open` and the associated :mod:`io` module are the "

"recommended approach for working with encoded text files, this module "

"provides additional utility functions and classes that allow the use of a "

"wider range of codecs when working with binary files:"

msgstr ""

"虽然内置的 :func:`open` 和相关联的 :mod:`io` "

"模块是操作已编码文本文件的推荐方式，但本模块也提供了额外的工具函数和类，允许在操作二进制文件时使用更多种类的编解码器："

#: ../../library/codecs.rst:183

msgid ""

"Open an encoded file using the given *mode* and return an instance of "

":class:`StreamReaderWriter`, providing transparent encoding/decoding. The "

"default file mode is ``'r'``, meaning to open the file in read mode."

msgstr ""

"使用给定的 *mode* 打开已编码的文件并返回一个 :class:`StreamReaderWriter` 的实例，提供透明的编码/解码。 "

"默认的文件模式为 ``'r'``，表示以读取模式打开文件。"

#: ../../library/codecs.rst:189

msgid ""

"Underlying encoded files are always opened in binary mode. No automatic "

"conversion of ``'\\n'`` is done on reading and writing. The *mode* argument "

"may be any binary mode acceptable to the built-in :func:`open` function; the"

" ``'b'`` is automatically added."

msgstr ""

"下层的已编码文件总是以二进制模式打开。 在读取和写入时不会自动执行 ``'\\n'`` 的转换。 *mode* 参数可以是内置 :func:`open`"

" 函数所接受的任意二进制模式；``'b'`` 会被自动添加。"

#: ../../library/codecs.rst:194

msgid ""

"*encoding* specifies the encoding which is to be used for the file. Any "

"encoding that encodes to and decodes from bytes is allowed, and the data "

"types supported by the file methods depend on the codec used."

msgstr ""

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

#: ../../library/codecs.rst:198

msgid ""

"*errors* may be given to define the error handling. It defaults to "

"``'strict'`` which causes a :exc:`ValueError` to be raised in case an "

"encoding error occurs."

msgstr ""

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

#: ../../library/codecs.rst:201

msgid ""

"*buffering* has the same meaning as for the built-in :func:`open` function. "

"It defaults to -1 which means that the default buffer size will be used."

msgstr "*buffering* 的含义与内置 :func:`open` 函数中的相同。 默认值 -1 表示将使用默认的缓冲区大小。"

#: ../../library/codecs.rst:207

msgid ""

"Return a :class:`StreamRecoder` instance, a wrapped version of *file* which "

"provides transparent transcoding. The original file is closed when the "

"wrapped version is closed."

msgstr ""

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

#: ../../library/codecs.rst:211

msgid ""

"Data written to the wrapped file is decoded according to the given "

"*data_encoding* and then written to the original file as bytes using "

"*file_encoding*. Bytes read from the original file are decoded according to "

"*file_encoding*, and the result is encoded using *data_encoding*."

msgstr ""

"写入已包装文件的数据会根据给定的 *data_encoding* 解码，然后以使用 *file_encoding* 的字节形式写入原始文件。 "

"从原始文件读取的字节串将根据 *file_encoding* 解码，其结果将使用 *data_encoding* 进行编码。"

#: ../../library/codecs.rst:217

msgid "If *file_encoding* is not given, it defaults to *data_encoding*."

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

#: ../../library/codecs.rst:219

msgid ""

"*errors* may be given to define the error handling. It defaults to "

"``'strict'``, which causes :exc:`ValueError` to be raised in case an "

"encoding error occurs."

msgstr ""

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

#: ../../library/codecs.rst:226

msgid ""

"Uses an incremental encoder to iteratively encode the input provided by "

"*iterator*. This function is a :term:`generator`. The *errors* argument (as "

"well as any other keyword argument) is passed through to the incremental "

"encoder."

msgstr ""

"使用增量式编码器通过迭代来编码由 *iterator* 所提供的输入。 此函数属于 :term:`generator`。 *errors* "

"参数（以及任何其他关键字参数）会被传递给增量式编码器。"

#: ../../library/codecs.rst:231

msgid ""

"This function requires that the codec accept text :class:`str` objects to "

"encode. Therefore it does not support bytes-to-bytes encoders such as "

"``base64_codec``."

msgstr ""

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

#: ../../library/codecs.rst:238

msgid ""

"Uses an incremental decoder to iteratively decode the input provided by "

"*iterator*. This function is a :term:`generator`. The *errors* argument (as "

"well as any other keyword argument) is passed through to the incremental "

"decoder."

msgstr ""

"使用增量式解码器通过迭代来解码由 *iterator* 所提供的输入。 此函数属于 :term:`generator`。 *errors* "

"参数（以及任何其他关键字参数）会被传递给增量式解码器。"

#: ../../library/codecs.rst:243

msgid ""

"This function requires that the codec accept :class:`bytes` objects to "

"decode. Therefore it does not support text-to-text encoders such as "

"``rot_13``, although ``rot_13`` may be used equivalently with "

":func:`iterencode`."

msgstr ""

"此函数要求编解码器接受 :class:`bytes` 对象进行解码。 因此它不支持文本到文本的编码器，例如 ``rot_13``，但是 "

"``rot_13`` 可以通过同样效果的 :func:`iterencode` 来使用。"

#: ../../library/codecs.rst:249

msgid ""

"The module also provides the following constants which are useful for "

"reading and writing to platform dependent files:"

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

#: ../../library/codecs.rst:264

msgid ""

"These constants define various byte sequences, being Unicode byte order "

"marks (BOMs) for several encodings. They are used in UTF-16 and UTF-32 data "

"streams to indicate the byte order used, and in UTF-8 as a Unicode "

"signature. :const:`BOM_UTF16` is either :const:`BOM_UTF16_BE` or "

":const:`BOM_UTF16_LE` depending on the platform's native byte order, "

":const:`BOM` is an alias for :const:`BOM_UTF16`, :const:`BOM_LE` for "

":const:`BOM_UTF16_LE` and :const:`BOM_BE` for :const:`BOM_UTF16_BE`. The "

"others represent the BOM in UTF-8 and UTF-32 encodings."

msgstr ""

"这些常量定义了多种字节序列，即一些编码格式的 Unicode 字节顺序标记（BOM）。 它们在 UTF-16 和 UTF-32 "

"数据流中被用以指明所使用的字节顺序，并在 UTF-8 中被用作 Unicode 签名。 :const:`BOM_UTF16` 是 "

":const:`BOM_UTF16_BE` 或 :const:`BOM_UTF16_LE`，具体取决于平台的本机字节顺序，:const:`BOM` 是 "

":const:`BOM_UTF16` 的别名, :const:`BOM_LE` 是 :const:`BOM_UTF16_LE` "

"的别名，:const:`BOM_BE` 是 :const:`BOM_UTF16_BE` 的别名。 其他序列则表示 UTF-8 和 UTF-32 "

"编码格式中的 BOM。"

#: ../../library/codecs.rst:278

msgid "Codec Base Classes"

msgstr "编解码器基类"

#: ../../library/codecs.rst:280

msgid ""

"The :mod:`codecs` module defines a set of base classes which define the "

"interfaces for working with codec objects, and can also be used as the basis"

" for custom codec implementations."

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

#: ../../library/codecs.rst:284

msgid ""

"Each codec has to define four interfaces to make it usable as codec in "

"Python: stateless encoder, stateless decoder, stream reader and stream "

"writer. The stream reader and writers typically reuse the stateless "

"encoder/decoder to implement the file protocols. Codec authors also need to "

"define how the codec will handle encoding and decoding errors."

msgstr ""

"每种编解码器必须定义四个接口以便用作 Python 中的编解码器：无状态编码器、无状态解码器、流读取器和流写入器。 "

"流读取器和写入器通常会重用无状态编码器/解码器来实现文件协议。 编解码器作者还需要定义编解码器将如何处理编码和解码错误。"

#: ../../library/codecs.rst:295

msgid "Error Handlers"

msgstr "错误处理方案"

#: ../../library/codecs.rst:297

msgid ""

"To simplify and standardize error handling, codecs may implement different "

"error handling schemes by accepting the *errors* string argument:"

msgstr "为了简化和标准化错误处理，编解码器可以通过接受 *errors* 字符串参数来实现不同的错误处理方案:"

#: ../../library/codecs.rst:317

msgid ""

"The following error handlers can be used with all Python :ref:`standard-"

"encodings` codecs:"

msgstr "以下错误处理器可以用于所有的 Python :ref:`standard-encodings` 编解码器:"

#: ../../library/codecs.rst:323 ../../library/codecs.rst:365

#: ../../library/codecs.rst:384

msgid "Value"

msgstr "值"

#: ../../library/codecs.rst:323 ../../library/codecs.rst:365

#: ../../library/codecs.rst:384 ../../library/codecs.rst:1317

#: ../../library/codecs.rst:1384 ../../library/codecs.rst:1439

msgid "Meaning"

msgstr "含意"

#: ../../library/codecs.rst:325

msgid "``'strict'``"

msgstr "``'strict'``"

#: ../../library/codecs.rst:325

msgid ""

"Raise :exc:`UnicodeError` (or a subclass), this is the default. Implemented "

"in :func:`strict_errors`."

msgstr "引发 :exc:`UnicodeError` (或其子类)，这是默认的方案。 在 :func:`strict_errors` 中实现。"

#: ../../library/codecs.rst:329

msgid "``'ignore'``"

msgstr "``'ignore'``"

#: ../../library/codecs.rst:329

msgid ""

"Ignore the malformed data and continue without further notice. Implemented "

"in :func:`ignore_errors`."

msgstr "忽略错误格式的数据并且不加进一步通知就继续执行。 在 :func:`ignore_errors` 中实现。"

#: ../../library/codecs.rst:333

msgid "``'replace'``"

msgstr "``'replace'``"

#: ../../library/codecs.rst:333

msgid ""

"Replace with a replacement marker. On encoding, use ``?`` (ASCII character)."

" On decoding, use ``�`` (U+FFFD, the official REPLACEMENT CHARACTER). "

"Implemented in :func:`replace_errors`."

msgstr ""

"用一个替代标记来替换。 在编码时，使用 ``?`` (ASCII 字符)。 在解码时，使用 ``�`` (U+FFFD，官方的 REPLACEMENT "

"CHARACTER)。 在 :func:`replace_errors` 中实现。"

#: ../../library/codecs.rst:339

msgid "``'backslashreplace'``"

msgstr "``'backslashreplace'``"

#: ../../library/codecs.rst:339

msgid ""

"Replace with backslashed escape sequences. On encoding, use hexadecimal form"

" of Unicode code point with formats ``\\xhh`` ``\\uxxxx`` ``\\Uxxxxxxxx``. "

"On decoding, use hexadecimal form of byte value with format ``\\xhh``. "

"Implemented in :func:`backslashreplace_errors`."

msgstr ""

"用反斜杠转义序列来替换。 在编码时，使用格式为 ``\\xhh`` ``\\uxxxx`` ``\\Uxxxxxxxx`` 的 Unicode "

"码位十六进制表示形式。 在解码时，使用格式为 ``\\xhh`` 的字节值十六进制表示形式。 在 "

":func:`backslashreplace_errors` 中实现。"

#: ../../library/codecs.rst:347

msgid "``'surrogateescape'``"

msgstr "``'surrogateescape'``"

#: ../../library/codecs.rst:347

msgid ""

"On decoding, replace byte with individual surrogate code ranging from "

"``U+DC80`` to ``U+DCFF``. This code will then be turned back into the same "

"byte when the ``'surrogateescape'`` error handler is used when encoding the "

"data. (See :pep:`383` for more.)"

msgstr ""

"在解码时，将字节替换为 ``U+DC80`` 至 ``U+DCFF`` 范围内的单个代理代码。 当在编码数据时使用 "

"``'surrogateescape'`` 错误处理方案时，此代理将被转换回相同的字节。 （请参阅 :pep:`383` 了解详情。）"

#: ../../library/codecs.rst:361

msgid ""

"The following error handlers are only applicable to encoding (within "

":term:`text encodings <text encoding>`):"

msgstr "下列错误处理器仅在编码时适用（在 :term:`文本编码格式 <text encoding>` 类别以内）:"

#: ../../library/codecs.rst:367

msgid "``'xmlcharrefreplace'``"

msgstr "``'xmlcharrefreplace'``"

#: ../../library/codecs.rst:367

msgid ""

"Replace with XML/HTML numeric character reference, which is a decimal form "

"of Unicode code point with format ``&#num;`` Implemented in "

":func:`xmlcharrefreplace_errors`."

msgstr ""

"用 XML/HTML 数字字符引用来替换，即格式为 ``&#num;`` 的 Unicode 码位十进制表达形式。 在 "

":func:`xmlcharrefreplace_errors` 中实现。"

#: ../../library/codecs.rst:372

msgid "``'namereplace'``"

msgstr "``'namereplace'``"

#: ../../library/codecs.rst:372

msgid ""

"Replace with ``\\N{...}`` escape sequences, what appears in the braces is "

"the Name property from Unicode Character Database. Implemented in "

":func:`namereplace_errors`."

msgstr ""

"用 ``\\N{...}`` 转义序列来替换，出现在花括号中的是来自 Unicode 字符数据库的 Name 属性。 在 "

":func:`namereplace_errors` 中实现。"

#: ../../library/codecs.rst:381

msgid ""

"In addition, the following error handler is specific to the given codecs:"

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

#: ../../library/codecs.rst:384

msgid "Codecs"

msgstr "编解码器"

#: ../../library/codecs.rst:386

msgid "``'surrogatepass'``"

msgstr "``'surrogatepass'``"

#: ../../library/codecs.rst:386

msgid "utf-8, utf-16, utf-32, utf-16-be, utf-16-le, utf-32-be, utf-32-le"

msgstr "utf-8, utf-16, utf-32, utf-16-be, utf-16-le, utf-32-be, utf-32-le"

#: ../../library/codecs.rst:386

msgid ""

"Allow encoding and decoding surrogate code point (``U+D800`` - ``U+DFFF``) "

"as normal code point. Otherwise these codecs treat the presence of surrogate"

" code point in :class:`str` as an error."

msgstr ""

"允许将代理码位 (``U+D800`` - ``U+DFFF``) 作为正常码位来编码和解码。 否则这些编解码器会将 :class:`str` "

"中出现的代理码位视为错误。"

#: ../../library/codecs.rst:393

msgid "The ``'surrogateescape'`` and ``'surrogatepass'`` error handlers."

msgstr "``'surrogateescape'`` 和 ``'surrogatepass'`` 错误处理方案。"

#: ../../library/codecs.rst:396

msgid ""

"The ``'surrogatepass'`` error handler now works with utf-16\\* and utf-32\\*"

" codecs."

msgstr "``'surrogatepass'`` 错误处理器现在可适用于 utf-16\\* 和 utf-32\\* 编解码器。"

#: ../../library/codecs.rst:400

msgid "The ``'namereplace'`` error handler."

msgstr "``'namereplace'`` 错误处理方案。"

#: ../../library/codecs.rst:403

msgid ""

"The ``'backslashreplace'`` error handler now works with decoding and "

"translating."

msgstr "``'backslashreplace'`` 错误处理器现在可适用于解码和转码。"

#: ../../library/codecs.rst:407

msgid ""

"The set of allowed values can be extended by registering a new named error "

"handler:"

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

#: ../../library/codecs.rst:412

msgid ""

"Register the error handling function *error_handler* under the name *name*. "

"The *error_handler* argument will be called during encoding and decoding in "

"case of an error, when *name* is specified as the errors parameter."

msgstr ""

"在名称 *name* 之下注册错误处理函数 *error_handler*。 当 *name* 被指定为错误形参时，*error_handler* "

"参数所指定的对象将在编码和解码期间发生错误的情况下被调用，"

#: ../../library/codecs.rst:416

msgid ""

"For encoding, *error_handler* will be called with a "

":exc:`UnicodeEncodeError` instance, which contains information about the "

"location of the error. The error handler must either raise this or a "

"different exception, or return a tuple with a replacement for the "

"unencodable part of the input and a position where encoding should continue."

" The replacement may be either :class:`str` or :class:`bytes`. If the "

"replacement is bytes, the encoder will simply copy them into the output "

"buffer. If the replacement is a string, the encoder will encode the "

"replacement. Encoding continues on original input at the specified position."

" Negative position values will be treated as being relative to the end of "

"the input string. If the resulting position is out of bound an "

":exc:`IndexError` will be raised."

msgstr ""

"对于编码操作，将会调用 *error_handler* 并传入一个 :exc:`UnicodeEncodeError` "

"实例，其中包含有关错误位置的信息。 "

"错误处理程序必须引发此异常或别的异常，或者也可以返回一个元组，其中包含输入的不可编码部分的替换对象，以及应当继续进行编码的位置。 替换对象可以为 "

":class:`str` 或 :class:`bytes` 类型。 如果替换对象为字节串，编码器将简单地将其复制到输出缓冲区。 "

"如果替换对象为字符串，编码器将对替换对象进行编码。 对原始输入的编码操作会在指定位置继续进行。 负的位置值将被视为相对于输入字符串的末尾。 "

"如果结果位置超出范围则将引发 :exc:`IndexError`。"

#: ../../library/codecs.rst:428

msgid ""

"Decoding and translating works similarly, except :exc:`UnicodeDecodeError` "

"or :exc:`UnicodeTranslateError` will be passed to the handler and that the "

"replacement from the error handler will be put into the output directly."

msgstr ""

"解码和转换的做法很相似，不同之处在于将把 :exc:`UnicodeDecodeError` 或 "

":exc:`UnicodeTranslateError` 传给处理程序，并且来自错误处理程序的替换对象将被直接放入输出。"

#: ../../library/codecs.rst:433

msgid ""

"Previously registered error handlers (including the standard error handlers)"

" can be looked up by name:"

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

#: ../../library/codecs.rst:438

msgid "Return the error handler previously registered under the name *name*."

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

#: ../../library/codecs.rst:440

msgid "Raises a :exc:`LookupError` in case the handler cannot be found."

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

#: ../../library/codecs.rst:442

msgid ""

"The following standard error handlers are also made available as module "

"level functions:"

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

#: ../../library/codecs.rst:447

msgid "Implements the ``'strict'`` error handling."

msgstr "实现了 ``'strict'`` 错误处理。"

#: ../../library/codecs.rst:449

msgid "Each encoding or decoding error raises a :exc:`UnicodeError`."

msgstr "每个编码或解码错误都将引发 :exc:`UnicodeError`。"

#: ../../library/codecs.rst:454

msgid "Implements the ``'ignore'`` error handling."

msgstr "实现了 ``'ignore'`` 错误处理。"

#: ../../library/codecs.rst:456

msgid ""

"Malformed data is ignored; encoding or decoding is continued without further"

" notice."

msgstr "错误格式的数据会被忽略；编码或解码将继续执行而不再通知。"

#: ../../library/codecs.rst:462

msgid "Implements the ``'replace'`` error handling."

msgstr "实现了 ``'replace'`` 错误处理。"

#: ../../library/codecs.rst:464

msgid ""

"Substitutes ``?`` (ASCII character) for encoding errors or ``�`` (U+FFFD, "

"the official REPLACEMENT CHARACTER) for decoding errors."

msgstr ""

"替换 ``?`` (ASCII 字符) 表示编码错误或者 ``�`` (U+FFFD，官方的 REPLACEMENT CHARACTER) "

"表示解码错误。"

#: ../../library/codecs.rst:470

msgid "Implements the ``'backslashreplace'`` error handling."

msgstr "实现了 ``'backslashreplace'`` 错误处理。"

#: ../../library/codecs.rst:472

msgid ""

"Malformed data is replaced by a backslashed escape sequence. On encoding, "

"use the hexadecimal form of Unicode code point with formats ``\\xhh`` "

"``\\uxxxx`` ``\\Uxxxxxxxx``. On decoding, use the hexadecimal form of byte "

"value with format ``\\xhh``."

msgstr ""

"错误格式的数据会用反斜杠转义序列来替换。 在编码时，使用格式为 ``\\xhh`` ``\\uxxxx`` ``\\Uxxxxxxxx`` 的 "

"Unicode 码位十六进制表示形式。 在解码时，使用格式为 ``\\xhh`` 的字节值十六进制表示形式。"

#: ../../library/codecs.rst:477

msgid "Works with decoding and translating."

msgstr "适用于解码和转码。"

#: ../../library/codecs.rst:483

msgid ""

"Implements the ``'xmlcharrefreplace'`` error handling (for encoding within "

":term:`text encoding` only)."

msgstr "实现 ``'xmlcharrefreplace'`` 错误处理（仅限 :term:`text encoding` 范围内的编码操作）。"

#: ../../library/codecs.rst:486

msgid ""

"The unencodable character is replaced by an appropriate XML/HTML numeric "

"character reference, which is a decimal form of Unicode code point with "

"format ``&#num;`` ."

msgstr "不可编码的字符会被替换为适当的 XML/HTML 数值字符引用，即格式为 ``&#num;`` 的十进制形式 Unicode 码位。"

#: ../../library/codecs.rst:493

msgid ""

"Implements the ``'namereplace'`` error handling (for encoding within "

":term:`text encoding` only)."

msgstr "实现 ``'namereplace'`` 错误处理（仅限 :term:`text encoding` 范围内的编码操作）。"

#: ../../library/codecs.rst:496

msgid ""

"The unencodable character is replaced by a ``\\N{...}`` escape sequence. The"

" set of characters that appear in the braces is the Name property from "

"Unicode Character Database. For example, the German lowercase letter ``'ß'``"

" will be converted to byte sequence ``\\N{LATIN SMALL LETTER SHARP S}`` ."

msgstr ""

"不可编码的字符会被替换为 ``\\N{...}`` 转义序列。 出现在花括号内的字符集合是来自于 Unicode 字符数据库的 Name 属性。 "

"例如，德语小写字母 ``'ß'`` 将被转换为字符序列 ``\\N{LATIN SMALL LETTER SHARP S}``。"

#: ../../library/codecs.rst:507

msgid "Stateless Encoding and Decoding"

msgstr "无状态的编码和解码"

#: ../../library/codecs.rst:509

msgid ""

"The base :class:`Codec` class defines these methods which also define the "

"function interfaces of the stateless encoder and decoder:"

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

#: ../../library/codecs.rst:515

msgid ""

"Encodes the object *input* and returns a tuple (output object, length "

"consumed). For instance, :term:`text encoding` converts a string object to a"

" bytes object using a particular character set encoding (e.g., ``cp1252`` or"

" ``iso-8859-1``)."

msgstr ""

"编码 *input* 对象并返回一个元组 (输出对象, 消耗长度)。 例如，:term:`text encoding` 会使用特定的字符集编码格式 "

"(例如 ``cp1252`` 或 ``iso-8859-1``) 将字符串转换为字节串对象。"

#: ../../library/codecs.rst:520 ../../library/codecs.rst:542

msgid ""

"The *errors* argument defines the error handling to apply. It defaults to "

"``'strict'`` handling."

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

#: ../../library/codecs.rst:523

msgid ""

"The method may not store state in the :class:`Codec` instance. Use "

":class:`StreamWriter` for codecs which have to keep state in order to make "

"encoding efficient."

msgstr ""

"此方法不一定会在 :class:`Codec` 实例中保存状态。 可使用必须保存状态的 :class:`StreamWriter` "

"作为编解码器以便高效地进行编码。"

#: ../../library/codecs.rst:527

msgid ""

"The encoder must be able to handle zero length input and return an empty "

"object of the output object type in this situation."

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

#: ../../library/codecs.rst:533

msgid ""

"Decodes the object *input* and returns a tuple (output object, length "

"consumed). For instance, for a :term:`text encoding`, decoding converts a "

"bytes object encoded using a particular character set encoding to a string "

"object."

msgstr ""

"解码 *input* 对象并返回一个元组 (输出对象, 消耗长度)。 例如，:term:`text encoding` "

"的解码操作会使用特定的字符集编码格式将字节串对象转换为字符串对象。"

#: ../../library/codecs.rst:538

msgid ""

"For text encodings and bytes-to-bytes codecs, *input* must be a bytes object"

" or one which provides the read-only buffer interface -- for example, buffer"

" objects and memory mapped files."

msgstr ""

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

#: ../../library/codecs.rst:545

msgid ""

"The method may not store state in the :class:`Codec` instance. Use "

":class:`StreamReader` for codecs which have to keep state in order to make "

"decoding efficient."

msgstr ""

"此方法不一定会在 :class:`Codec` 实例中保存状态。 可使用必须保存状态的 :class:`StreamReader` "

"作为编解码器以便高效地进行解码。"

#: ../../library/codecs.rst:549

msgid ""

"The decoder must be able to handle zero length input and return an empty "

"object of the output object type in this situation."

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

#: ../../library/codecs.rst:554

msgid "Incremental Encoding and Decoding"

msgstr "增量式的编码和解码"

#: ../../library/codecs.rst:556

msgid ""

"The :class:`IncrementalEncoder` and :class:`IncrementalDecoder` classes "

"provide the basic interface for incremental encoding and decoding. "

"Encoding/decoding the input isn't done with one call to the stateless "

"encoder/decoder function, but with multiple calls to the "

":meth:`~IncrementalEncoder.encode`/:meth:`~IncrementalDecoder.decode` method"

" of the incremental encoder/decoder. The incremental encoder/decoder keeps "

"track of the encoding/decoding process during method calls."

msgstr ""

":class:`IncrementalEncoder` 和 :class:`IncrementalDecoder` 类提供了增量式编码和解码的基本接口。"

" 对输入的编码/解码不是通过对无状态编码器/解码器的一次调用，而是通过对增量式编码器/解码器的 "

":meth:`~IncrementalEncoder.encode`/:meth:`~IncrementalDecoder.decode` "

"方法的多次调用。 增量式编码器/解码器会在方法调用期间跟踪编码/解码过程。"

#: ../../library/codecs.rst:564

msgid ""

"The joined output of calls to the "

":meth:`~IncrementalEncoder.encode`/:meth:`~IncrementalDecoder.decode` method"

" is the same as if all the single inputs were joined into one, and this "

"input was encoded/decoded with the stateless encoder/decoder."

msgstr ""

"调用 :meth:`~IncrementalEncoder.encode`/:meth:`~IncrementalDecoder.decode` "

"方法后的全部输出相当于将所有通过无状态编码器/解码器进行编码/解码的单个输入连接在一起所得到的输出。"

#: ../../library/codecs.rst:573

msgid "IncrementalEncoder Objects"

msgstr "IncrementalEncoder 对象"

#: ../../library/codecs.rst:575

msgid ""

"The :class:`IncrementalEncoder` class is used for encoding an input in "

"multiple steps. It defines the following methods which every incremental "

"encoder must define in order to be compatible with the Python codec "

"registry."

msgstr ""

":class:`IncrementalEncoder` 类用来对一个输入进行分步编码。 它定义了以下方法，每个增量式编码器都必须定义这些方法以便与 "

"Python 编解码器注册表相兼容。"

#: ../../library/codecs.rst:582

msgid "Constructor for an :class:`IncrementalEncoder` instance."

msgstr ":class:`IncrementalEncoder` 实例的构造器。"

#: ../../library/codecs.rst:584

msgid ""

"All incremental encoders must provide this constructor interface. They are "

"free to add additional keyword arguments, but only the ones defined here are"

" used by the Python codec registry."

msgstr ""

"所有增量式编码器必须提供此构造器接口。 它们可以自由地添加额外的关键字参数，但只有在这里定义的参数才会被 Python 编解码器注册表所使用。"

#: ../../library/codecs.rst:588

msgid ""

"The :class:`IncrementalEncoder` may implement different error handling "

"schemes by providing the *errors* keyword argument. See :ref:`error-"

"handlers` for possible values."

msgstr ""

":class:`IncrementalEncoder` 可以通过提供 *errors* 关键字参数来实现不同的错误处理方案。 可用的值请参阅 "

":ref:`error-handlers`。"

#: ../../library/codecs.rst:592

msgid ""

"The *errors* argument will be assigned to an attribute of the same name. "

"Assigning to this attribute makes it possible to switch between different "

"error handling strategies during the lifetime of the "

":class:`IncrementalEncoder` object."

msgstr ""

"*errors* 参数将被赋值给一个同名的属性。 通过对此属性赋值就可以在 :class:`IncrementalEncoder` "

"对象的生命期内在不同的错误处理策略之间进行切换。"

#: ../../library/codecs.rst:600

msgid ""

"Encodes *object* (taking the current state of the encoder into account) and "

"returns the resulting encoded object. If this is the last call to "

":meth:`encode` *final* must be true (the default is false)."

msgstr ""

"编码 *object* (会将编码器的当前状态纳入考虑) 并返回已编码的结果对象。 如果这是对 :meth:`encode` 的最终调用则 "

"*final* 必须为真值（默认为假值）。"

#: ../../library/codecs.rst:607

msgid ""

"Reset the encoder to the initial state. The output is discarded: call "

"``.encode(object, final=True)``, passing an empty byte or text string if "

"necessary, to reset the encoder and to get the output."

msgstr ""

"将编码器重置为初始状态。 输出将被丢弃：调用 ``.encode(object, "

"final=True)``，在必要时传入一个空字节串或字符串，重置编码器并得到输出。"

#: ../../library/codecs.rst:614

msgid ""

"Return the current state of the encoder which must be an integer. The "

"implementation should make sure that ``0`` is the most common state. (States"

" that are more complicated than integers can be converted into an integer by"

" marshaling/pickling the state and encoding the bytes of the resulting "

"string into an integer.)"

msgstr ""

"返回编码器的当前状态，该值必须为一个整数。 实现应当确保 ``0`` 是最常见的状态。 "

"（比整数更复杂的状态表示可以通过编组/选择状态并将结果字符串的字节数据编码为整数来转换为一个整数值）。"

#: ../../library/codecs.rst:623

msgid ""

"Set the state of the encoder to *state*. *state* must be an encoder state "

"returned by :meth:`getstate`."

msgstr "将编码器的状态设为 *state*。 *state* 必须为 :meth:`getstate` 所返回的一个编码器状态。"

#: ../../library/codecs.rst:630

msgid "IncrementalDecoder Objects"

msgstr "IncrementalDecoder 对象"

#: ../../library/codecs.rst:632

msgid ""

"The :class:`IncrementalDecoder` class is used for decoding an input in "

"multiple steps. It defines the following methods which every incremental "

"decoder must define in order to be compatible with the Python codec "

"registry."

msgstr ""

":class:`IncrementalDecoder` 类用来对一个输入进行分步解码。 它定义了以下方法，每个增量式解码器都必须定义这些方法以便与 "

"Python 编解码器注册表相兼容。"

#: ../../library/codecs.rst:639

msgid "Constructor for an :class:`IncrementalDecoder` instance."

msgstr ":class:`IncrementalDecoder` 实例的构造器。"

#: ../../library/codecs.rst:641

msgid ""

"All incremental decoders must provide this constructor interface. They are "

"free to add additional keyword arguments, but only the ones defined here are"

" used by the Python codec registry."

msgstr ""

"所有增量式解码器必须提供此构造器接口。 它们可以自由地添加额外的关键字参数，但只有在这里定义的参数才会被 Python 编解码器注册表所使用。"

#: ../../library/codecs.rst:645

msgid ""

"The :class:`IncrementalDecoder` may implement different error handling "

"schemes by providing the *errors* keyword argument. See :ref:`error-"

"handlers` for possible values."

msgstr ""

":class:`IncrementalDecoder` 可以通过提供 *errors* 关键字参数来实现不同的错误处理方案。 可用的值请参阅 "

":ref:`error-handlers`。"

#: ../../library/codecs.rst:649

msgid ""

"The *errors* argument will be assigned to an attribute of the same name. "

"Assigning to this attribute makes it possible to switch between different "

"error handling strategies during the lifetime of the "

":class:`IncrementalDecoder` object."

msgstr ""

"*errors* 参数将被赋值给一个同名的属性。 通过对此属性赋值就可以在 :class:`IncrementalDecoder` "

"对象的生命期内在不同的错误处理策略之间进行切换。"

#: ../../library/codecs.rst:657

msgid ""

"Decodes *object* (taking the current state of the decoder into account) and "

"returns the resulting decoded object. If this is the last call to "

":meth:`decode` *final* must be true (the default is false). If *final* is "

"true the decoder must decode the input completely and must flush all "

"buffers. If this isn't possible (e.g. because of incomplete byte sequences "

"at the end of the input) it must initiate error handling just like in the "

"stateless case (which might raise an exception)."

msgstr ""

"解码 *object* (会将解码器的当前状态纳入考虑) 并返回已解码的结果对象。 如果这是对 :meth:`decode` 的最终调用则 "

"*final* 必须为真值（默认为假值）。 如果 *final* 为真值则解码器必须对输入进行完全解码并且必须 刷新所有缓冲区。 "

"如果这无法做到（例如由于在输入结束时字节串序列不完整）则它必须像在无状态的情况下那样初始化错误处理（这可能引发一个异常）。"

#: ../../library/codecs.rst:668

msgid "Reset the decoder to the initial state."

msgstr "将解码器重置为初始状态。"

#: ../../library/codecs.rst:673

msgid ""

"Return the current state of the decoder. This must be a tuple with two "

"items, the first must be the buffer containing the still undecoded input. "

"The second must be an integer and can be additional state info. (The "

"implementation should make sure that ``0`` is the most common additional "

"state info.) If this additional state info is ``0`` it must be possible to "

"set the decoder to the state which has no input buffered and ``0`` as the "

"additional state info, so that feeding the previously buffered input to the "

"decoder returns it to the previous state without producing any output. "

"(Additional state info that is more complicated than integers can be "

"converted into an integer by marshaling/pickling the info and encoding the "

"bytes of the resulting string into an integer.)"

msgstr ""

"返回解码器的当前状态。 这必须为一个二元组，第一项必须是包含尚未解码的输入的缓冲区。 第二项必须为一个整数，可以表示附加状态信息。 （实现应当确保 "

"``0`` 是最常见的附加状态信息。） 如果此附加状态信息为 ``0`` 则必须可以将解码器设为没有已缓冲输入并且以 ``0`` "

"作为附加状态信息，以便将先前已缓冲的输入馈送到解码器使其返回到先前的状态而不产生任何输出。 "

"（比整数更复杂的附加状态信息可以通过编组/选择状态信息并将结果字符串的字节数据编码为整数来转换为一个整数值。）"

#: ../../library/codecs.rst:688

msgid ""

"Set the state of the decoder to *state*. *state* must be a decoder state "

"returned by :meth:`getstate`."

msgstr "将解码器的状态设为 *state*。 *state* 必须为 :meth:`getstate` 所返回的一个解码器状态。"

#: ../../library/codecs.rst:693

msgid "Stream Encoding and Decoding"

msgstr "流式的编码和解码"

#: ../../library/codecs.rst:696

msgid ""

"The :class:`StreamWriter` and :class:`StreamReader` classes provide generic "

"working interfaces which can be used to implement new encoding submodules "

"very easily. See :mod:`encodings.utf_8` for an example of how this is done."

msgstr ""

":class:`StreamWriter` 和 :class:`StreamReader` "

"类提供了一些泛用工作接口，可被用来非常方便地实现新的编码格式子模块。 请参阅 :mod:`encodings.utf_8` 中的示例了解如何做到这一点。"

#: ../../library/codecs.rst:704

msgid "StreamWriter Objects"

msgstr "StreamWriter 对象"

#: ../../library/codecs.rst:706

msgid ""

"The :class:`StreamWriter` class is a subclass of :class:`Codec` and defines "

"the following methods which every stream writer must define in order to be "

"compatible with the Python codec registry."

msgstr ""