Unicode Objects and Codecs

Unicode Objects

由于Python 3.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对象已通过一个已弃用的API（通常为PyUnicode_FromUnicode()）创建，并且仅承载Py_UNICODE*你必须在调用任何其他API之前调用PyUnicode_READY()。

Unicode Type

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

Py_UCS4

Py_UCS2

Py_UCS1

这些类型是无符号整型类型的typedef，宽度足以分别包含32位，16位和8位的字符。当处理单个Unicode字符时，使用Py_UCS4。

版本3.3中的新功能。

Py_UNICODE

这是wchar_t的typedef，它是一个16位类型或32位类型，具体取决于平台。

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

PyASCIIObject

PyCompactUnicodeObject

PyUnicodeObject

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

版本3.3中的新功能。

PyTypeObject PyUnicode_Type

此实例PyTypeObject表示Python Unicode类型。它暴露给Python代码，如str。

以下API实际上是C宏，可用于快速检查和访问Unicode对象的内部只读数据：

int PyUnicode_Check(PyObject *o)

如果对象o是Unicode对象或Unicode子类型的实例，则返回true。

int PyUnicode_CheckExact(PyObject *o)

如果对象o是Unicode对象，而不是子类型的实例，则返回true。

int PyUnicode_READY(PyObject *o)

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

成功时返回0，失败时设置为-1，特别是在内存分配失败时发生。

版本3.3中的新功能。

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)

返回一个指向规范表达式的指针，转换为UCS1，UCS2或UCS4整数类型以进行直接字符访问。如果规范表示具有正确的字符大小，则不执行检查；使用PyUnicode_KIND()选择正确的宏。在访问之前，请确保PyUnicode_READY()已被调用。

版本3.3中的新功能。

PyUnicode_WCHAR_KIND

PyUnicode_1BYTE_KIND

PyUnicode_2BYTE_KIND

PyUnicode_4BYTE_KIND

返回PyUnicode_KIND()宏的值。

版本3.3中的新功能。

int PyUnicode_KIND(PyObject *o)

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

版本3.3中的新功能。

void* PyUnicode_DATA(PyObject *o)

返回一个void指针指向原始unicode缓冲区。o必须是“规范”表示中的Unicode对象（未选中）。

版本3.3中的新功能。

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

写入规范表示数据（使用PyUnicode_DATA()获得）。此宏不执行任何健全检查，并且旨在用于循环。调用者应缓存从其他宏调用获得的kind值和数据 t>指针。index是字符串中的索引（从0开始），value是应该写入该位置的新代码点值。

版本3.3中的新功能。

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

从规范表示数据（使用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(PyObject *o)

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

版本3.3中的新功能。

int PyUnicode_ClearFreeList()

清除空闲列表。返回已释放项目的总数。

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必须是Unicode对象（未选中）。

自版本3.3之后弃用，将在版本4.0中删除：部分旧式Unicode API请使用PyUnicode_GET_LENGTH()迁移。

Py_ssize_t PyUnicode_GET_DATA_SIZE(PyObject *o)

返回不推荐的Py_UNICODE表示形式的大小（以字节为单位）。o必须是Unicode对象（未选中）。

自版本3.3之后弃用，将在版本4.0中删除：部分旧式Unicode API请使用PyUnicode_GET_LENGTH()迁移。

Py_UNICODE* PyUnicode_AS_UNICODE(PyObject *o)

const char* PyUnicode_AS_DATA(PyObject *o)

返回指向对象的Py_UNICODE表示形式的指针。返回的缓冲区总是以额外的空代码点结束。它还可能包含嵌入的空代码点，这将导致在大多数C函数中使用时，该字符串被截断。AS_DATA形式将指针转换为const char *。o参数必须是Unicode对象（未选中）。

在版本3.3中更改：此宏现在效率低下 - 因为在许多情况下，Py_UNICODE表示不存在，需要创建 - 并且可能失败（返回NULL 带有异常集）。尝试移植代码以使用新的PyUnicode_nBYTE_DATA()宏或使用PyUnicode_WRITE()或PyUnicode_READ()。

自版本3.3之后弃用，将在版本4.0中删除：部分旧式Unicode API请使用PyUnicode_nBYTE_DATA()宏系列迁移。

Unicode Character Properties

Unicode提供了许多不同的字符属性。最常需要的可以通过这些宏来映射到C函数，这取决于Python配置。

int Py_UNICODE_ISSPACE(Py_UNICODE ch)

根据ch是否为空格字符返回1或0。

int Py_UNICODE_ISLOWER(Py_UNICODE ch)

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

int Py_UNICODE_ISUPPER(Py_UNICODE ch)

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

int Py_UNICODE_ISTITLE(Py_UNICODE ch)

根据ch是否为字幕字符，返回1或0。

int Py_UNICODE_ISLINEBREAK(Py_UNICODE ch)

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

int Py_UNICODE_ISDECIMAL(Py_UNICODE ch)

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

int Py_UNICODE_ISDIGIT(Py_UNICODE ch)

根据ch是否为数字字符，返回1或0。

int Py_UNICODE_ISNUMERIC(Py_UNICODE ch)

根据ch是否为数字字符，返回1或0。

int Py_UNICODE_ISALPHA(Py_UNICODE ch)

根据ch是否为字母字符，返回1或0。

int Py_UNICODE_ISALNUM(Py_UNICODE ch)

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

int Py_UNICODE_ISPRINTABLE(Py_UNICODE ch)

