Unicode对象和编解码器
*********************


Unicode对象
===========

自从python3.3中实现了 **PEP 393** 以来，Unicode对象在内部使用各种表示
形式，以便在保持内存效率的同时处理完整范围的Unicode字符。对于所有代码
点都低于128、256或65536的字符串，有一些特殊情况；否则，代码点必须低于
1114112（这是完整的Unicode范围）。

"Py_UNICODE*" 和 UTF-8 表示形式将按需创建并缓存至 Unicode 对象。
"Py_UNICODE*" 表示形式是已弃用且低效率的。

由于旧API和新API之间的转换，Unicode对象内部可以处于两种状态，这取决于
它们的创建方式：

* “规范”Unicode对象是由非弃用的Unicode API创建的所有对象。它们使用实现
  所允许的最有效的表达方式。

* "legacy" Unicode objects have been created through one of the
  deprecated APIs (typically "PyUnicode_FromUnicode()") and only bear
  the "Py_UNICODE*" representation; you will have to call
  "PyUnicode_READY()" on them before calling any other API.

注解:

  The "legacy" Unicode object will be removed in Python 3.12 with
  deprecated APIs. All Unicode objects will be "canonical" since then.
  See **PEP 623** for more information.


Unicode类型
-----------

以下是用于Python中Unicode实现的基本Unicode对象类型：

type Py_UCS4
type Py_UCS2
type Py_UCS1
    * Part of the Stable ABI.*

   这些类型是无符号整数类型的类型定义，其宽度足以分别包含 32 位、16 位
   和 8 位字符。 当需要处理单个 Unicode 字符时，请使用 "Py_UCS4"。

   3.3 新版功能.

type Py_UNICODE

   This is a typedef of "wchar_t", which is a 16-bit type or 32-bit
   type depending on the platform.

   在 3.3 版更改: 在以前的版本中，这是16位类型还是32位类型，这取决于您
   在构建时选择的是“窄”还是“宽”Unicode版本的Python。

type PyASCIIObject
type PyCompactUnicodeObject
type PyUnicodeObject

   这些关于 "PyObject" 的子类型表示了一个 Python Unicode 对象。 在几乎
   所有情形下，它们不应该被直接使用，因为所有处理 Unicode 对象的 API
   函数都接受并返回 "PyObject" 类型的指针。

   3.3 新版功能.

PyTypeObject PyUnicode_Type
    * Part of the Stable ABI.*

   这个 "PyTypeObject" 实例代表 Python Unicode 类型。 它作为 "str" 公
   开给 Python 代码。

The following APIs are really C macros and can be used to do fast
checks and to access internal read-only data of Unicode objects:

int PyUnicode_Check(PyObject *o)

   如果对象*o*是Unicode对象或Unicode子类型的实例，则返回“真"。此函数始
   终成功。

int PyUnicode_CheckExact(PyObject *o)

   如果对象*o*是Unicode对象，但不是子类型的实例，则返回“真”。此函数始
   终成功。

int PyUnicode_READY(PyObject *o)

   确保字符串对象*o*处于“规范的”表达方式。在使用下面描述的任何访问宏之
   前，这是必需的。

   Returns "0" on success and "-1" with an exception set on failure,
   which in particular happens if memory allocation fails.

   3.3 新版功能.

   从 3.10 版起不建议使用，将在 3.12 版中移除: This API will be
   removed with "PyUnicode_FromUnicode()".

Py_ssize_t PyUnicode_GET_LENGTH(PyObject *o)

   返回Unicode字符串的长度（以代码点为单位）*o*必须是“规范”表达方式中
   的Unicode对象（未选中）。

   3.3 新版功能.

Py_UCS1 *PyUnicode_1BYTE_DATA(PyObject *o)
Py_UCS2 *PyUnicode_2BYTE_DATA(PyObject *o)
Py_UCS4 *PyUnicode_4BYTE_DATA(PyObject *o)

   Return a pointer to the canonical representation cast to UCS1, UCS2
   or UCS4 integer types for direct character access.  No checks are
   performed if the canonical representation has the correct character
   size; use "PyUnicode_KIND()" to select the right macro.  Make sure
   "PyUnicode_READY()" has been called before accessing this.

   3.3 新版功能.

PyUnicode_WCHAR_KIND
PyUnicode_1BYTE_KIND
PyUnicode_2BYTE_KIND
PyUnicode_4BYTE_KIND

   返回 "PyUnicode_KIND()" 宏的值。

   3.3 新版功能.

   从 3.10 版起不建议使用，将在 3.12 版中移除: "PyUnicode_WCHAR_KIND"
   已被弃用。

unsigned int PyUnicode_KIND(PyObject *o)

   返回一个PyUnicode类常量（见上文），指示此Unicode对象用于存储其数据
   的每个字符的字节数*o*必须是“规范”表达方式中的Unicode对象（未选中）
   。

   3.3 新版功能.

void *PyUnicode_DATA(PyObject *o)

   返回指向原始Unicode缓冲区的空指针*o*必须是“规范”表达方式中的Unicode
   对象（未选中）。

   3.3 新版功能.

void PyUnicode_WRITE(int kind, void *data, Py_ssize_t index, Py_UCS4 value)

   Write into a canonical representation *data* (as obtained with
   "PyUnicode_DATA()").  This macro does not do any sanity checks and
   is intended for usage in loops.  The caller should cache the *kind*
   value and *data* pointer as obtained from other macro calls.
   *index* is the index in the string (starts at 0) and *value* is the
   new code point value which should be written to that location.

   3.3 新版功能.

Py_UCS4 PyUnicode_READ(int kind, void *data, Py_ssize_t index)

   从规范表示的 *data* (如同用 "PyUnicode_DATA()" 获取) 中读取一个码位
   。 不会执行检查或就绪调用。

   3.3 新版功能.

Py_UCS4 PyUnicode_READ_CHAR(PyObject *o, Py_ssize_t index)

   从 Unicode 对象 *o* 读取一个字符，必须使用“规范”表示形式。 如果你执
   行行多次连续读取则此函数的效率将低于 "PyUnicode_READ()"。

   3.3 新版功能.

PyUnicode_MAX_CHAR_VALUE(o)

   返回适合于基于*o*创建另一个字符串的最大代码点，该字符串必须在“规范”
   表达方式中。这始终是一种近似，但比在字符串上迭代更有效。

   3.3 新版功能.

Py_ssize_t PyUnicode_GET_SIZE(PyObject *o)

   Return the size of the deprecated "Py_UNICODE" representation, in
   code units (this includes surrogate pairs as 2 units).  *o* has to
   be a Unicode object (not checked).

   从 3.3 版起不建议使用，将在 3.12 版中移除: 旧式 Unicode API 的一部
   分，请迁移到使用 "PyUnicode_GET_LENGTH()"。

Py_ssize_t PyUnicode_GET_DATA_SIZE(PyObject *o)

   Return the size of the deprecated "Py_UNICODE" representation in
   bytes.  *o* has to be a Unicode object (not checked).

   从 3.3 版起不建议使用，将在 3.12 版中移除: 旧式 Unicode API 的一部
   分，请迁移到使用 "PyUnicode_GET_LENGTH()"。

Py_UNICODE *PyUnicode_AS_UNICODE(PyObject *o)
const char *PyUnicode_AS_DATA(PyObject *o)

   Return a pointer to a "Py_UNICODE" representation of the object.
   The returned buffer is always terminated with an extra null code
   point.  It may also contain embedded null code points, which would
   cause the string to be truncated when used in most C functions.
   The "AS_DATA" form casts the pointer to "const char*".  The *o*
   argument has to be a Unicode object (not checked).

   在 3.3 版更改: This macro is now inefficient -- because in many
   cases the "Py_UNICODE" representation does not exist and needs to
   be created -- and can fail (return "NULL" with an exception set).
   Try to port the code to use the new "PyUnicode_nBYTE_DATA()" macros
   or use "PyUnicode_WRITE()" or "PyUnicode_READ()".

   从 3.3 版起不建议使用，将在 3.12 版中移除: 旧式 Unicode API 的一部
   分，请迁移到使用 "PyUnicode_nBYTE_DATA()" 宏族。

