当前位置：首页 > 编程语言 > python >内容正文

python

python cpython关系_第3篇:CPython内部探究:PyASCIIObject的初始化

发布时间：2024/1/23 python 35 豆豆

生活随笔收集整理的这篇文章主要介绍了 python cpython关系_第3篇:CPython内部探究:PyASCIIObject的初始化小编觉得挺不错的,现在分享给大家,帮大家做个参考.

在CPython3.3之后，字符串对象发生了根本性的变法,本篇我们来讨论一下字符串对象，在Include/unicodeobject.h，在整个源代码的官方文档可以归纳出几点。在CPython3.3+之后，Unicode字符串分为有4种

紧凑型ASCII(Compact ASCII)

紧凑型ASCII也称为ASCII限定字符串(ASCII only String).其对应PyASCIIObject结构体，该对象使用一个空间连续的内存块(一个内部的state结构体和一个wchar_t类型的指针)，紧凑型ASCII只能涵盖拉丁编码以内的字符。ASCII字符限定意味着PyASCIIObject只能U+0000 ～ U+007F这段区间的字符码。

typedef struct {

PyObject_HEAD

Py_ssize_t length; /* 字符串中的码位个数 */

Py_hash_t hash; /* Hash value; -1 if not set */

struct {

unsigned int interned:2;

unsigned int kind:3;

unsigned int compact:1;

unsigned int ascii:1;

unsigned int ready:1;

unsigned int :24;

} state;

wchar_t *wstr; /*C底层的宽字符序列以NUL结束*/

} PyASCIIObject;

ASCII限定字符串可以由PyUnicode_New函数使用其结构体创建并设定state.ascii为1,state.compact为1。

从上面的类定义可知

length用于保存字符串中字符编码的数量

hash用于缓存C级别字符串的哈系值。由于字符串对象是不可变对象,这样避免每次重新计算该字符串的hash字段的值

state保存了保存了其子类实例的状态信息，

wstr是缓存C字符串的一个wchar指针，当然它是以“\0”结束

紧凑型Unicode(Compact Unicode)

其对应PyCompactUnicodeObject结构体,紧凑型Unicode以PyASCIIObject为基类，非ASCII字符串可以通过PyUnicode_New函数为PyCompactUnicodeObject分配内存并设置state.compact=1

typedef struct {

PyASCIIObject _base;

Py_ssize_t utf8_length; /* utf8中的字节数，不包括结尾的\0. */

char *utf8; /* UTF-8表示形式(\0终止) */

Py_ssize_t wstr_length; /* wstr中的码位个数 */

} PyCompactUnicodeObject;

传统的字符串(Legacy String)

其对应PyUnicodeObject结构体，传统的字符串对象会其中会包含两种特殊状态not ready和ready。

传统的字符串可以通过PyUnicode_FromUnicode为分配PyUnicodeObject结构体分配内存并封装C级别的unicode字符串。实际的字符串数据最初位于wstr块中，并使用_PyUnicode_Ready函数复制到data的块中。

typedef struct {

PyCompactUnicodeObject _base;

union {

void *any;

Py_UCS1 *latin1;

Py_UCS2 *ucs2;

Py_UCS4 *ucs4;

} data; /* 最小形式的Unicode缓冲区 */

} PyUnicodeObject;

Unicode对象的原始基类除了PyObject外，是以PyASCIIObject继承而来的，PyCompactUnicodeObject类继承PyASCIIObject,PyUnicodeObject继承自PyCompactUnicodeObject，那么整个CPython3.3+的字符串体系可以用如下图表示

Unicode字符串的字节宽度

在了解字符串如何创建有一个非常关键概念，我们查看Include/cpython/unicodeobject.h源文件时，CPython内部定义了一个叫PyUnicode_Kind的枚举类型,PyUnicode_New函数在实例化一个字符串对象时，会使用PyUnicode_Kind的枚举值设定字符串对象内部类state.kind的值，该字段将告知CPython的其他内部代码如何解读C底层的char指针指向的字符串数据。