根据ch是否为可打印字符，返回1或0。不可打印字符是在Unicode字符数据库中定义为“其他”或“分隔符”的字符，除了被认为是可打印的ASCII空间（0x20）。（请注意，在此上下文中的可打印字符是在字符串上调用repr()时不应转义的字符。它对处理写入sys.stdout或sys.stderr的字符串没有影响。

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

Py_UNICODE Py_UNICODE_TOLOWER(Py_UNICODE ch)

将字符ch转换为小写。

从版本3.3开始弃用：此函数使用简单的大小写映射。

Py_UNICODE Py_UNICODE_TOUPPER(Py_UNICODE ch)

将字符ch转换为大写。

从版本3.3开始弃用：此函数使用简单的大小写映射。

Py_UNICODE Py_UNICODE_TOTITLE(Py_UNICODE ch)

返回字符ch转换为标题大小写。

从版本3.3开始弃用：此函数使用简单的大小写映射。

int Py_UNICODE_TODECIMAL(Py_UNICODE ch)

返回转换为十进制正整数的字符ch。如果这不可能，返回-1。此宏不引发异常。

int Py_UNICODE_TODIGIT(Py_UNICODE ch)

将字符ch转换为单个数字整数。如果这不可能，返回-1。此宏不引发异常。

double Py_UNICODE_TONUMERIC(Py_UNICODE ch)

返回字符ch转换为双精度型。如果这不可能，则返回-1.0。此宏不引发异常。

这些API可用于处理代理：

Py_UNICODE_IS_SURROGATE(ch)

检查ch是否为代理（0xD800 ch / t5> 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)

加入两个替代字符并返回单个Py_UCS4值。高和低 t>分别是代理对中的前导和尾随代理。

Creating and accessing Unicode strings

要创建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)

使用给定的种类创建一个新的Unicode对象（可能的值为PyUnicode_1BYTE_KIND等，由PyUnicode_KIND()）返回。缓冲区必须指向每个字符1，2或4个字节的大小单位的数组，由类型指定。

版本3.3中的新功能。

PyObject* PyUnicode_FromStringAndSize(const char *u, Py_ssize_t size)

从字符缓冲区u创建一个Unicode对象。字节将被解释为UTF-8编码。缓冲区被复制到新对象中。如果缓冲区不是NULL，则返回值可能是共享对象，即不允许修改数据。

如果u是NULL，则此函数的行为类似于PyUnicode_FromUnicode()，缓冲区设置为NULL。此使用已弃用，支持PyUnicode_New()。

PyObject *PyUnicode_FromString(const char *u)

从UTF-8编码的空终止字符缓冲区u创建Unicode对象。

PyObject* PyUnicode_FromFormat(const char *format, ...)

使用C printf() -style 格式字符串和可变数量的参数，计算生成的Python unicode字符串的大小，并返回一个字符串， 。变量参数必须为C类型，并且必须完全对应于格式 ASCII编码字符串中的格式字符。允许使用以下格式字符：

格式字符	类型	评论
%%	n / a	字面值％character。
%c	int	单个字符，表示为C int。
%d	int	完全等效于printf("%d")。
%u	unsigned int	完全等效于printf("%u")。
%ld	长	完全等效于printf("%ld")。
%li	长	完全等效于printf("%li")。
%lu	unsigned long	完全等效于printf("%lu")。
%lld	长长	完全等效于printf("%lld")。
%lli	长长	完全等效于printf("%lli")。
%llu	unsigned long long	完全等效于printf("%llu")。
%zd	Py_ssize_t	完全等效于printf("%zd")。
%zi	Py_ssize_t	完全等效于printf("%zi")。
%zu	size_t	完全等效于printf("%zu")。
%i	int	完全等效于printf("%i")。
%x	int	完全等效于printf("%x")。
%s	char *	一个以null结尾的C字符数组。
%p	void *	C指针的十六进制表示。大部分等效于printf("%p")，除了它确保以字面值0x开始，而不管平台的printf 。
%A	PyObject *	调用ascii()的结果。
%U	PyObject *	unicode对象。
%V	PyObject *，char *	一个unicode对象（可能是NULL）和一个以null结束的C字符数组作为第二个参数（如果第一个参数是NULL，将被使用）。
%S	PyObject *	调用PyObject_Str()的结果。
%R	PyObject *	调用PyObject_Repr()的结果。

无法识别的格式字符会将所有格式字符串的其余部分按原样复制到结果字符串，并放弃任何额外的参数。

注意

“％lld”和“％llu”格式说明仅在定义HAVE_LONG_LONG时可用。

注意

宽度格式化单元是字符数而不是字节数。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).

在版本3.2中更改：支持"%lld"和"%llu"已添加。

在版本3.3中已更改：支持"%li"，"%lli"和"%zi"

Changed in version 3.4: Support width and precision formatter for "%s", "%A", "%U", "%V", "%S", "%R" added.

PyObject* PyUnicode_FromFormatV(const char *format, va_list vargs)

与PyUnicode_FromFormat()相同，只是它需要两个参数。

PyObject* PyUnicode_FromEncodedObject(PyObject *obj, const char *encoding, const char *errors)

返回值：新引用。

将编码对象obj解码为Unicode对象。

根据给定的编码解码bytes，bytearray和其他bytes-like objects，并使用定义的错误处理由错误。两者都可以NULL使接口使用默认值（有关详细信息，请参阅Built-in Codecs）。

所有其他对象（包括Unicode对象）都会导致设置TypeError。

如果有错误，API返回NULL。调用者负责减少返回的对象。

