Python內建類型str原始碼分析

1 Unicode

電腦儲存的基本單位是位元組，由8個位元位元組成。由於英文只由26個字母加若干符號組成，因此英文字元可以直接用位元組來保存。但是其他語言（例如中日韓等），由於字元眾多，不得不使用多個位元組來進行編碼。

隨著電腦科技的傳播，非拉丁文字元編碼技術不斷發展，但仍有兩個比較大的限制：

• 不支援多語言：一種語言的編碼方案不能用於另一種語言

• 沒有統一標準：例如中文就有GBK、GB2312、GB18030等多種編碼標準

#由於編碼方式不統一，開發人員就需要在不同編碼之間來回轉換，不可避免地會出現很多錯誤。為了解決這類不統一問題，Unicode標準被提出了。 Unicode會對世界上大部分文字系統進行整理、編碼，讓電腦可以用統一的方式處理文字。 Unicode目前已經收錄了超過14萬個字符，自然支援多語言。 （Unicode的uni就是「統一」的字根）

2 Python中的Unicode

#2.1 Unicode物件的好處

Python在3之後，str物件內部改用Unicode表示，因此在原始碼中成為Unicode物件。使用Unicode表示的好處是：程式核心邏輯統一使用Unicode，只需在輸入、輸出層進行解碼、編碼，可最大程度地避免各種編碼問題。

圖示如下：

2.2 Python對Unicode的最佳化

#問題：由於Unicode收錄字元已經超過14萬個，每個字元至少要4個位元組來保存（這裡應該是因為2個位元組不夠，所以才用4個位元組，一般不會使用3個位元組）。而英文字元用ASCII碼表示只需要1個字節，使用Unicode反而會使頻繁使用的英文字元的開銷變成原來的4倍。

首先我們來看看Python中不同形式的str物件的大小差異：

>>> sys.getsizeof('ab') - sys.getsizeof('a')
1
>>> sys.getsizeof('一二') - sys.getsizeof('一')
2
>>> sys.getsizeof('????????') - sys.getsizeof('????')
4

由此可見，Python內部對Unicode物件進行了最佳化：根據文字內容，選擇底層儲存單元。

Unicode物件底層儲存根據文字字元的Unicode碼位元範圍分成三類：

• PyUnicode_1BYTE_KIND：所有字元碼位元在U 0000到U 00FF之間

• PyUnicode_2BYTE_KIND：所有字元碼位元在U 0000到U FFFF之間，且至少有一個字元的碼位元大於U 00FF

• PyUnicode_1BYTE_KIND：所有字元碼位在U 0000到U 10FFFF之間，且至少有一個字元的碼位大於U FFFF

對應枚舉如下：

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
};

根據不同的分類，選擇不同的儲存單元：

/* Py_UCS4 and Py_UCS2 are typedefs for the respective
   unicode representations. */
typedef uint32_t Py_UCS4;
typedef uint16_t Py_UCS2;
typedef uint8_t Py_UCS1;

對應關係如下：

##字元儲存單元字元儲存單元大小（位元組）PyUnicode_1BYTE_KINDPy_UCS11#PyUnicode_2BYTE_KIND1#PyUnicode_2BYTE_KIND#PyUnicode_2BYTE_KIND1

#文字類型
1		#PyUnicode_2BYTE_KIND
	1

#PyUnicode_2BYTE_KIND
• 1

• #PyUnicode_2BYTE_KIND

  1

• #PyUnicode

Py_UCS2

• 2

PyUnicode_4BYTE_KIND

Py_UCS4#4#Py_UCS4#4#由於Unicode內部儲存結構因文字類型而異，因此類型kind必須作為Unicode物件公共欄位進行儲存。 Python內部定義了一些標誌位，作為Unicode公共字段：（介於筆者水平有限，這裡的字段在後續內容中不會全部介紹，大家後續可以自行了解。抱拳~）##compact：記憶體分配方式，物件與文字緩衝區是否分離asscii：文字是否皆為純ASCII透過PyUnicode_New函數，根據文字字元數size以及最大字元maxchar初始化Unicode物件。此函數主要是根據maxchar為Unicode物件選擇最緊湊的字元儲存單元以及底層結構體：（原始碼比較長，這裡就不列出了，大家可以自行了解，下面以表格形式展現）maxchar kindascii

#interned：是否為interned機制維護		kind：類型，用於區分字元底層儲存單元大小
#128	256	65536
PyUnicode_1BYTE_KIND	PyUnicode_1BYTE_KIND	PyUnicode_2BYTE_KIND	PyUnicode_4BYTE_KIND

#1######0######0#####0# ###########字元儲存單元大小（位元組）######1#######1######2######4### #########底層結構體######PyASCIIObject######PyCompactUnicodeObject######PyCompactUnicodeObject#######PyCompactUnicodeObject########## ##

3 Unicode对象的底层结构体

3.1 PyASCIIObject

C源码：

typedef struct {
    PyObject_HEAD
    Py_ssize_t length;          /* Number of code points in the string */
    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;              /* wchar_t representation (null-terminated) */
} PyASCIIObject;

源码分析：

length：文本长度

hash：文本哈希值

state：Unicode对象标志位

wstr：缓存C字符串的一个wchar_t指针，以“\0”结束（这里和我看的另一篇文章讲得不太一样，另一个描述是：ASCII文本紧接着位于PyASCIIObject结构体后面，我个人觉得现在的这种说法比较准确，毕竟源码结构体后面没有别的字段了）