enum PyUnicode_Kind {

/* String contains only wstr byte characters. This is only possible

when the string was created with a legacy API and _PyUnicode_Ready()

has not been called yet. */

PyUnicode_WCHAR_KIND = 0,

/* Return values of the PyUnicode_KIND() macro: */

PyUnicode_1BYTE_KIND = 1,

PyUnicode_2BYTE_KIND = 2,

PyUnicode_4BYTE_KIND = 4

};

字符串对象的内存分配

前文说到PyASCIIObject对象和PyCompactUnicodeObject对象都可以通过PyUnicode_New函数来创建，那么该函数如何区分它创建的目标是PyASCIIObject，还是PyCompactUnicodeObject呢？尽管两者是"父子"的继承关系，毕竟它们是不同的数据类型，仔细看一下实现代码，大体上PyUnicode_New函数是根据maxchar来区分创建什么字符串对象的。

maxchar小于128，并且字符位宽为1个字节，即标准的ASCII可识别的有效字符仅有128个，于是创建PyASCIIObject对象

maxchar小于256，并且字符位宽为1个字节，PyUnicode_New就创建PyCompactUnicodeObject对象。对于256个字符码位组成的字符集,称为扩展的ASCII字符集(Extended ASCII Charset)

字节通常用于保存文本文档中的各个字符。在ASCII字符集中，每个0到127之间的二进制值都被赋予一个特定字符。大多数计算机扩展了ASCII字符集，以使用一个字节中可用的256个字符的整个范围。前128个字符处理特殊内容，例如常见外语中的重音字符。

maxchar小于65536，并且字符位宽为2个字节,PyUnicode_New就创建PyCompactUnicodeObject对象，这种情况PyCompactUnicodeObject对象实际保存的是utf-16编码的字符串。

最后一种情况就是处理码位个数大于65536且小于MAX_UNICODE，通常此类的字符串的编码是utf-32

PyObject *

PyUnicode_New(Py_ssize_t size, Py_UCS4 maxchar)