Py_ssize_t PyUnicode_GetLength(PyObject *unicode)

返回Unicode对象的长度，在代码点。

版本3.3中的新功能。

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

将字符从一个Unicode对象复制到另一个。此函数在必要时执行字符转换，如果可能，则返回到memcpy()。返回-1并在错误时设置异常，否则返回0。

版本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)

将字符写入字符串。该字符串必须已通过PyUnicode_New()创建。因为Unicode字符串应该是不可变的，所以字符串不能被共享或者被哈希。

此函数检查unicode是Unicode对象，索引不在边界之外，并且该对象可以安全地修改。它的引用计数是1）。

版本3.3中的新功能。

Py_UCS4 PyUnicode_ReadChar(PyObject *unicode, Py_ssize_t index)

从字符串中读取字符。此函数检查unicode是Unicode对象，并且索引不超出范围，与宏版本PyUnicode_READ_CHAR()相反。

版本3.3中的新功能。

PyObject* PyUnicode_Substring(PyObject *str, Py_ssize_t start, Py_ssize_t end)

从字符索引开始（包含）到字符索引结束（排除）返回str的子字符串。不支持负索引。

版本3.3中的新功能。

Py_UCS4* PyUnicode_AsUCS4(PyObject *u, Py_UCS4 *buffer, Py_ssize_t buflen, int copy_null)

如果copy_null设置，将字符串u复制到UCS4缓冲区中，包括空字符。返回NULL，并且如果buflen小于u t5的长度，则在错误上设置异常（特别是ValueError成功返回缓冲区。

版本3.3中的新功能。

Py_UCS4* PyUnicode_AsUCS4Copy(PyObject *u)

将字符串u复制到使用PyMem_Malloc()分配的新UCS4缓冲区中。如果失败，则返回NULL并设置MemoryError。返回的缓冲区总是附加一个额外的空代码点。

版本3.3中的新功能。

Deprecated Py_UNICODE APIs

从版本3.3开始弃用，将在4.0版中删除。

这些API函数随着 PEP 393的实现而弃用。扩展模块可以继续使用它们，因为它们不会在Python 3.x中删除，但需要注意，它们的使用现在可能导致性能和内存命中。

PyObject* PyUnicode_FromUnicode(const Py_UNICODE *u, Py_ssize_t size)

返回值：新引用。

从给定大小的Py_UNICODE缓冲区u创建一个Unicode对象。u可能是NULL，这会导致内容未定义。用户有责任填写所需的数据。缓冲区被复制到新对象中。

如果缓冲区不是NULL，则返回值可能是共享对象。因此，仅当u为NULL时，才允许修改生成的Unicode对象。

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().

请使用PyUnicode_FromKindAndData()或PyUnicode_New()迁移。

Py_UNICODE* PyUnicode_AsUnicode(PyObject *unicode)

返回一个只读指针到Unicode对象的内部Py_UNICODE缓冲区或NULL错误。这将创建对象的Py_UNICODE*表示，如果它还不可用。缓冲区总是以一个额外的空代码点结束。请注意，生成的Py_UNICODE字符串也可能包含嵌入的空代码点，这将导致在大多数C函数中使用时，该字符串被截断。

请使用PyUnicode_AsUCS4()，PyUnicode_Substring()，PyUnicode_ReadChar()或类似的新API来迁移。

PyObject* PyUnicode_TransformDecimalToASCII(Py_UNICODE *s, Py_ssize_t size)

通过将给定大小的Py_UNICODE缓冲区中的所有十进制数字替换为ASCII数字0-9（根据其十进制值）来创建Unicode对象。如果发生异常，则返回NULL。

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

像PyUnicode_AsUnicode()，但也会在size中保存Py_UNICODE()数组长度（不包括额外的null终止符）。请注意，生成的Py_UNICODE*字符串可能包含嵌入的空代码点，这将导致在大多数C函数中使用时，该字符串被截断。

版本3.3中的新功能。

Py_UNICODE* PyUnicode_AsUnicodeCopy(PyObject *unicode)

创建以空代码点结尾的Unicode字符串的副本。在内存分配失败时返回NULL并引发MemoryError异常，否则返回一个新的已分配缓冲区（使用PyMem_Free()释放缓冲区）。请注意，生成的Py_UNICODE*字符串可能包含嵌入的空代码点，这将导致在大多数C函数中使用时，该字符串被截断。

版本3.2中的新功能。

请迁移到PyUnicode_AsUCS4Copy()或类似的新API。

Py_ssize_t PyUnicode_GetSize(PyObject *unicode)

返回弃用Py_UNICODE

请使用PyUnicode_GetLength()迁移。

PyObject* PyUnicode_FromObject(PyObject *obj)

返回值：新引用。

如果需要，将Unicode子类型的实例复制到新的真正的Unicode对象。如果obj已经是一个真正的Unicode对象（不是子类型），则返回具有递增引用计数的引用。

除Unicode或其子类型以外的对象将导致TypeError。

Locale Encoding

当前区域设置编码可用于解码来自操作系统的文本。

PyObject* PyUnicode_DecodeLocaleAndSize(const char *str, Py_ssize_t len, const char *errors)

解码当前语言环境编码的字符串。支持的错误处理程序为"strict"和"surrogateescape"（ PEP 383）。如果错误是NULL，则解码器使用"strict"错误处理程序。str必须以空字符结束，但不能包含嵌入的空字符。

使用PyUnicode_DecodeFSDefaultAndSize()解码来自Py_FileSystemDefaultEncoding（在Python启动时读取的区域设置编码）的字符串。