int PyUnicode_IsIdentifier(PyObject *o)
    * Part of the Stable ABI.*

   如果字符串按照语言定义是合法的标识符则返回 "1"，参见 标识符和关键字
   小节。 否则返回 "0"。

   在 3.9 版更改: 如果字符串尚未就绪则此函数不会再调用
   "Py_FatalError()"。


Unicode字符属性
---------------

Unicode提供了许多不同的字符特性。最常需要的宏可以通过这些宏获得，这些
宏根据Python配置映射到C函数。

int Py_UNICODE_ISSPACE(Py_UCS4 ch)

   根据 *ch* 是否为空白字符返回 "1" 或 "0"。

int Py_UNICODE_ISLOWER(Py_UCS4 ch)

   根据 *ch* 是否为小写字符返回 "1" 或 "0"。

int Py_UNICODE_ISUPPER(Py_UCS4 ch)

   根据 *ch* 是否为大写字符返回 "1" 或 "0"

int Py_UNICODE_ISTITLE(Py_UCS4 ch)

   根据 *ch* 是否为标题化的大小写返回 "1" 或 "0"。

int Py_UNICODE_ISLINEBREAK(Py_UCS4 ch)

   根据 *ch* 是否为换行类字符返回 "1" 或 "0"。

int Py_UNICODE_ISDECIMAL(Py_UCS4 ch)

   根据 *ch* 是否为十进制数字符返回 "1" 或 "0"。

int Py_UNICODE_ISDIGIT(Py_UCS4 ch)

   根据 *ch* 是否为数码类字符返回 "1" 或 "0"。

int Py_UNICODE_ISNUMERIC(Py_UCS4 ch)

   根据 *ch* 是否为数值类字符返回 "1" 或 "0"。

int Py_UNICODE_ISALPHA(Py_UCS4 ch)

   根据 *ch* 是否为字母类字符返回 "1" 或 "0"。

int Py_UNICODE_ISALNUM(Py_UCS4 ch)

   根据 *ch* 是否为字母数字类字符返回 "1" 或 "0"。

int Py_UNICODE_ISPRINTABLE(Py_UCS4 ch)

   根据 *ch* 是否为可打印字符返回 "1" 或``0``。 不可打印字符是指在
   Unicode 字符数据库中被定义为 "Other" 或 "Separator" 的字符，例外情
   况是 ASCII 空格 (0x20) 被视为可打印字符。 (请注意在此语境下可打印字
   符是指当在字符串上发起调用 "repr()" 时不应被转义的字符。 它们字符串
   写入 "sys.stdout" 或 "sys.stderr" 时所需的处理无关)。

这些 API 可用于快速直接的字符转换：

Py_UCS4 Py_UNICODE_TOLOWER(Py_UCS4 ch)

   返回转换为小写形式的字符 *ch*。

   3.3 版后已移除: 此函数使用简单的大小写映射。

Py_UCS4 Py_UNICODE_TOUPPER(Py_UCS4 ch)

   返回转换为大写形式的字符 *ch*。

   3.3 版后已移除: 此函数使用简单的大小写映射。

Py_UCS4 Py_UNICODE_TOTITLE(Py_UCS4 ch)

   返回转换为标题大小写形式的字符 *ch*。

   3.3 版后已移除: 此函数使用简单的大小写映射。

int Py_UNICODE_TODECIMAL(Py_UCS4 ch)

   Return the character *ch* converted to a decimal positive integer.
   Return "-1" if this is not possible.  This macro does not raise
   exceptions.

int Py_UNICODE_TODIGIT(Py_UCS4 ch)

   Return the character *ch* converted to a single digit integer.
   Return "-1" if this is not possible.  This macro does not raise
   exceptions.

double Py_UNICODE_TONUMERIC(Py_UCS4 ch)

   Return the character *ch* converted to a double. Return "-1.0" if
   this is not possible.  This macro does not raise exceptions.

这些 API 可被用来操作代理项：

Py_UNICODE_IS_SURROGATE(ch)

   检测 *ch* 是否为代理项 ("0xD800 <= ch <= 0xDFFF")。

Py_UNICODE_IS_HIGH_SURROGATE(ch)

   检测 *ch* 是否为高代理项 ("0xD800 <= ch <= 0xDBFF")。

Py_UNICODE_IS_LOW_SURROGATE(ch)

   检测 *ch* 是否为低代理项 ("0xDC00 <= ch <= 0xDFFF")。

Py_UNICODE_JOIN_SURROGATES(high, low)

   Join two surrogate characters and return a single Py_UCS4 value.
   *high* and *low* are respectively the leading and trailing
   surrogates in a surrogate pair.


创建和访问 Unicode 字符串
-------------------------

要创建 Unicode 对象和访问其基本序列属性，请使用这些 API：

PyObject *PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar)
    *返回值：新的引用。*

   创建一个新的 Unicode 对象。 *maxchar* 应为可放入字符串的实际最大码
   位。 作为一个近似值，它可被向上舍入到序列 127, 255, 65535, 1114111
   中最接近的值。

   这是分配新的 Unicode 对象的推荐方式。 使用此函数创建的对象不可改变
   大小。

   3.3 新版功能.

PyObject *PyUnicode_FromKindAndData(int kind, const void *buffer, Py_ssize_t size)
    *返回值：新的引用。*

   以给定的 *kind* 创建一个新的 Unicode 对象（可能的值为
   "PyUnicode_1BYTE_KIND" 等，即 "PyUnicode_KIND()" 所返回的值）。
   *buffer* 必须指向由此分类所给出的，以每字符 1, 2 或 4 字节单位的
   *size* 大小的数组。

   3.3 新版功能.

PyObject *PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size)
    *返回值：新的引用。** Part of the Stable ABI.*

   Create a Unicode object from the char buffer *u*.  The bytes will
   be interpreted as being UTF-8 encoded.  The buffer is copied into
   the new object. If the buffer is not "NULL", the return value might
   be a shared object, i.e. modification of the data is not allowed.

   If *u* is "NULL", this function behaves like
   "PyUnicode_FromUnicode()" with the buffer set to "NULL".  This
   usage is deprecated in favor of "PyUnicode_New()", and will be
   removed in Python 3.12.

PyObject *PyUnicode_FromString(const char *u)
    *返回值：新的引用。** Part of the Stable ABI.*

   根据 UTF-8 编码的以空值结束的字符缓冲区 *u* 创建一个 Unicode 对象。

