第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
#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代码细节。

更新中.....

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 211,884评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,347评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,435评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,509评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,611评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,837评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,987评论 3赞 408
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,730评论 0赞 267
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,194评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,525评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,664评论 1赞 340
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,334评论 4赞 330
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,944评论 3赞 313
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,764评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,997评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,389评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,554评论 2赞 349