也可以看看

Py_DecodeLocale()函数。

版本3.3中的新功能。

PyObject* PyUnicode_DecodeLocale(const char *str, const char *errors)

类似于PyUnicode_DecodeLocaleAndSize()，但使用strlen()计算字符串长度。

版本3.3中的新功能。

PyObject* PyUnicode_EncodeLocale(PyObject *unicode, const char *errors)

将Unicode对象编码为当前语言环境编码。支持的错误处理程序为"strict"和"surrogateescape"（ PEP 383）。如果错误是NULL，则编码器使用"strict"错误处理程序。返回bytes对象。str不能包含嵌入的空字符。

使用PyUnicode_EncodeFSDefault()将字符串编码为Py_FileSystemDefaultEncoding（在Python启动时读取的语言环境编码）。

也可以看看

Py_EncodeLocale()函数。

版本3.3中的新功能。

File System Encoding

要对文件名和其他环境字符串进行编码和解码，应使用Py_FileSystemEncoding作为编码，并将"surrogateescape"用作错误处理程序（t4> PEP 383）。要在参数解析期间对文件名进行编码，应使用"O&"转换器，将PyUnicode_FSConverter()作为转换函数：

int PyUnicode_FSConverter(PyObject* obj, void* result)

ParseTuple转换器：使用PyUnicode_EncodeFSDefault()将str对象编码为bytes bytes对象按原样输出。result必须是PyBytesObject*，当它不再使用时必须被释放。

版本3.1中的新功能。

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

int PyUnicode_FSDecoder(PyObject* obj, void* result)

ParseTuple转换器：使用PyUnicode_DecodeFSDefaultAndSize()；将bytes对象解码为str str对象按原样输出。result必须是PyUnicodeObject*，它必须在不再使用时被释放。

版本3.2中的新功能。

PyObject* PyUnicode_DecodeFSDefaultAndSize(const char *s, Py_ssize_t size)

在Windows上使用Py_FileSystemDefaultEncoding和"surrogateescape"错误处理程序或"strict"解码字符串。

如果未设置Py_FileSystemDefaultEncoding，则回退到区域设置编码。

Py_FileSystemDefaultEncoding在启动时从语言环境编码初始化，以后无法修改。如果需要从当前语言环境编码解码字符串，请使用PyUnicode_DecodeLocaleAndSize()。

也可以看看

Py_DecodeLocale()函数。

在版本3.2中更改：在Windows上使用"strict"错误处理程序。

PyObject* PyUnicode_DecodeFSDefault(const char *s)

使用Windows上的Py_FileSystemDefaultEncoding和"surrogateescape"错误处理程序或"strict"解码以null结束的字符串。

如果未设置Py_FileSystemDefaultEncoding，则回退到区域设置编码。

如果知道字符串长度，请使用PyUnicode_DecodeFSDefaultAndSize()。

在版本3.2中更改：在Windows上使用"strict"错误处理程序。

PyObject* PyUnicode_EncodeFSDefault(PyObject *unicode)

在Windows上使用"surrogateescape"错误处理程序或"strict"将Unicode对象编码为Py_FileSystemDefaultEncoding，并返回bytes请注意，生成的bytes对象可能包含空字节。

如果未设置Py_FileSystemDefaultEncoding，则回退到区域设置编码。

Py_FileSystemDefaultEncoding在启动时从语言环境编码初始化，以后无法修改。如果需要将字符串编码为当前语言环境编码，请使用PyUnicode_EncodeLocale()。

也可以看看

Py_EncodeLocale()函数。

版本3.2中的新功能。

wchar_t Support

wchar_t支持支持它的平台：

PyObject* PyUnicode_FromWideChar(const wchar_t *w, Py_ssize_t size)

返回值：新引用。

从给定大小的wchar_t缓冲区w创建Unicode对象。传递-1作为size表示函数本身必须使用wcslen计算长度。失败时返回NULL。

Py_ssize_t PyUnicode_AsWideChar(PyUnicodeObject *unicode, wchar_t *w, Py_ssize_t size)

将Unicode对象内容复制到wchar_t缓冲区w中。最多可复制大小 wchar_t字符（不包括可能尾随的空终止字符）。返回已复制的wchar_t字符数，如果出现错误，则返回-1。请注意，生成的wchar_t*字符串可能或可能不是空终止。调用者的责任是确保wchar_t*字符串是null终止的，以防应用程序需要这种情况。另外，请注意，wchar_t*字符串可能包含空字符，这将导致在使用大多数C函数时，字符串被截断。

wchar_t* PyUnicode_AsWideCharString(PyObject *unicode, Py_ssize_t *size)

将Unicode对象转换为宽字符串。输出字符串总是以空字符结尾。如果size不是NULL，请将宽字符数（不包括尾随的空终止字符）写入* size。

返回由PyMem_Alloc()分配的缓冲区（使用PyMem_Free()释放它）。发生错误时，返回NULL，* size未定义，并引发MemoryError。请注意，生成的wchar_t字符串可能包含空字符，这将导致在使用大多数C函数时，字符串被截断。

版本3.2中的新功能。

UCS4 Support

版本3.3中的新功能。

size_t Py_UCS4_strlen(const Py_UCS4 *u)

Py_UCS4* Py_UCS4_strcpy(Py_UCS4 *s1, const Py_UCS4 *s2)

Py_UCS4* Py_UCS4_strncpy(Py_UCS4 *s1, const Py_UCS4 *s2, size_t n)