PyObject *PyUnicode_FromFormat(const char *format, ...)
    *返回值：新的引用。** Part of the Stable ABI.*

   Take a C "printf()"-style *format* string and a variable number of
   arguments, calculate the size of the resulting Python Unicode
   string and return a string with the values formatted into it.  The
   variable arguments must be C types and must correspond exactly to
   the format characters in the *format* ASCII-encoded string. The
   following format characters are allowed:

   +---------------------+-----------------------+------------------------------------+
   | 格式字符            | 类型                  | 注释                               |
   |=====================|=======================|====================================|
   | "%%"                | *不适用*              | 文字%字符。                        |
   +---------------------+-----------------------+------------------------------------+
   | "%c"                | int                   | 单个字符，表示为C 语言的整型。     |
   +---------------------+-----------------------+------------------------------------+
   | "%d"                | int                   | 相当于 "printf("%d")". [1]         |
   +---------------------+-----------------------+------------------------------------+
   | "%u"                | unsigned int          | 相当于 "printf("%u")". [1]         |
   +---------------------+-----------------------+------------------------------------+
   | "%ld"               | 长整型                | 相当于 "printf("%ld")". [1]        |
   +---------------------+-----------------------+------------------------------------+
   | "%li"               | 长整型                | 相当于 "printf("%li")". [1]        |
   +---------------------+-----------------------+------------------------------------+
   | "%lu"               | unsigned long         | 相当于 "printf("%lu")". [1]        |
   +---------------------+-----------------------+------------------------------------+
   | "%lld"              | long long             | 相当于 "printf("%lld")". [1]       |
   +---------------------+-----------------------+------------------------------------+
   | "%lli"              | long long             | 相当于 "printf("%lli")". [1]       |
   +---------------------+-----------------------+------------------------------------+
   | "%llu"              | unsigned long long    | 相当于 "printf("%llu")". [1]       |
   +---------------------+-----------------------+------------------------------------+
   | "%zd"               | "Py_ssize_t"          | 相当于 "printf("%zd")". [1]        |
   +---------------------+-----------------------+------------------------------------+
   | "%zi"               | "Py_ssize_t"          | 相当于 "printf("%zi")". [1]        |
   +---------------------+-----------------------+------------------------------------+
   | "%zu"               | size_t                | 相当于 "printf("%zu")". [1]        |
   +---------------------+-----------------------+------------------------------------+
   | "%i"                | int                   | 相当于 "printf("%i")". [1]         |
   +---------------------+-----------------------+------------------------------------+
   | "%x"                | int                   | 相当于 "printf("%x")". [1]         |
   +---------------------+-----------------------+------------------------------------+
   | "%s"                | const char*           | 以 null 为终止符的 C 字符数组。    |
   +---------------------+-----------------------+------------------------------------+
   | "%p"                | const void*           | 一个 C 指针的十六进制表示形式。 基 |
   |                     |                       | 本等价于 "printf("%p")" 但它会确   |
   |                     |                       | 保以字面值 "0x" 开头，不论系统平台 |
   |                     |                       | 上 "printf" 的输出是什么。         |
   +---------------------+-----------------------+------------------------------------+
   | "%A"                | PyObject*             | "ascii()" 调用的结果。             |
   +---------------------+-----------------------+------------------------------------+
   | "%U"                | PyObject*             | 一个 Unicode 对象。                |
   +---------------------+-----------------------+------------------------------------+
   | "%V"                | PyObject*, const      | 一个 Unicode 对象 (可以为 "NULL")  |
   |                     | char*                 | 和一个以空值结束的 C 字符数组作为  |
   |                     |                       | 第二个形参（如果第一个形参为       |
   |                     |                       | "NULL"，第二个形参将被使用）。     |
   +---------------------+-----------------------+------------------------------------+
   | "%S"                | PyObject*             | 调用 "PyObject_Str()" 的结果。     |
   +---------------------+-----------------------+------------------------------------+
   | "%R"                | PyObject*             | 调用 "PyObject_Repr()" 的结果。    |
   +---------------------+-----------------------+------------------------------------+

   An unrecognized format character causes all the rest of the format
   string to be copied as-is to the result string, and any extra
   arguments discarded.

   注解:

     The width formatter unit is number of characters rather than
     bytes. The precision formatter unit is number of bytes for ""%s""
     and ""%V"" (if the "PyObject*" argument is "NULL"), and a number
     of characters for ""%A"", ""%U"", ""%S"", ""%R"" and ""%V"" (if
     the "PyObject*" argument is not "NULL").

   [1] For integer specifiers (d, u, ld, li, lu, lld, lli, llu, zd,
       zi, zu, i, x): the 0-conversion flag has effect even when a
       precision is given.

   在 3.2 版更改: 增加了对 ""%lld"" 和 ""%llu"" 的支持。

   在 3.3 版更改: 增加了对 ""%li"", ""%lli"" 和 ""%zi"" 的支持。

   在 3.4 版更改: 增加了对 ""%s"", ""%A"", ""%U"", ""%V"", ""%S"",
   ""%R"" 的宽度和精度格式符支持。

PyObject *PyUnicode_FromFormatV(const char *format, va_list vargs)
    *返回值：新的引用。** Part of the Stable ABI.*

   等同于 "PyUnicode_FromFormat()" 但它将接受恰好两个参数。

PyObject *PyUnicode_FromEncodedObject(PyObject *obj, const char *encoding, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   将一个已编码的对象 *obj* 解码为 Unicode 对象。

   "bytes", "bytearray" 和其他 *字节类对象* 将按照给定的 *encoding* 来
   解码并使用由 *errors* 定义的错误处理方式。 两者均可为 "NULL" 即让接
   口使用默认值（请参阅 内置编解码器 了解详情）。

   所有其他对象，包括 Unicode 对象，都将导致设置 "TypeError"。

   如有错误该 API 将返回 "NULL"。 调用方要负责递减指向所返回对象的引用
   。

Py_ssize_t PyUnicode_GetLength(PyObject *unicode)
    * Part of the Stable ABI since version 3.7.*

   返回 Unicode 对象码位的长度。

   3.3 新版功能.

Py_ssize_t PyUnicode_CopyCharacters(PyObject *to, Py_ssize_t to_start, PyObject *from, Py_ssize_t from_start, Py_ssize_t how_many)

   Copy characters from one Unicode object into another.  This
   function performs character conversion when necessary and falls
   back to "memcpy()" if possible.  Returns "-1" and sets an exception
   on error, otherwise returns the number of copied characters.

   3.3 新版功能.

Py_ssize_t PyUnicode_Fill(PyObject *unicode, Py_ssize_t start, Py_ssize_t length, Py_UCS4 fill_char)

   使用一个字符填充字符串：将 *fill_char* 写入
   "unicode[start:start+length]"。

   如果 *fill_char* 值大于字符串最大字符值，或者如果字符串有 1 以上的
   引用将执行失败。

   返回写入的字符数量，或者在出错时返回 "-1" 并引发一个异常。

   3.3 新版功能.

int PyUnicode_WriteChar(PyObject *unicode, Py_ssize_t index, Py_UCS4 character)
    * Part of the Stable ABI since version 3.7.*

   将一个字符写入到字符串。 字符串必须通过 "PyUnicode_New()" 创建。 由
   于 Unicode 字符串应当是不可变的，因此该字符串不能被共享，或是被哈希
   。

   该函数将检查 *unicode* 是否为 Unicode 对象，索引是否未越界，并且对
   象是否可被安全地修改（即其引用计数为一）。

   3.3 新版功能.

Py_UCS4 PyUnicode_ReadChar(PyObject *unicode, Py_ssize_t index)
    * Part of the Stable ABI since version 3.7.*

   Read a character from a string.  This function checks that
   *unicode* is a Unicode object and the index is not out of bounds,
   in contrast to the macro version "PyUnicode_READ_CHAR()".

   3.3 新版功能.

PyObject *PyUnicode_Substring(PyObject *str, Py_ssize_t start, Py_ssize_t end)
    *返回值：新的引用。** Part of the Stable ABI since version 3.7.*

   返回 *str* 的一个子串，从字符索引 *start* (包括) 到字符索引 *end* (
   不包括)。 不支持负索引号。

   3.3 新版功能.

Py_UCS4 *PyUnicode_AsUCS4(PyObject *u, Py_UCS4 *buffer, Py_ssize_t buflen, int copy_null)
    * Part of the Stable ABI since version 3.7.*

   将字符串 *u* 拷贝到一个 UCS4 缓冲区，包括一个空字符，如果设置了
   *copy_null* 的话。 出错时返回 "NULL" 并设置一个异常（特别是当
   *buflen* 小于 *u* 的长度时，"SystemError" 将被设置）。 成功时返回
   *buffer*。

   3.3 新版功能.

Py_UCS4 *PyUnicode_AsUCS4Copy(PyObject *u)
    * Part of the Stable ABI since version 3.7.*

   将字符串 *u* 拷贝到使用 "PyMem_Malloc()" 分配的新 UCS4 缓冲区。 如
   果执行失败，将返回 "NULL" 并设置 "MemoryError"。 返回的缓冲区将总是
   会添加一个额外的空码位。

   3.3 新版功能.


已弃用的 Py_UNICODE API
-----------------------

从 3.3 版起不建议使用，将在 3.12 版中移除.

These API functions are deprecated with the implementation of **PEP
393**. Extension modules can continue using them, as they will not be
removed in Python 3.x, but need to be aware that their use can now
cause performance and memory hits.

PyObject *PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size)
    *返回值：新的引用。*

   Create a Unicode object from the Py_UNICODE buffer *u* of the given
   size. *u* may be "NULL" which causes the contents to be undefined.
   It is the user's responsibility to fill in the needed data.  The
   buffer is copied into the new object.

   If the buffer is not "NULL", the return value might be a shared
   object. Therefore, modification of the resulting Unicode object is
   only allowed when *u* is "NULL".

   If the buffer is "NULL", "PyUnicode_READY()" must be called once
   the string content has been filled before using any of the access
   macros such as "PyUnicode_KIND()".

   从 3.3 版起不建议使用，将在 3.12 版中移除: Part of the old-style
   Unicode API, please migrate to using "PyUnicode_FromKindAndData()",
   "PyUnicode_FromWideChar()", or "PyUnicode_New()".