{

PyObject *obj;

PyCompactUnicodeObject *unicode;

void *data;

enum PyUnicode_Kind kind;

int is_sharing, is_ascii;

Py_ssize_t char_size;

Py_ssize_t struct_size;

/*返回空字符串的PyObject包装类 */

if (size == 0 && unicode_empty != NULL) {

Py_INCREF(unicode_empty);

return unicode_empty;

}

//处理ASCII字符集

is_ascii = 0;

is_sharing = 0;

struct_size = sizeof(PyCompactUnicodeObject);

if (maxchar < 128) {

kind = PyUnicode_1BYTE_KIND;

char_size = 1;

is_ascii = 1;

struct_size = sizeof(PyASCIIObject);

}

//处理ASCII扩展的字符集

else if (maxchar < 256) {

kind = PyUnicode_1BYTE_KIND;

char_size = 1;

}

//处理utf-16编码的字符集

else if (maxchar < 65536) {

kind = PyUnicode_2BYTE_KIND;

char_size = 2;

if (sizeof(wchar_t) == 2)

is_sharing = 1;

}

//处理utf-32编码的字符串

else {

if (maxchar > MAX_UNICODE) {

PyErr_SetString(PyExc_SystemError,

"invalid maximum character passed to PyUnicode_New");

return NULL;

}

kind = PyUnicode_4BYTE_KIND;

char_size = 4;

if (sizeof(wchar_t) == 4)

is_sharing = 1;

}

/* Ensure we won't overflow the size. */

if (size < 0) {

PyErr_SetString(PyExc_SystemError,

"Negative size passed to PyUnicode_New");

return NULL;

}

if (size > ((PY_SSIZE_T_MAX - struct_size) / char_size - 1))

return PyErr_NoMemory();

来自_PyObject_New()的重复分配代码，而不是对PyObject_New()的调用，

因此我们能够为对象及其数据缓冲区分配空间。

obj = (PyObject *) PyObject_MALLOC(struct_size + (size + 1) * char_size);

if (obj == NULL)

return PyErr_NoMemory();

//绑定PyUnicode_Type的类型信息

obj = PyObject_INIT(obj, &PyUnicode_Type);

if (obj == NULL)

return NULL;

unicode = (PyCompactUnicodeObject *)obj;

if (is_ascii)

//obj指针移动

data = ((PyASCIIObject*)obj) + 1;

else

data = unicode + 1;

//设定state内部类的状态信息

_PyUnicode_LENGTH(unicode) = size;

_PyUnicode_HASH(unicode) = -1;

_PyUnicode_STATE(unicode).interned = 0;

_PyUnicode_STATE(unicode).kind = kind;

_PyUnicode_STATE(unicode).compact = 1;

_PyUnicode_STATE(unicode).ready = 1;

_PyUnicode_STATE(unicode).ascii = is_ascii;

if (is_ascii) {

//NULL结束符

((char*)data)[size] = 0;

_PyUnicode_WSTR(unicode) = NULL;

}

else if (kind == PyUnicode_1BYTE_KIND) {

((char*)data)[size] = 0;

_PyUnicode_WSTR(unicode) = NULL;

_PyUnicode_WSTR_LENGTH(unicode) = 0;

unicode->utf8 = NULL;

unicode->utf8_length = 0;

}

else {

unicode->utf8 = NULL;

unicode->utf8_length = 0;

if (kind == PyUnicode_2BYTE_KIND)

((Py_UCS2*)data)[size] = 0;

else /* kind == PyUnicode_4BYTE_KIND */

((Py_UCS4*)data)[size] = 0;

if (is_sharing) {

_PyUnicode_WSTR_LENGTH(unicode) = size;

_PyUnicode_WSTR(unicode) = (wchar_t *)data;

}

else {

_PyUnicode_WSTR_LENGTH(unicode) = 0;

_PyUnicode_WSTR(unicode) = NULL;

}

#ifdef Py_DEBUG

unicode_fill_invalid((PyObject*)unicode, 0);

#endif

assert(_PyUnicode_CheckConsistency((PyObject*)unicode, 0));

return obj;

}

PyUnicode_New函数在计算要为字符串对象分配的内存后，即执行下面这条语句后

obj = (PyObject *) PyObject_MALLOC(struct_size + (size + 1) * char_size);

那么PyASCIIObject的内存分配如下图

跟着会调用PyObject_INIT(obj, &PyUnicode_Type)函数来将PyUnicode_Type实例绑定到字符串对象的头部。

OK！我们之前谈论PyType_Type实例和各内置数据类型的关系后，你应该清楚字符串对象的初始化匹配对应的PyUnicode_Type实例,我们关注的是tp_new字段的函数指针unicode_new

PyTypeObject PyUnicode_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"str", /* tp_name */

sizeof(PyUnicodeObject), /* tp_basicsize */

0, /* tp_itemsize */

/* Slots */

(destructor)unicode_dealloc, /* tp_dealloc */

.....

unicode_repr, /* tp_repr */

&unicode_as_number, /* tp_as_number */

&unicode_as_sequence, /* tp_as_sequence */

&unicode_as_mapping, /* tp_as_mapping */

(hashfunc) unicode_hash, /* tp_hash*/

....

(reprfunc) unicode_str, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

....

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE |

Py_TPFLAGS_UNICODE_SUBCLASS, /* tp_flags */

unicode_doc, /* tp_doc */

.....

PyUnicode_RichCompare, /* tp_richcompare */

0, /* tp_weaklistoffset */

unicode_iter, /* tp_iter */

0, /* tp_iternext */

unicode_methods, /* tp_methods */

....

&PyBaseObject_Type, /* tp_base */

....

unicode_new, /* tp_new */

PyObject_Del, /* tp_free */

};

若我们为以下字符串,分配内存,对于CPython来说，它们默认执行utf-8执行解码也即29个字节

"我是一个自由开发者!!"

当整个PyUnicode_New函数返回时，它构建的PyASCIIObject如下内存图所示