Py_UCS4* Py_UCS4_strcat(Py_UCS4 *s1, const Py_UCS4 *s2)

int Py_UCS4_strcmp(const Py_UCS4 *s1, const Py_UCS4 *s2)

int Py_UCS4_strncmp(const Py_UCS4 *s1, const Py_UCS4 *s2, size_t n)

Py_UCS4* Py_UCS4_strchr(const Py_UCS4 *s, Py_UCS4 c)

Py_UCS4* Py_UCS4_strrchr(const Py_UCS4 *s, Py_UCS4 c)

这些效用函数处理Py_UCS4字符的字符串，否则表现得与C标准库函数具有相同的名称。

Built-in Codecs

Python提供了一组内建编解码器，用C写速度。所有这些编解码器可以通过以下功能直接使用。

许多以下API接受两个参数编码和错误，它们具有与内部str() string对象构造函数相同的语义。

将编码设置为NULL会导致使用默认编码，即ASCII。文件系统调用应使用PyUnicode_FSConverter()编码文件名。这在内部使用变量Py_FileSystemDefaultEncoding。此变量应该被视为只读：在某些系统上，它将是一个指向静态字符串的指针，在其他系统上，它将在运行时改变（例如当应用程序调用setlocale时）。

错误处理由错误设置，也可以设置为NULL意味着使用为编解码器定义的默认处理。所有内建编解码器的默认错误处理是“strict”（引发ValueError）。

编解码器都使用类似的接口。为了简单起见，仅记录与以下通用名称的偏差。

Generic Codecs

这些是通用编解码器API：

PyObject* PyUnicode_Decode(const char *s, Py_ssize_t size, const char *encoding, const char *errors)

返回值：新引用。

通过解码编码字符串的大小字节来创建Unicode对象。 编码和错误与str()内建函数中相同名称的参数含义相同。要使用的编解码器使用Python编解码器注册表查找。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_AsEncodedString(PyObject *unicode, const char *encoding, const char *errors)

返回值：新引用。

编码Unicode对象并将结果返回为Python字节对象。编码和错误与Unicode encode()方法中相同名称的参数含义相同。要使用的编解码器使用Python编解码器注册表查找。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_Encode(const Py_UNICODE *s, Py_ssize_t size, const char *encoding, const char *errors)

返回值：新引用。

编码给定大小的Py_UNICODE缓冲区s，并返回一个Python字节对象。编码和错误与Unicode encode()方法中相同名称的参数含义相同。要使用的编解码器使用Python编解码器注册表查找。如果编解码器引发异常，则返回NULL。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请使用PyUnicode_AsEncodedString()迁移。

UTF-8 Codecs

这些是UTF-8编解码器API：

PyObject* PyUnicode_DecodeUTF8(const char *s, Py_ssize_t size, const char *errors)

返回值：新引用。

通过解码UTF-8编码字符串的大小字节来创建Unicode对象。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_DecodeUTF8Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)

返回值：新引用。

如果耗用是NULL，则表现为PyUnicode_DecodeUTF8()。如果耗用不是NULL，则不完整的UTF-8字节序列将不被视为错误。这些字节不会被解码，并且已解码的字节数将存储在consumption中。

PyObject* PyUnicode_AsUTF8String(PyObject *unicode)

返回值：新引用。

使用UTF-8编码Unicode对象，并将结果返回为Python字节对象。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

char* PyUnicode_AsUTF8AndSize(PyObject *unicode, Py_ssize_t *size)

返回指向Unicode对象的UTF-8编码的指针，并将编码表示的大小（以字节为单位）存储在size中。size参数可以是NULL；在这种情况下不会存储大小。返回的缓冲区总是有一个额外的空字节（不包括在size），不管是否有任何其他空代码点。

在出现错误的情况下，会返回NULL，并且未存储大小。

这会将Unicode对象中的字符串的UTF-8表示高速缓存，随后的调用将返回指向同一缓冲区的指针。调用者不负责释放缓冲区。

版本3.3中的新功能。

char* PyUnicode_AsUTF8(PyObject *unicode)

作为PyUnicode_AsUTF8AndSize()，但不存储大小。

版本3.3中的新功能。

PyObject* PyUnicode_EncodeUTF8(const Py_UNICODE *s, Py_ssize_t size, const char *errors)

返回值：新引用。

使用UTF-8编码给定大小的Py_UNICODE缓冲区s并返回一个Python字节对象。如果编解码器引发异常，则返回NULL。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请使用PyUnicode_AsUTF8String()或PyUnicode_AsUTF8AndSize()迁移。

UTF-32 Codecs

这些是UTF-32编解码器API：

PyObject* PyUnicode_DecodeUTF32(const char *s, Py_ssize_t size, const char *errors, int *byteorder)

从UTF-32编码的缓冲字符串解码size字节并返回相应的Unicode对象。错误（如果非NULL）定义错误处理。它默认为“strict”。

如果字节序为非NULL，则解码器使用给定的字节顺序开始解码：

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

如果*byteorder为零，并且输入数据的前四个字节是字节顺序标记（BOM），则解码器切换到此字节顺序，并且BOM不会复制到生成的Unicode字符串中。如果*byteorder为-1或1，则任何字节顺序标记将复制到输出。

完成后，*字节序设置为输入数据结束时的当前字节顺序。

如果byteorder是NULL，编解码器以本地顺序模式启动。

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

PyObject* PyUnicode_DecodeUTF32Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)