图示如下：

（注意这里state字段后面有一个4字节大小的空洞，这是结构体字段内存对齐造成的现象，主要是为了优化内存访问效率）

ASCII文本由wstr指向，以’abc’和空字符串对象’'为例：

3.2 PyCompactUnicodeObject

如果文本不全是ASCII，Unicode对象底层便由PyCompactUnicodeObject结构体保存。C源码如下：

/* Non-ASCII strings allocated through PyUnicode_New use the
   PyCompactUnicodeObject structure. state.compact is set, and the data
   immediately follow the structure. */
typedef struct {
    PyASCIIObject _base;
    Py_ssize_t utf8_length;     /* Number of bytes in utf8, excluding the
                                 * terminating \0. */
    char *utf8;                 /* UTF-8 representation (null-terminated) */
    Py_ssize_t wstr_length;     /* Number of code points in wstr, possible
                                 * surrogates count as two code points. */
} PyCompactUnicodeObject;

PyCompactUnicodeObject在PyASCIIObject的基础上增加了3个字段：

utf8_length：文本UTF8编码长度

utf8：文本UTF8编码形式，缓存以避免重复编码运算

wstr_length：wstr的“长度”（这里所谓的长度没有找到很准确的说法，笔者也不太清楚怎么能打印出来，大家可以自行研究下）

注意到，PyASCIIObject中并没有保存UTF8编码形式，这是因为ASCII本身就是合法的UTF8，这也是ASCII文本底层由PyASCIIObject保存的原因。

结构图示：

3.3 PyUnicodeObject

PyUnicodeObject则是Python中str对象的具体实现。C源码如下：

/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the
   PyUnicodeObject structure. The actual string data is initially in the wstr
   block, and copied into the data block using _PyUnicode_Ready. */
typedef struct {
    PyCompactUnicodeObject _base;
    union {
        void *any;
        Py_UCS1 *latin1;
        Py_UCS2 *ucs2;
        Py_UCS4 *ucs4;
    } data;                     /* Canonical, smallest-form Unicode buffer */
} PyUnicodeObject;

3.4 示例

在日常开发时，要结合实际情况注意字符串拼接前后的内存大小差别：

>>> import sys
>>> text = 'a' * 1000
>>> sys.getsizeof(text)
1049
>>> text += '????'
>>> sys.getsizeof(text)
4080

4 interned机制

如果str对象的interned标志位为1，Python虚拟机将为其开启interned机制，

源码如下：（相关信息在网上可以看到很多说法和解释，这里笔者能力有限，暂时没有找到最确切的答案，之后补充。抱拳~但是我们通过分析源码应该是能看出一些门道的）

/* This dictionary holds all interned unicode strings.  Note that references
   to strings in this dictionary are *not* counted in the string's ob_refcnt.
   When the interned string reaches a refcnt of 0 the string deallocation
   function will delete the reference from this dictionary.
   Another way to look at this is that to say that the actual reference
   count of a string is:  s->ob_refcnt + (s->state ? 2 : 0)
*/
static PyObject *interned = NULL;
void
PyUnicode_InternInPlace(PyObject **p)
{
    PyObject *s = *p;
    PyObject *t;
#ifdef Py_DEBUG
    assert(s != NULL);
    assert(_PyUnicode_CHECK(s));
#else
    if (s == NULL || !PyUnicode_Check(s))
        return;
#endif
    /* If it's a subclass, we don't really know what putting
       it in the interned dict might do. */
    if (!PyUnicode_CheckExact(s))
        return;
    if (PyUnicode_CHECK_INTERNED(s))
        return;
    if (interned == NULL) {
        interned = PyDict_New();
        if (interned == NULL) {
            PyErr_Clear(); /* Don't leave an exception */
            return;
        }
    }
    Py_ALLOW_RECURSION
    t = PyDict_SetDefault(interned, s, s);
    Py_END_ALLOW_RECURSION
    if (t == NULL) {
        PyErr_Clear();
        return;
    }
    if (t != s) {
        Py_INCREF(t);
        Py_SETREF(*p, t);
        return;
    }
    /* The two references in interned are not counted by refcnt.
       The deallocator will take care of this */
    Py_REFCNT(s) -= 2;
    _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;
}

可以看到，源码前面还是做一些基本的检查。我们可以看一下37行和50行：将s添加到interned字典中时，其实s同时是key和value（这里我不太清楚为什么会这样做），所以s对应的引用计数是+2了的（具体可以看PyDict_SetDefault()的源码），所以在50行时会将计数-2，保证引用计数的正确。

考虑下面的场景：

>>> class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
>>> user = User('Tom', 21)
>>> user.__dict__
{'name': 'Tom', 'age': 21}

由于对象的属性由dict保存，这意味着每个User对象都要保存一个str对象‘name’，这会浪费大量的内存。而str是不可变对象，因此Python内部将有潜在重复可能的字符串都做成单例模式，这就是interned机制。Python具体做法就是在内部维护一个全局dict对象，所有开启interned机制的str对象均保存在这里，后续需要使用的时候，先创建，如果判断已经维护了相同的字符串，就会将新创建的这个对象回收掉。

示例：

由不同运算生成’abc’，最后都是同一个对象：

>>> a = 'abc'
>>> b = 'ab' + 'c'
>>> id(a), id(b), a is b
(2752416949872, 2752416949872, True)

以上是Python內建類型str原始碼分析的詳細內容。更多資訊請關注PHP中文網其他相關文章！