字符串对象的初始化

一个简单的例子，有想过在一个Python脚本中，一个字符串字面量如何在CPython内部完成字符串对象的实例化吗？对于CPython3.9来说，在实例化一个脚本内固有的字符串(即单引号或双引号内)，其实质上从C级别的字符指针(const char*)指向的字符串字面量拷贝到PyUnicode_New函数分配的堆内存的过程。而字符串初始化的函数调用起点为PyUnicode_DecodeUTF8Stateful函数。

该流程省略了很多unicode字节码解码等特殊情况而得到一个简化的流程图。经过测试，几乎所有Python脚本内部所有字符串初始化的常规函数调用流程。

有人可能会问，你这个图依据是怎么来的？我们已经知道PyUnicode_New函数是一个为字符串对象间接分配内存的函数接口，我们只要通过IDE工具查找并筛选引用该函数的上一个函数的结果，从中找到可能的函数调用路径，并在各个可能的函数中插入一些printf函数，打印函数名称和相关传入的关键参数，就能推断出该字符串对象初始化的轨迹了。还有慎用Python的Debug模型，因为你从IDE工具看到内存状态可能和运行时有所差异的。这个我在其他篇章也提到过。例如，我们在一个测试的test.py文件中，测试下面的Python字符串的实例化过程

"我是一个自由开发者!!"

那么执行python脚本将所有打印的运行时信息重定向到一个文本中

./python test.py >debug.txt

如下图所示，我们发现只要python的运行时系统不论调用模块间的内置函数，还是用户的自定义函数，只要涉及Python字符串对象都依次遵循上面PyASCIIObject/PyUnicodeObject初始化的函数调用过程

unicode_decode_utf8函数

回归正题，我们先看一下一个关键的函数unicode_decode_utf8,该函数的完整代码见Objects/unicodeobject.c的第4979行-5122行，由于篇幅所限我这里将该函数拆解三个部分来讨论，先查看第4979行第5088行.该函数第一个参数是const char*类型字符指针s，这里重点讨论该函数和它调用的ascii_decode函数的一些细节问题。

static PyObject *

unicode_decode_utf8(const char *s, Py_ssize_t size,

_Py_error_handler error_handler, const char *errors,

Py_ssize_t *consumed)

{

//处理空字符对象返回

if (size == 0) {

if (consumed)

*consumed = 0;

_Py_RETURN_UNICODE_EMPTY();

}

/* 处理仅为一个字符的情况，且假定是ASCII字符 */

if (size == 1 && (unsigned char)s[0] < 128) {

if (consumed)

*consumed = 1;

return get_latin1_char((unsigned char)s[0]);

}

const char *starts = s;

const char *end = s + size;

//假定参数s是一堆由ASCII码位组成的字符串

PyObject *u = PyUnicode_New(size, 127);

if (u == NULL) {

return NULL;

}

s += ascii_decode(s, end, PyUnicode_1BYTE_DATA(u));

if (s == end) {

return u;

}

....

}

unicode_decode_utf8函数假定传入的C级别的字符串分三种情况实例化字符串对象

第1种情况：仅包含一个字符且位于标准的ASCII字符集区间内

此时调用get_latin1_char函数并返回，那么get_latin1_char函数主要做的事情就是在整个Python解释器运行期间的缓存所有使用过的单个ASCII字符对象到一个长度为256的unicode_latin1静态数组中。否则会为该字符调用PyUnicode_New函数分配内存并缓存到unicode_latin1数组后再返回。

static PyObject*

get_latin1_char(unsigned char ch)

{

PyObject *unicode;

#ifdef LATIN1_SINGLETONS

unicode = unicode_latin1[ch];

//如果该字符已缓存在unicode_latin1中，立即返回

if (unicode) {

Py_INCREF(unicode);

return unicode;

}

#endif

//否则会为该字符分配内存

unicode = PyUnicode_New(1, ch);

if (!unicode) {

return NULL;

}

PyUnicode_1BYTE_DATA(unicode)[0] = ch;

assert(_PyUnicode_CheckConsistency(unicode, 1));

#ifdef LATIN1_SINGLETONS

Py_INCREF(unicode);

unicode_latin1[ch] = unicode;

#endif

return unicode;

}