如果耗用是NULL，则表现为PyUnicode_DecodeUTF32()。如果used不是NULL，PyUnicode_DecodeUTF32Stateful()不会处理尾随的未完成的UTF-32字节序列（如一些字节不能被四）为错误。这些字节不会被解码，并且已解码的字节数将存储在consumption中。

PyObject* PyUnicode_AsUTF32String(PyObject *unicode)

以本地字节顺序使用UTF-32编码返回一个Python字节字符串。字符串始终以BOM标记开头。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_EncodeUTF32(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)

返回在s中保存Unicode数据的UTF-32编码值的Python字节对象。根据以下字节顺序写入输出：

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

如果byteorder为0，则输出字符串将始终以Unicode BOM标记（U + FEFF）开头。在其他两种模式下，不添加BOM标记。

如果未定义Py_UNICODE_WIDE，则代理对将作为单个代码点输出。

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

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请迁移到使用PyUnicode_AsUTF32String()。

UTF-16 Codecs

这些是UTF-16编解码器API：

PyObject* PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors, int *byteorder)

返回值：新引用。

从UTF-16编码的缓冲区字符串解码大小字节并返回相应的Unicode对象。错误（如果非NULL）定义错误处理。它默认为“strict”。

如果字节序为非NULL，则解码器使用给定的字节顺序开始解码：

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

如果*byteorder为零，并且输入数据的前两个字节是字节顺序标记（BOM），则解码器切换到此字节顺序，并且BOM不会复制到生成的Unicode字符串中。如果*byteorder为-1或1，则任何字节顺序标记将复制到输出（其中将导致\ufeff或\ufffe字符）。

完成后，*字节序设置为输入数据结束时的当前字节顺序。

如果byteorder是NULL，编解码器以本地顺序模式启动。

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

PyObject* PyUnicode_DecodeUTF16Stateful(const char *s, Py_ssize_t size, const char *errors, int *byteorder, Py_ssize_t *consumed)

返回值：新引用。

如果耗用是NULL，则表现为PyUnicode_DecodeUTF16()。如果耗用不是NULL，PyUnicode_DecodeUTF16Stateful()将不会处理尾随的未完成的UTF-16字节序列（例如奇数字节或分割代理对）作为错误。这些字节不会被解码，并且已解码的字节数将存储在consumption中。

PyObject* PyUnicode_AsUTF16String(PyObject *unicode)

返回值：新引用。

使用本地字节顺序的UTF-16编码返回一个Python字节字符串。字符串始终以BOM标记开头。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_EncodeUTF16(const Py_UNICODE *s, Py_ssize_t size, const char *errors, int byteorder)

返回值：新引用。

返回在s中保存Unicode数据的UTF-16编码值的Python字节对象。根据以下字节顺序写入输出：

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

如果byteorder为0，则输出字符串将始终以Unicode BOM标记（U + FEFF）开头。在其他两种模式下，不添加BOM标记。

如果定义Py_UNICODE_WIDE，则单个Py_UNICODE值可以表示为代理对。如果未定义，则每个Py_UNICODE值将解释为UCS-2字符。

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

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请使用PyUnicode_AsUTF16String()迁移。

UTF-7 Codecs

这些是UTF-7编解码器API：

PyObject* PyUnicode_DecodeUTF7(const char *s, Py_ssize_t size, const char *errors)

通过解码UTF-7编码字符串s的size字节来创建Unicode对象。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_DecodeUTF7Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)

如果耗用是NULL，则表现为PyUnicode_DecodeUTF7()。如果耗用不是NULL，则不会将不完整的UTF-7 base-64部分视为错误。这些字节不会被解码，并且已解码的字节数将存储在consumption中。

PyObject* PyUnicode_EncodeUTF7(const Py_UNICODE *s, Py_ssize_t size, int base64SetO, int base64WhiteSpace, const char *errors)

使用UTF-7编码给定大小的Py_UNICODE缓冲区，并返回一个Python字节对象。如果编解码器引发异常，则返回NULL。

如果base64SetO非零，则“Set O”（没有其他特殊含义的标点符号）将以base-64编码。如果base64WhiteSpace非零，则空白将以base-64编码。对于Python“utf-7”编解码器，它们都设置为零。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分。

Unicode-Escape Codecs

这些是“Unicode Escape”编解码器API：

PyObject* PyUnicode_DecodeUnicodeEscape(const char *s, Py_ssize_t size, const char *errors)

返回值：新引用。

通过解码Unicode-Escape编码字符串的大小字节来创建Unicode对象。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_AsUnicodeEscapeString(PyObject *unicode)

返回值：新引用。

使用Unicode-Escape编码Unicode对象，并将结果返回为Python字符串对象。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_EncodeUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size)

返回值：新引用。

使用Unicode-Escape编码给定大小的Py_UNICODE缓冲区并返回一个Python字符串对象。如果编解码器引发异常，则返回NULL。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请使用PyUnicode_AsUnicodeEscapeString()迁移。

Raw-Unicode-Escape Codecs

这些是“原始Unicode脱出”编解码器API：

PyObject* PyUnicode_DecodeRawUnicodeEscape(const char *s, Py_ssize_t size, const char *errors)

返回值：新引用。

通过解码Raw-Unicode-Escape编码字符串的大小字节来创建Unicode对象。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_AsRawUnicodeEscapeString(PyObject *unicode)

返回值：新引用。

使用Raw-Unicode-Escape编码Unicode对象，并将结果返回为Python字符串对象。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_EncodeRawUnicodeEscape(const Py_UNICODE *s, Py_ssize_t size, const char *errors)

返回值：新引用。