Py_UNICODE *PyUnicode_AsUnicode(PyObject *unicode)

   Return a read-only pointer to the Unicode object's internal
   "Py_UNICODE" buffer, or "NULL" on error. This will create the
   "Py_UNICODE*" representation of the object if it is not yet
   available. The buffer is always terminated with an extra null code
   point. Note that the resulting "Py_UNICODE" string may also contain
   embedded null code points, which would cause the string to be
   truncated when used in most C functions.

   从 3.3 版起不建议使用，将在 3.12 版中移除: Part of the old-style
   Unicode API, please migrate to using "PyUnicode_AsUCS4()",
   "PyUnicode_AsWideChar()", "PyUnicode_ReadChar()" or similar new
   APIs.

PyObject *PyUnicode_TransformDecimalToASCII(Py_UNICODE *s, Py_ssize_t size)
    *返回值：新的引用。*

   Create a Unicode object by replacing all decimal digits in
   "Py_UNICODE" buffer of the given *size* by ASCII digits 0--9
   according to their decimal value.  Return "NULL" if an exception
   occurs.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using "Py_UNICODE_TODECIMAL()".

Py_UNICODE *PyUnicode_AsUnicodeAndSize(PyObject *unicode, Py_ssize_t *size)

   Like "PyUnicode_AsUnicode()", but also saves the "Py_UNICODE()"
   array length (excluding the extra null terminator) in *size*. Note
   that the resulting "Py_UNICODE*" string may contain embedded null
   code points, which would cause the string to be truncated when used
   in most C functions.

   3.3 新版功能.

   从 3.3 版起不建议使用，将在 3.12 版中移除: Part of the old-style
   Unicode API, please migrate to using "PyUnicode_AsUCS4()",
   "PyUnicode_AsWideChar()", "PyUnicode_ReadChar()" or similar new
   APIs.

Py_ssize_t PyUnicode_GetSize(PyObject *unicode)
    * Part of the Stable ABI.*

   Return the size of the deprecated "Py_UNICODE" representation, in
   code units (this includes surrogate pairs as 2 units).

   从 3.3 版起不建议使用，将在 3.12 版中移除: 旧式 Unicode API 的一部
   分，请迁移到使用 "PyUnicode_GET_LENGTH()"。

PyObject *PyUnicode_FromObject(PyObject *obj)
    *返回值：新的引用。** Part of the Stable ABI.*

   Copy an instance of a Unicode subtype to a new true Unicode object
   if necessary. If *obj* is already a true Unicode object (not a
   subtype), return the reference with incremented refcount.

   非 Unicode 或其子类型的对象将导致 "TypeError"。


语言区域编码格式
----------------

当前语言区域编码格式可被用来解码来自操作系统的文本。