第2种情况:假定字符串长度不超过127,即由ASCII区间内的任意编码组成的字符串

这一逻辑推定的事实是前127个字符编码(即ASCII字符集)是unicode字符集的一个子集。不论传入的C级别字符串属于哪一种情况，都需经过一个特殊的ascii_decode函数，这个ascii_decode函数对于在如下情况通常给unicode_decode_utf8函数返回0的偏移量

纯ASCII字符串或纯中文字符的unicode字符串

任意ASCII字符和多国unicode字符编码混合的字符串

PS：具体的源代码请查看下面代码，关于该函数CPython源代码文档,以及官方网站的API说明都没有提及，因此，我对其算法甚少理解，有大伙提供详细信息，烦请跟帖评论留言。

static Py_ssize_t

ascii_decode(const char *start, const char *end, Py_UCS1 *dest)

{

const char *p = start;

const char *aligned_end = (const char *) _Py_ALIGN_DOWN(end, SIZEOF_LONG);

#if !defined(__m68k__)

#if SIZEOF_LONG <= SIZEOF_VOID_P

//断言dest是按8字节对齐

assert(_Py_IS_ALIGNED(dest, SIZEOF_LONG));

if (_Py_IS_ALIGNED(p, SIZEOF_LONG)) {

/* Fast path, see in STRINGLIB(utf8_decode) for

an explanation. */

/* Help allocation */

const char *_p = p;

Py_UCS1 * q = dest;

while (_p < aligned_end) {

unsigned long value = *(const unsigned long *) _p;

if (value & ASCII_CHAR_MASK)

break;

*((unsigned long *)q) = value;

_p += SIZEOF_LONG;

q += SIZEOF_LONG;

}

p = _p;

while (p < end) {

if ((unsigned char)*p & 0x80)

break;

*q++ = *p++;

}

return p - start;

}

#endif

while (p < end) {

/* Fast path, see in STRINGLIB(utf8_decode) in stringlib/codecs.h

for an explanation. */

if (_Py_IS_ALIGNED(p, SIZEOF_LONG)) {

/* Help allocation */

const char *_p = p;

while (_p < aligned_end) {

unsigned long value = *(const unsigned long *) _p;

if (value & ASCII_CHAR_MASK)

break;

_p += SIZEOF_LONG;

}

p = _p;

if (_p == end)

break;

}

if ((unsigned char)*p & 0x80)

break;

++p;

}

memcpy(dest, start, p - start);

return p - start;

}

我们上面示例字符串在初始化时过程前，我们在其C函数内用pinrtf函数的关键信息的输出，编译后运行如下图

我们将上面的信息绘制成一个内存图，自然就一目了然啦。由于ascii_decode在函数返回后,对于任意的ASCII字符串对象或纯Unicode编码的字符串对象，p-start的偏移量始终为0.

ss8..png

还有更多的细节，我们说本实例的字符串的长度是29字节，前27个字节是unicode编码，而最后两个字节是纯粹ASCII字符。其实UTF-8的思想是使用不同长度的字节序列对各种Unicode字符进行编码，标准的ASCII字符，即包括拉丁字母数字和标点符号使用一个字节、ASCII扩展字符都以2字节的顺序排列、韩文，中文和日文表意文字使用3字节序列。

小结

我们本篇讨论了字符串对象的内存分配PyUnicode_New函数，以及提出了CPython3.3+的字符串初始化的函数调用路径，先讨论了unicode_decode_utf8函数和ascii_decode函数的一些细节问题。下一篇会讨论剩下的unicode_decode_utf8代码细节。

更新中.....

总结

以上是生活随笔为你收集整理的python cpython关系_第3篇:CPython内部探究:PyASCIIObject的初始化的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。

上一篇： python面向对象作业_python面
下一篇： python meshgrid_torc