使用Raw-Unicode-Escape编码给定大小的Py_UNICODE缓冲区并返回一个Python字符串对象。如果编解码器引发异常，则返回NULL。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请使用PyUnicode_AsRawUnicodeEscapeString()迁移。

Latin-1 Codecs

这些是Latin-1编解码器API：Latin-1对应于前256个Unicode序数，并且编码期间这些编解码器只接受这些。

PyObject* PyUnicode_DecodeLatin1(const char *s, Py_ssize_t size, const char *errors)

返回值：新引用。

通过解码拉丁语-1编码字符串的大小字节来创建Unicode对象。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_AsLatin1String(PyObject *unicode)

返回值：新引用。

使用Latin-1编码Unicode对象，并将结果返回为Python字节对象。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_EncodeLatin1(const Py_UNICODE *s, Py_ssize_t size, const char *errors)

返回值：新引用。

使用Latin-1编码给定大小的Py_UNICODE缓冲区并返回一个Python字节对象。如果编解码器引发异常，则返回NULL。

Deprecated since version 3.3, will be removed in version 4.0: Part of the old-style Py_UNICODE API; please migrate to using PyUnicode_AsLatin1String().

ASCII Codecs

这些是ASCII编解码器API。只接受7位ASCII数据。所有其他代码生成错误。

PyObject* PyUnicode_DecodeASCII(const char *s, Py_ssize_t size, const char *errors)

返回值：新引用。

通过解码ASCII编码字符串的大小字节来创建Unicode对象。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_AsASCIIString(PyObject *unicode)

返回值：新引用。

使用ASCII编码Unicode对象，并将结果返回为Python字节对象。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_EncodeASCII(const Py_UNICODE *s, Py_ssize_t size, const char *errors)

返回值：新引用。

使用ASCII编码给定大小的Py_UNICODE缓冲区，并返回一个Python字节对象。如果编解码器引发异常，则返回NULL。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请使用PyUnicode_AsASCIIString()迁移。

Character Map Codecs

这种编解码器是特别的，因为它可以用于实现许多不同的编解码器（这实际上是为了获得encodings包中包含的大多数标准编解码器而做的）。编解码器使用映射来编码和解码字符。

解码映射必须将单个字符串字符映射到单个Unicode字符，整数（然后解释为Unicode序数）或None（意味着“未定义映射”并导致错误）。

编码映射必须将单个Unicode字符映射到单个字符串字符，整数（然后解释为Latin-1序数）或None（意味着“未定义映射”并导致错误）。

提供的映射对象必须只支持__getitem__映射接口。

如果字符查找失败并出现LookupError，则该字符将被复制，这意味着其序数值将被解释为Unicode或Latin-1序数。因此，映射只需要包含将字符映射到不同代码点的映射。

这些是映射编解码器API：

PyObject* PyUnicode_DecodeCharmap(const char *s, Py_ssize_t size, PyObject *mapping, const char *errors)

返回值：新引用。

使用给定的映射对象解码编码字符串的大小字节来创建Unicode对象。如果编解码器引发异常，则返回NULL。如果映射是NULL，拉丁-1解码将被完成。否则它可以是字典映射字节或unicode字符串，被视为查找表。大于字符串长度的字节值和U + FFFE“字符”的长度被视为“未定义映射”。

PyObject* PyUnicode_AsCharmapString(PyObject *unicode, PyObject *mapping)

返回值：新引用。

使用给定的映射对Unicode对象进行编码，并将结果返回为Python字符串对象。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

以下编解码器API是特殊的，将Unicode映射到Unicode。

PyObject* PyUnicode_TranslateCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *table, const char *errors)

返回值：新引用。

通过对其应用字符映射表来翻译给定大小的Py_UNICODE缓冲区并返回生成的Unicode对象。当编解码器引发异常时返回NULL。

映射表必须将Unicode序数整数映射到Unicode序数整数或None（导致删除字符）。

映射表只需要提供__getitem__()接口；字典和序列工作良好。未映射字符序数（导致LookupError的字符序数）保持不变，并按原样复制。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分。

PyObject* PyUnicode_EncodeCharmap(const Py_UNICODE *s, Py_ssize_t size, PyObject *mapping, const char *errors)

返回值：新引用。

使用给定的映射对给定的大小的Py_UNICODE缓冲区进行编码，并返回一个Python字符串对象。如果编解码器引发异常，则返回NULL。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请使用PyUnicode_AsCharmapString()迁移。

MBCS codecs for Windows

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

PyObject* PyUnicode_DecodeMBCS(const char *s, Py_ssize_t size, const char *errors)

返回值：新引用。

通过解码MBCS编码字符串的大小字节来创建Unicode对象。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_DecodeMBCSStateful(const char *s, int size, const char *errors, int *consumed)

If consumed is NULL, behave like PyUnicode_DecodeMBCS(). If consumed is not NULL, PyUnicode_DecodeMBCSStateful() will not decode trailing lead byte and the number of bytes that have been decoded will be stored in consumed.

PyObject* PyUnicode_AsMBCSString(PyObject *unicode)

返回值：新引用。

使用MBCS编码Unicode对象，并将结果返回为Python字节对象。错误处理是“strict”。如果编解码器引发异常，则返回NULL。

PyObject* PyUnicode_EncodeCodePage(int code_page, PyObject *unicode, const char *errors)

使用指定的代码页编码Unicode对象，并返回一个Python字节对象。如果编解码器引发异常，则返回NULL。使用CP_ACP代码页获取MBCS编码器。

版本3.3中的新功能。