PyObject *PyUnicode_DecodeLocaleAndSize(const char *str, Py_ssize_t len, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI since version 3.7.*

   解码字符串在 Android 和 VxWorks 上使用 UTF-8，在其他平台上则使用当
   前语言区域编码格式。 支持的错误处理器有 ""strict"" 和
   ""surrogateescape"" (**PEP 383**)。 如果 *errors* 为 "NULL" 则解码
   器将使用 ""strict"" 错误处理器。 *str* 必须以一个空字符结束但不可包
   含嵌入的空字符。

   Use "PyUnicode_DecodeFSDefaultAndSize()" to decode a string from
   "Py_FileSystemDefaultEncoding" (the locale encoding read at Python
   startup).

   此函数将忽略 Python UTF-8 模式。

   参见: The "Py_DecodeLocale()" 函数。

   3.3 新版功能.

   在 3.7 版更改: 此函数现在也会为 "surrogateescape" 错误处理器使用当
   前语言区域编码格式，但在 Android 上例外。 在之前版本中，
   "Py_DecodeLocale()" 将被用于 "surrogateescape"，而当前语言区域编码
   格式将被用于 "strict"。

PyObject *PyUnicode_DecodeLocale(const char *str, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI since version 3.7.*

   Similar to "PyUnicode_DecodeLocaleAndSize()", but compute the
   string length using "strlen()".

   3.3 新版功能.

PyObject *PyUnicode_EncodeLocale(PyObject *unicode, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI since version 3.7.*

   编码 Unicode 对象在 Android 和 VxWorks 上使用 UTF-8，在其他平台上使
   用当前语言区域编码格式。 支持的错误处理器有 ""strict"" 和
   ""surrogateescape"" (**PEP 383**)。 如果 *errors* 为 "NULL" 则编码
   器将使用 ""strict"" 错误处理器。 返回一个 "bytes" 对象。 *unicode*
   不可包含嵌入的空字符。

   Use "PyUnicode_EncodeFSDefault()" to encode a string to
   "Py_FileSystemDefaultEncoding" (the locale encoding read at Python
   startup).

   此函数将忽略 Python UTF-8 模式。

   参见: "Py_EncodeLocale()" 函数。

   3.3 新版功能.

   在 3.7 版更改: 此函数现在也会为 "surrogateescape" 错误处理器使用当
   前语言区域编码格式，但在 Android 上例外。 在之前版本中，
   "Py_EncodeLocale()" 将被用于 "surrogateescape"，而当前语言区域编码
   格式将被用于 "strict"。


文件系统编码格式
----------------

To encode and decode file names and other environment strings,
"Py_FileSystemDefaultEncoding" should be used as the encoding, and
"Py_FileSystemDefaultEncodeErrors" should be used as the error handler
(**PEP 383** and **PEP 529**). To encode file names to "bytes" during
argument parsing, the ""O&"" converter should be used, passing
"PyUnicode_FSConverter()" as the conversion function:

int PyUnicode_FSConverter(PyObject *obj, void *result)
    * Part of the Stable ABI.*

   ParseTuple 转换器：编码 "str" 对象 -- 直接获取或是通过
   "os.PathLike" 接口 -- 使用 "PyUnicode_EncodeFSDefault()" 转为
   "bytes"；"bytes" 对象将被原样输出。 *result* 必须为
   "PyBytesObject*" 并将在其不再被使用时释放。

   3.1 新版功能.

   在 3.6 版更改: 接受一个 *path-like object*。

要在参数解析期间将文件名解码为 "str"，应当使用 ""O&"" 转换器，传入
"PyUnicode_FSDecoder()" 作为转换函数：

int PyUnicode_FSDecoder(PyObject *obj, void *result)
    * Part of the Stable ABI.*

   ParseTuple 转换器：解码 "bytes" 对象 -- 直接获取或是通过
   "os.PathLike" 接口间接获取 -- 使用
   "PyUnicode_DecodeFSDefaultAndSize()" 转为 "str"；"str" 对象将被原样
   输出。 *result* 必须为 "PyUnicodeObject*" 并将在其不再被使用时释放
   。

   3.2 新版功能.

   在 3.6 版更改: 接受一个 *path-like object*。

PyObject *PyUnicode_DecodeFSDefaultAndSize(const char *s, Py_ssize_t size)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用 *filesystem encoding and error handler* 解码字符串。

   If "Py_FileSystemDefaultEncoding" is not set, fall back to the
   locale encoding.

   "Py_FileSystemDefaultEncoding" is initialized at startup from the
   locale encoding and cannot be modified later. If you need to decode
   a string from the current locale encoding, use
   "PyUnicode_DecodeLocaleAndSize()".

   参见: The "Py_DecodeLocale()" 函数。

   在 3.6 版更改: Use "Py_FileSystemDefaultEncodeErrors" error
   handler.

PyObject *PyUnicode_DecodeFSDefault(const char *s)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用 *filesystem encoding and error handler* 解码以空值结尾的字符串
   。

   If "Py_FileSystemDefaultEncoding" is not set, fall back to the
   locale encoding.

   Use "PyUnicode_DecodeFSDefaultAndSize()" if you know the string
   length.

   在 3.6 版更改: Use "Py_FileSystemDefaultEncodeErrors" error
   handler.

PyObject *PyUnicode_EncodeFSDefault(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI.*

   Encode a Unicode object to "Py_FileSystemDefaultEncoding" with the
   "Py_FileSystemDefaultEncodeErrors" error handler, and return
   "bytes". Note that the resulting "bytes" object may contain null
   bytes.

   If "Py_FileSystemDefaultEncoding" is not set, fall back to the
   locale encoding.

   "Py_FileSystemDefaultEncoding" is initialized at startup from the
   locale encoding and cannot be modified later. If you need to encode
   a string to the current locale encoding, use
   "PyUnicode_EncodeLocale()".

   参见: "Py_EncodeLocale()" 函数。

   3.2 新版功能.

   在 3.6 版更改: Use "Py_FileSystemDefaultEncodeErrors" error
   handler.


wchar_t 支持
------------

"wchar_t" support for platforms which support it:

PyObject *PyUnicode_FromWideChar(const wchar_t *w, Py_ssize_t size)
    *返回值：新的引用。** Part of the Stable ABI.*

   Create a Unicode object from the "wchar_t" buffer *w* of the given
   *size*. Passing "-1" as the *size* indicates that the function must
   itself compute the length, using wcslen. Return "NULL" on failure.

Py_ssize_t PyUnicode_AsWideChar(PyObject *unicode, wchar_t *w, Py_ssize_t size)
    * Part of the Stable ABI.*

   Copy the Unicode object contents into the "wchar_t" buffer *w*.  At
   most *size* "wchar_t" characters are copied (excluding a possibly
   trailing null termination character).  Return the number of
   "wchar_t" characters copied or "-1" in case of an error.  Note that
   the resulting "wchar_t*" string may or may not be null-terminated.
   It is the responsibility of the caller to make sure that the
   "wchar_t*" string is null-terminated in case this is required by
   the application. Also, note that the "wchar_t*" string might
   contain null characters, which would cause the string to be
   truncated when used with most C functions.

wchar_t *PyUnicode_AsWideCharString(PyObject *unicode, Py_ssize_t *size)
    * Part of the Stable ABI since version 3.7.*

   Convert the Unicode object to a wide character string. The output
   string always ends with a null character. If *size* is not "NULL",
   write the number of wide characters (excluding the trailing null
   termination character) into **size*. Note that the resulting
   "wchar_t" string might contain null characters, which would cause
   the string to be truncated when used with most C functions. If
   *size* is "NULL" and the "wchar_t*" string contains null characters
   a "ValueError" is raised.

   Returns a buffer allocated by "PyMem_Alloc()" (use "PyMem_Free()"
   to free it) on success. On error, returns "NULL" and **size* is
   undefined. Raises a "MemoryError" if memory allocation is failed.

   3.2 新版功能.

   在 3.7 版更改: 如果 *size* 为 "NULL" 且 "wchar_t*" 字符串包含空字符
   则会引发 "ValueError"。


内置编解码器
============

Python 提供了一组以 C 编写以保证运行速度的内置编解码器。 所有这些编解
码器均可通过下列函数直接使用。

下列 API 大都接受 encoding 和 errors 两个参数，它们具有与在内置
"str()" 字符串对象构造器中同名参数相同的语义。

Setting encoding to "NULL" causes the default encoding to be used
which is UTF-8.  The file system calls should use
"PyUnicode_FSConverter()" for encoding file names. This uses the
variable "Py_FileSystemDefaultEncoding" internally. This variable
should be treated as read-only: on some systems, it will be a pointer
to a static string, on others, it will change at run-time (such as
when the application invokes setlocale).

错误处理方式由 errors 设置并且也可以设为 "NULL" 表示使用为编解码器定义
的默认处理方式。 所有内置编解码器的默认错误处理方式是 "strict" (会引发
"ValueError")。

编解码器都使用类似的接口。 为了保持简单只有与下列泛型编解码器的差异才
会记录在文档中。


泛型编解码器
------------

以下是泛型编解码器的 API:

PyObject *PyUnicode_Decode(const char *s, Py_ssize_t size, const char *encoding, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过解码已编码字符串 *s* 的 *size* 个字节创建一个 Unicode 对象。
   *encoding* 和 *errors* 具有与 "str()" 内置函数中同名形参相同的含义
   。 要使用的编解码器将使用 Python 编解码器注册表来查找。 如果编解码
   器引发了异常则返回 "NULL"。

PyObject *PyUnicode_AsEncodedString(PyObject *unicode, const char *encoding, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   编码一个 Unicode 对象并将结果作为 Python 字节串对象返回。
   *encoding* 和 *errors* 具有与 Unicode "encode()" 方法中同名形参相同
   的含义。 要使用的编解码器将使用 Python 编解码器注册表来查找。 如果
   编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_Encode(const Py_UNICODE *s, Py_ssize_t size, const char *encoding, const char *errors)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer *s* of the given *size* and return a
   Python bytes object.  *encoding* and *errors* have the same meaning
   as the parameters of the same name in the Unicode "encode()"
   method.  The codec to be used is looked up using the Python codec
   registry.  Return "NULL" if an exception was raised by the codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsEncodedString()".


UTF-8 编解码器
--------------

以下是 UTF-8 编解码器 API:

PyObject *PyUnicode_DecodeUTF8(const char *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过解码 UTF-8 编码的字节串 *s* 的 *size* 个字节创建一个 Unicode 对
   象。 如果编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_DecodeUTF8Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
    *返回值：新的引用。** Part of the Stable ABI.*

   如果 *consumed* 为 "NULL"，则行为类似于 "PyUnicode_DecodeUTF8()"。
   如果 *consumed* 不为 "NULL"，则末尾的不完整 UTF-8 字节序列将不被视
   为错误。 这些字节将不会被解码并且已被解码的字节数将存储在
   *consumed* 中。

PyObject *PyUnicode_AsUTF8String(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用 UTF-8 编码 Unicode 对象并将结果作为 Python 字节串对象返回。 错
   误处理方式为 "strict"。 如果编解码器引发了异常则将返回 "NULL"。

const char *PyUnicode_AsUTF8AndSize(PyObject *unicode, Py_ssize_t *size)
    * Part of the Stable ABI since version 3.10.*

   返回一个指向 Unicode 对象的 UTF-8 编码格式数据的指针，并将已编码数
   据的大小（以字节为单位）存储在 *size* 中。 *size* 参数可以为 "NULL"
   ；在此情况下数据的大小将不会被存储。 返回的缓冲区总是会添加一个额外
   的空字节（不包括在 *size* 中），无论是否存在任何其他的空码位。

   在发生错误的情况下，将返回 "NULL" 附带设置一个异常并且不会存储
   *size* 值。

   这将缓存 Unicode 对象中字符串的 UTF-8 表示形式，并且后续调用将返回
   指向同一缓存区的指针。 调用方不必负责释放该缓冲区。 缓冲区会在
   Unicode 对象被作为垃圾回收时被释放并使指向它的指针失效。

   3.3 新版功能.

   在 3.7 版更改: 返回类型现在是 "const char *" 而不是 "char *"。

   在 3.10 版更改: This function is a part of the limited API.

const char *PyUnicode_AsUTF8(PyObject *unicode)

   类似于 "PyUnicode_AsUTF8AndSize()"，但不会存储大小值。

   3.3 新版功能.

   在 3.7 版更改: 返回类型现在是 "const char *" 而不是 "char *"。

PyObject *PyUnicode_EncodeUTF8(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer *s* of the given *size* using UTF-8
   and return a Python bytes object.  Return "NULL" if an exception
   was raised by the codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsUTF8String()", "PyUnicode_AsUTF8AndSize()" or
   "PyUnicode_AsEncodedString()".


UTF-32 编解码器
---------------

以下是 UTF-32 编解码器 API:

PyObject *PyUnicode_DecodeUTF32(const char *s, Py_ssize_t size, const char *errors, int *byteorder)
    *返回值：新的引用。** Part of the Stable ABI.*

   从 UTF-32 编码的缓冲区数据解码 *size* 个字节并返回相应的 Unicode 对
   象。 *errors* (如果不为 "NULL") 定义了错误处理方式。 默认为
   "strict"。

   如果 *byteorder* 不为 "NULL"，解码器将使用给定的字节序进行解码:

      *byteorder == -1: little endian
      *byteorder == 0:  native order
      *byteorder == 1:  big endian

   如果 "*byteorder" 为零，且输入数据的前四个字节为字节序标记 (BOM)，
   则解码器将切换为该字节序并且 BOM 将不会被拷贝到结果 Unicode 字符串
   中。 如果 "*byteorder" 为 "-1" 或 "1"，则字节序标记会被拷贝到输出中
   。

   在完成后，**byteorder* 将在输入数据的末尾被设为当前字节序。

   如果 *byteorder* 为 "NULL"，编解码器将使用本机字节序。

   如果编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_DecodeUTF32Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)
    *返回值：新的引用。** Part of the Stable ABI.*

   如果 *consumed* 为 "NULL"，则行为类似于 "PyUnicode_DecodeUTF32()"。
   如果 *consumed* 不为 "NULL"，则 "PyUnicode_DecodeUTF32Stateful()"
   将不把末尾的不完整 UTF-32 字节序列（如字节数不可被四整除）视为错误
   。 这些字节将不会被解码并且已被解码的字节数将存储在 *consumed* 中。

PyObject *PyUnicode_AsUTF32String(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI.*

   返回使用 UTF-32 编码格式本机字节序的 Python 字节串。 字节串将总是以
   BOM 标记打头。 错误处理方式为 "strict"。 如果编解码器引发了异常则返
   回 "NULL"。

PyObject *PyUnicode_EncodeUTF32(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)
    *返回值：新的引用。*

   Return a Python bytes object holding the UTF-32 encoded value of
   the Unicode data in *s*.  Output is written according to the
   following byte order:

      byteorder == -1: little endian
      byteorder == 0:  native byte order (writes a BOM mark)
      byteorder == 1:  big endian

   If byteorder is "0", the output string will always start with the
   Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
   prepended.

   If "Py_UNICODE_WIDE" is not defined, surrogate pairs will be output
   as a single code point.

   如果编解码器引发了异常则返回 "NULL"。

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsUTF32String()" or "PyUnicode_AsEncodedString()".


UTF-16 编解码器
---------------

以下是 UTF-16 编解码器的 API:

PyObject *PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors, int *byteorder)
    *返回值：新的引用。** Part of the Stable ABI.*

   从 UTF-16 编码的缓冲区数据解码 *size* 个字节并返回相应的 Unicode 对
   象。 *errors* (如果不为 "NULL") 定义了错误处理方式。 默认为
   "strict"。

   如果 *byteorder* 不为 "NULL"，解码器将使用给定的字节序进行解码:

      *byteorder == -1: little endian
      *byteorder == 0:  native order
      *byteorder == 1:  big endian

   如果 "*byteorder" 为零，且输入数据的前两个字节为字节序标记 (BOM)，
   则解码器将切换为该字节序并且 BOM 将不会被拷贝到结果 Unicode 字符串
   中。 如果 "*byteorder" 为 "-1" 或 "1"，则字节序标记会被拷贝到输出中
   (它将是一个 "\ufeff" 或 "\ufffe" 字符)。

   在完成后，"*byteorder" 将在输入数据的末尾被设为当前字节序。

   如果 *byteorder* 为 "NULL"，编解码器将使用本机字节序。

   如果编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_DecodeUTF16Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)
    *返回值：新的引用。** Part of the Stable ABI.*

   如果 *consumed* 为 "NULL"，则行为类似于 "PyUnicode_DecodeUTF16()"。
   如果 *consumed* 不为 "NULL"，则 "PyUnicode_DecodeUTF16Stateful()"
   将不把末尾的不完整 UTF-16 字节序列（如为奇数个字节或为分开的替代对
   ）视为错误。 这些字节将不会被解码并且已被解码的字节数将存储在
   *consumed* 中。

PyObject *PyUnicode_AsUTF16String(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI.*

   返回使用 UTF-16 编码格式本机字节序的 Python 字节串。 字节串将总是以
   BOM 标记打头。 错误处理方式为 "strict"。 如果编解码器引发了异常则返
   回 "NULL"。

PyObject *PyUnicode_EncodeUTF16(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)
    *返回值：新的引用。*

   Return a Python bytes object holding the UTF-16 encoded value of
   the Unicode data in *s*.  Output is written according to the
   following byte order:

      byteorder == -1: little endian
      byteorder == 0:  native byte order (writes a BOM mark)
      byteorder == 1:  big endian

   If byteorder is "0", the output string will always start with the
   Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is
   prepended.

   If "Py_UNICODE_WIDE" is defined, a single "Py_UNICODE" value may
   get represented as a surrogate pair. If it is not defined, each
   "Py_UNICODE" values is interpreted as a UCS-2 character.

   如果编解码器引发了异常则返回 "NULL"。

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsUTF16String()" or "PyUnicode_AsEncodedString()".


UTF-7 编解码器
--------------

以下是 UTF-7 编解码器 API:

PyObject *PyUnicode_DecodeUTF7(const char *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过解码 UTF-7 编码的字节串 *s* 的 *size* 个字节创建一个 Unicode 对
   象。 如果编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_DecodeUTF7Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
    *返回值：新的引用。** Part of the Stable ABI.*

   如果 *consumed* 为 "NULL"，则行为类似于 "PyUnicode_DecodeUTF7()"。
   如果 *consumed* 不为 "NULL"，则末尾的不完整 UTF-7 base-64 部分将不
   被视为错误。 这些字节将不会被解码并且已被解码的字节数将存储在
   *consumed* 中。

PyObject *PyUnicode_EncodeUTF7(const Py_UNICODE *s, Py_ssize_t size, int base64SetO, int base64WhiteSpace, const char *errors)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer of the given size using UTF-7 and
   return a Python bytes object.  Return "NULL" if an exception was
   raised by the codec.

   If *base64SetO* is nonzero, "Set O" (punctuation that has no
   otherwise special meaning) will be encoded in base-64.  If
   *base64WhiteSpace* is nonzero, whitespace will be encoded in
   base-64.  Both are set to zero for the Python "utf-7" codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsEncodedString()".


Unicode-Escape 编解码器
-----------------------

以下是 "Unicode Escape" 编解码器的 API:

PyObject *PyUnicode_DecodeUnicodeEscape(const char *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过解码 Unicode-Escape 编码的字节串 *s* 的 *size* 个字节创建一个
   Unicode 对象。 如果编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_AsUnicodeEscapeString(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用 Unicode-Escape 编码 Unicode 对象并将结果作为字节串对象返回。
   错误处理方式为 "strict"。 如果编解码器引发了异常则将返回 "NULL"。

PyObject *PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer of the given *size* using Unicode-
   Escape and return a bytes object.  Return "NULL" if an exception
   was raised by the codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsUnicodeEscapeString()".


Raw-Unicode-Escape 编解码器
---------------------------

以下是 "Raw Unicode Escape" 编解码器的 API:

PyObject *PyUnicode_DecodeRawUnicodeEscape(const char *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过解码 Raw-Unicode-Escape 编码的字节串 *s* 的 *size* 个字节创建一
   个 Unicode 对象。 如果编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用 Raw-Unicode-Escape 编码 Unicode 对象并将结果作为字节串对象返回
   。 错误处理方式为 "strict"。 如果编解码器引发了异常则将返回 "NULL"
   。

PyObject *PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer of the given *size* using Raw-
   Unicode-Escape and return a bytes object.  Return "NULL" if an
   exception was raised by the codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsRawUnicodeEscapeString()" or
   "PyUnicode_AsEncodedString()".


Latin-1 编解码器
----------------

以下是 Latin-1 编解码器的 API: Latin-1 对应于前 256 个 Unicode 码位且
编码器在编码期间只接受这些码位。

PyObject *PyUnicode_DecodeLatin1(const char *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过解码 Latin-1 编码的字节串 *s* 的 *size* 个字节创建一个 Unicode
   对象。 如果编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_AsLatin1String(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用 Latin-1 编码 Unicode 对象并将结果作为 Python 字节串对象返回。
   错误处理方式为 "strict"。 如果编解码器引发了异常则将返回 "NULL"。

PyObject *PyUnicode_EncodeLatin1(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer of the given *size* using Latin-1
   and return a Python bytes object.  Return "NULL" if an exception
   was raised by the codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsLatin1String()" or "PyUnicode_AsEncodedString()".


ASCII 编解码器
--------------

以下是 ASCII 编解码器的 API。 只接受 7 位 ASCII 数据。 任何其他编码的
数据都将导致错误。

PyObject *PyUnicode_DecodeASCII(const char *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过解码 ASCII 编码的字节串 *s* 的 *size* 个字节创建一个 Unicode 对
   象。 如果编解码器引发了异常则返回 "NULL"。

PyObject *PyUnicode_AsASCIIString(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用 ASCII 编码 Unicode 对象并将结果作为 Python 字节串对象返回。 错
   误处理方式为 "strict"。 如果编解码器引发了异常则将返回 "NULL"。

PyObject *PyUnicode_EncodeASCII(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer of the given *size* using ASCII and
   return a Python bytes object.  Return "NULL" if an exception was
   raised by the codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsASCIIString()" or "PyUnicode_AsEncodedString()".


字符映射编解码器
----------------

This codec is special in that it can be used to implement many
different codecs (and this is in fact what was done to obtain most of
the standard codecs included in the "encodings" package). The codec
uses mappings to encode and decode characters.  The mapping objects
provided must support the "__getitem__()" mapping interface;
dictionaries and sequences work well.

以下是映射编解码器的 API:

PyObject *PyUnicode_DecodeCharmap(const char *data, Py_ssize_t size, PyObject *mapping, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过使用给定的 *mapping* 对象解码已编码字节串 *s* 的 *size* 个字节
   创建 Unicode 对象。 如果编解码器引发了异常则返回 "NULL"。

   如果 *mapping* 为 "NULL"，则将应用 Latin-1 编码格式。 否则
   *mapping* 必须为字节码位值（0 至 255 范围内的整数）到 Unicode 字符
   串的映射、整数（将被解读为 Unicode 码位）或 "None"。 未映射的数据字
   节 -- 这样的数据将导致 "LookupError"，以及被映射到 "None" 的数据，
   "0xFFFE" 或 "'\ufffe'"，将被视为未定义的映射并导致报错。

PyObject *PyUnicode_AsCharmapString(PyObject *unicode, PyObject *mapping)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用给定的 *mapping* 对象编码 Unicode 对象并将结果作为字节串对象返
   回。 错误处理方式为 "strict"。 如果编解码器引发了异常则将返回
   "NULL"。

   *mapping* 对象必须将整数 Unicode 码位映射到字节串对象、0 至 255 范
   围内的整数或 "None"。 未映射的字符码位（将导致 "LookupError" 的数据
   ）以及映射到 "None" 的数据将被视为“未定义的映射”并导致报错。

PyObject *PyUnicode_EncodeCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *mapping, const char *errors)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer of the given *size* using the given
   *mapping* object and return the result as a bytes object.  Return
   "NULL" if an exception was raised by the codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsCharmapString()" or "PyUnicode_AsEncodedString()".

以下特殊的编解码器 API 会将 Unicode 映射至 Unicode。

PyObject *PyUnicode_Translate(PyObject *str, PyObject *table, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI.*

   通过应用字符映射表来转写字符串并返回结果 Unicode 对象。 如果编解码
   器引发了异常则返回 "NULL"。

   字符映射表必须将整数 Unicode 码位映射到整数 Unicode 码位或 "None" (
   这将删除相应的字符)。

   Mapping tables need only provide the "__getitem__()" interface;
   dictionaries and sequences work well.  Unmapped character ordinals
   (ones which cause a "LookupError") are left untouched and are
   copied as-is.

   *errors* 具有用于编解码器的通常含义。 它可以为 "NULL" 表示使用默认
   的错误处理方式。

PyObject *PyUnicode_TranslateCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *mapping, const char *errors)
    *返回值：新的引用。*

   Translate a "Py_UNICODE" buffer of the given *size* by applying a
   character *mapping* table to it and return the resulting Unicode
   object. Return "NULL" when an exception was raised by the codec.

   从 3.3 版起不建议使用，将在 3.11 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using "PyUnicode_Translate()".
   or generic codec based API


Windows 中的 MBCS 编解码器
--------------------------

以下是 MBCS 编解码器的 API。 目前它们仅在 Windows 中可用并使用 Win32
MBCS 转换器来实现转换。 请注意 MBCS（或 DBCS）是一类编码格式，而非只有
一个。 目标编码格式是由运行编解码器的机器上的用户设置定义的。

PyObject *PyUnicode_DecodeMBCS(const char *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI on Windows since
   version 3.7.*

   Create a Unicode object by decoding *size* bytes of the MBCS
   encoded string *s*. Return "NULL" if an exception was raised by the
   codec.

PyObject *PyUnicode_DecodeMBCSStateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
    *返回值：新的引用。** Part of the Stable ABI on Windows since
   version 3.7.*

   如果 *consumed* 为 "NULL"，则行为类似于 "PyUnicode_DecodeMBCS()"。
   如果 *consumed* 不为 "NULL"，则 "PyUnicode_DecodeMBCSStateful()" 将
   不会解码末尾的不完整字节并且已被解码的字节数将存储在 *consumed* 中
   。

PyObject *PyUnicode_AsMBCSString(PyObject *unicode)
    *返回值：新的引用。** Part of the Stable ABI on Windows since
   version 3.7.*

   使用 MBCS 编码 Unicode 对象并将结果作为 Python 字节串对象返回。 错
   误处理方式为 "strict"。 如果编解码器引发了异常则将返回 "NULL"。

PyObject *PyUnicode_EncodeCodePage(int code_page, PyObject *unicode, const char *errors)
    *返回值：新的引用。** Part of the Stable ABI on Windows since
   version 3.7.*

   Encode the Unicode object using the specified code page and return
   a Python bytes object.  Return "NULL" if an exception was raised by
   the codec. Use "CP_ACP" code page to get the MBCS encoder.

   3.3 新版功能.

PyObject *PyUnicode_EncodeMBCS(const Py_UNICODE *s, Py_ssize_t size, const char *errors)
    *返回值：新的引用。*

   Encode the "Py_UNICODE" buffer of the given *size* using MBCS and
   return a Python bytes object.  Return "NULL" if an exception was
   raised by the codec.

   从 3.3 版起不建议使用，将在 4.0 版中移除: Part of the old-style
   "Py_UNICODE" API; please migrate to using
   "PyUnicode_AsMBCSString()", "PyUnicode_EncodeCodePage()" or
   "PyUnicode_AsEncodedString()".


方法和槽位
----------


方法与槽位函数
==============

以下 API 可以处理输入的 Unicode 对象和字符串（在描述中我们称其为字符串
）并返回适当的 Unicode 对象或整数值。

如果发生异常它们都将返回 "NULL" 或 "-1"。

PyObject *PyUnicode_Concat(PyObject *left, PyObject *right)
    *返回值：新的引用。** Part of the Stable ABI.*

   拼接两个字符串得到一个新的 Unicode 字符串。

PyObject *PyUnicode_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit)
    *返回值：新的引用。** Part of the Stable ABI.*

   拆分一个字符串得到一个 Unicode 字符串的列表。 如果 *sep* 为 "NULL"
   ，则将根据空格来拆分所有子字符串。 否则，将根据指定的分隔符来拆分。
   最多拆分数为 *maxsplit*。 如为负值，则没有限制。 分隔符不包括在结果
   列表中。

PyObject *PyUnicode_Splitlines(PyObject *s, int keepend)
    *返回值：新的引用。** Part of the Stable ABI.*

   Split a Unicode string at line breaks, returning a list of Unicode
   strings. CRLF is considered to be one line break.  If *keepend* is
   "0", the line break characters are not included in the resulting
   strings.

PyObject *PyUnicode_Join(PyObject *separator, PyObject *seq)
    *返回值：新的引用。** Part of the Stable ABI.*

   使用给定的 *separator* 合并一个字符串列表并返回结果 Unicode 字符串
   。

Py_ssize_t PyUnicode_Tailmatch(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)
    * Part of the Stable ABI.*

   Return "1" if *substr* matches "str[start:end]" at the given tail
   end (*direction* == "-1" means to do a prefix match, *direction* ==
   "1" a suffix match), "0" otherwise. Return "-1" if an error
   occurred.

Py_ssize_t PyUnicode_Find(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)
    * Part of the Stable ABI.*

   Return the first position of *substr* in "str[start:end]" using the
   given *direction* (*direction* == "1" means to do a forward search,
   *direction* == "-1" a backward search).  The return value is the
   index of the first match; a value of "-1" indicates that no match
   was found, and "-2" indicates that an error occurred and an
   exception has been set.

Py_ssize_t PyUnicode_FindChar(PyObject *str, Py_UCS4 ch, Py_ssize_t start, Py_ssize_t end, int direction)
    * Part of the Stable ABI since version 3.7.*

   Return the first position of the character *ch* in "str[start:end]"
   using the given *direction* (*direction* == "1" means to do a
   forward search, *direction* == "-1" a backward search).  The return
   value is the index of the first match; a value of "-1" indicates
   that no match was found, and "-2" indicates that an error occurred
   and an exception has been set.

   3.3 新版功能.

   在 3.7 版更改: *start* and *end* are now adjusted to behave like
   "str[start:end]".

Py_ssize_t PyUnicode_Count(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end)
    * Part of the Stable ABI.*

   Return the number of non-overlapping occurrences of *substr* in
   "str[start:end]".  Return "-1" if an error occurred.

PyObject *PyUnicode_Replace(PyObject *str, PyObject *substr, PyObject *replstr, Py_ssize_t maxcount)
    *返回值：新的引用。** Part of the Stable ABI.*

   Replace at most *maxcount* occurrences of *substr* in *str* with
   *replstr* and return the resulting Unicode object. *maxcount* ==
   "-1" means replace all occurrences.

int PyUnicode_Compare(PyObject *left, PyObject *right)
    * Part of the Stable ABI.*

   比较两个字符串并返回 "-1", "0", "1" 分别表示小于、等于和大于。

   此函数执行失败时返回 "-1"，因此应当调用 "PyErr_Occurred()" 来检查错
   误。

int PyUnicode_CompareWithASCIIString(PyObject *uni, const char *string)
    * Part of the Stable ABI.*

   Compare a Unicode object, *uni*, with *string* and return "-1",
   "0", "1" for less than, equal, and greater than, respectively. It
   is best to pass only ASCII-encoded strings, but the function
   interprets the input string as ISO-8859-1 if it contains non-ASCII
   characters.

   此函数不会引发异常。

PyObject *PyUnicode_RichCompare(PyObject *left, PyObject *right, int op)
    *返回值：新的引用。** Part of the Stable ABI.*

   对两个 Unicode 字符串执行富比较并返回以下值之一:

   * "NULL" 用于引发了异常的情况

   * "Py_True" or "Py_False" for successful comparisons

   * "Py_NotImplemented" in case the type combination is unknown

   Possible values for *op* are "Py_GT", "Py_GE", "Py_EQ", "Py_NE",
   "Py_LT", and "Py_LE".

PyObject *PyUnicode_Format(PyObject *format, PyObject *args)
    *返回值：新的引用。** Part of the Stable ABI.*

   根据 *format* 和 *args* 返回一个新的字符串对象；这等同于 "format %
   args"。

int PyUnicode_Contains(PyObject *container, PyObject *element)
    * Part of the Stable ABI.*

   Check whether *element* is contained in *container* and return true
   or false accordingly.

   *element* has to coerce to a one element Unicode string. "-1" is
   returned if there was an error.

void PyUnicode_InternInPlace(PyObject **string)
    * Part of the Stable ABI.*

   Intern the argument **string* in place.  The argument must be the
   address of a pointer variable pointing to a Python Unicode string
   object.  If there is an existing interned string that is the same
   as **string*, it sets **string* to it (releasing the reference to
   the old string object and creating a new *strong reference* to the
   interned string object), otherwise it leaves **string* alone and
   interns it (creating a new *strong reference*). (Clarification:
   even though there is a lot of talk about references, think of this
   function as reference-neutral; you own the object after the call if
   and only if you owned it before the call.)

PyObject *PyUnicode_InternFromString(const char *v)
    *返回值：新的引用。** Part of the Stable ABI.*

   "PyUnicode_FromString()" 和 "PyUnicode_InternInPlace()" 的组合操作
   ，返回一个已内部化的新 Unicode 字符串对象，或一个指向具有相同值的原
   有内部化字符串对象的新的（“拥有的”）引用。