PyObject* PyUnicode_EncodeMBCS(const Py_UNICODE *s, Py_ssize_t size, const char *errors)

返回值：新引用。

使用MBCS编码给定大小的Py_UNICODE缓冲区，并返回一个Python字节对象。如果编解码器引发异常，则返回NULL。

从版本3.3开始弃用，将在版本4.0中删除：旧式Py_UNICODE API的一部分；请使用PyUnicode_AsMBCSString()或PyUnicode_EncodeCodePage()迁移。

Methods & Slots

Methods and Slot Functions

以下API能够处理Unicode对象和输入上的字符串（我们在说明中将它们称为字符串），并根据需要返回Unicode对象或整数。

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

PyObject* PyUnicode_Concat(PyObject *left, PyObject *right)

返回值：新引用。

Concat两个字符串给出一个新的Unicode字符串。

PyObject* PyUnicode_Split(PyObject *s, PyObject *sep, Py_ssize_t maxsplit)

返回值：新引用。

拆分一个给出Unicode字符串列表的字符串。如果sep是NULL，则将在所有空格子串处进行拆分。否则，分裂发生在给定的分隔符。最多只能执行maxsplit拆分。如果为负，则不设置限制。分隔符不包括在结果列表中。

PyObject* PyUnicode_Splitlines(PyObject *s, int keepend)

返回值：新引用。

在换行符处拆分Unicode字符串，返回Unicode字符串列表。CRLF被认为是一个换行符。如果keepend为0，则换行符不包括在生成的字符串中。

PyObject* PyUnicode_Translate(PyObject *str, PyObject *table, const char *errors)

返回值：新引用。

通过对字符串应用字符映射表来翻译字符串，并返回生成的Unicode对象。

映射表必须将Unicode序数整数映射到Unicode序数整数或None（导致删除字符）。

映射表只需要提供__getitem__()接口；字典和序列工作良好。未映射字符序数（导致LookupError的字符序数）保持不变，并按原样复制。

errors具有编解码器的通常含义。可以是NULL，表示使用默认错误处理。

PyObject* PyUnicode_Join(PyObject *separator, PyObject *seq)

返回值：新引用。

使用给定的分隔符连接字符串序列，并返回生成的Unicode字符串。

Py_ssize_t PyUnicode_Tailmatch(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)

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. 如果发生错误，返回-1。

Py_ssize_t PyUnicode_Find(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end, int direction)

使用给定的方向（方向 == 1）返回str[start:end]中的substr意味着进行向前搜索，方向 == -1向后搜索）。返回值是第一个匹配的索引；值-1表示未找到匹配，-2表示发生了错误并设置了异常。

Py_ssize_t PyUnicode_FindChar(PyObject *str, Py_UCS4 ch, Py_ssize_t start, Py_ssize_t end, int direction)

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). 返回值是第一个匹配的索引；值-1表示未找到匹配，-2表示发生了错误并设置了异常。

版本3.3中的新功能。

Py_ssize_t PyUnicode_Count(PyObject *str, PyObject *substr, Py_ssize_t start, Py_ssize_t end)

返回str[start:end]中substr的不重叠出现次数。如果发生错误，返回-1。

PyObject* PyUnicode_Replace(PyObject *str, PyObject *substr, PyObject *replstr, Py_ssize_t maxcount)

返回值：新引用。

在str中用replstr替换最多maxcount次的substr，并返回生成的Unicode对象。maxcount == -1表示替换所有出现。

int PyUnicode_Compare(PyObject *left, PyObject *right)

比较两个字符串，并分别返回-1，0，1小于，等于和大于。

int PyUnicode_CompareWithASCIIString(PyObject *uni, const char *string)

将unicode对象uni与string进行比较，并分别对小于，等于和大于返回-1,0,1。最好只传递ASCII编码的字符串，但如果输入字符串包含非ASCII字符，则该函数将其解释为ISO-8859-1。

PyObject* PyUnicode_RichCompare(PyObject *left, PyObject *right, int op)

Rich比较两个Unicode字符串并返回以下之一：

• NULL，以防发生异常
• Py_True或Py_False，以便成功比较
• Py_NotImplemented，以防类型组合未知

请注意，如果参数到Unicode的转换失败，并且UnicodeDecodeError，则Py_EQ和Py_NE比较可能会导致UnicodeWarning >。

op的可能值为Py_GT，Py_GE，Py_EQ，Py_NE，Py_LT和Py_LE。

PyObject* PyUnicode_Format(PyObject *format, PyObject *args)

返回值：新引用。

从格式和args返回一个新的字符串对象；这类似于格式 ％ args。

int PyUnicode_Contains(PyObject *container, PyObject *element)

检查元素是否包含在容器中，并相应地返回true或false。

元素必须强制为一个元素的Unicode字符串。如果存在错误，则返回-1。

void PyUnicode_InternInPlace(PyObject **string)

实际中的参数* string。参数必须是指向Python Unicode字符串对象的指针变量的地址。如果存在与* string相同的现有内部字符串，则会将* string设置为（减少旧字符串对象的引用计数，并增加引用计数），否则它会留下* string，并实现它（增加它的引用计数）。（澄清：即使有很多关于引用计数的讨论，认为此函数作为引用计数中立；在调用之后拥有对象，如果且仅当在调用之前拥有它）。

PyObject* PyUnicode_InternFromString(const char *v)

PyUnicode_FromString()和PyUnicode_InternInPlace()的组合，将已经被嵌入的新的Unicode字符串对象或者新的（“拥有的”字符串对象具有相同的值。