引言

“深入認(rèn)識Python內(nèi)建類型”這部分的內(nèi)容會從源碼角度為大家介紹Python中各種常用的內(nèi)建類型。

在介紹常用類型str之前，在上一篇博客：Python源碼學(xué)習(xí)筆記：深入認(rèn)識Python內(nèi)建類型——bytes已經(jīng)為大家介紹了和str息息相關(guān)的bytes的源碼知識。這篇博客回味大家分析str相關(guān)的源碼。

1 Unicode

計算機(jī)存儲的基本單位是字節(jié)，由8個比特位組成。由于英文只由26個字母加若干符號組成，因此英文字符可以直接用字節(jié)來保存。但是其他語言（例如中日韓等），由于字符眾多，不得不使用多個字節(jié)來進(jìn)行編碼。

隨著計算機(jī)技術(shù)的傳播，非拉丁文字符編碼技術(shù)不斷發(fā)展，但是仍然存在兩個比較大的局限性：

• 不支持多語言：一種語言的編碼方案不能用于另外一種語言
• 沒有統(tǒng)一標(biāo)準(zhǔn)：例如中文就有GBK、GB2312、GB18030等多種編碼標(biāo)準(zhǔn)

由于編碼方式不統(tǒng)一，開發(fā)人員就需要在不同編碼之間來回轉(zhuǎn)換，不可避免地會出現(xiàn)很多錯誤。為了解決這類不統(tǒng)一問題，Unicode標(biāo)準(zhǔn)被提出了。Unicode對世界上大部分文字系統(tǒng)進(jìn)行整理、編碼，讓計算機(jī)可以用統(tǒng)一的方式處理文本。Unicode目前已經(jīng)收錄了超過14萬個字符，天然地支持多語言。（Unicode的uni就是“統(tǒng)一”的詞根）

2 Python中的Unicode

2.1 Unicode對象的好處

Python在3之后，str對象內(nèi)部改用Unicode表示，因此在源碼中成為Unicode對象。使用Unicode表示的好處是：程序核心邏輯統(tǒng)一使用Unicode，只需在輸入、輸出層進(jìn)行解碼、編碼，可最大程度地避免各種編碼問題。

圖示如下：

2.2 Python對Unicode的優(yōu)化

問題：由于Unicode收錄字符已經(jīng)超過14萬個，每個字符至少需要4個字節(jié)來保存（這里應(yīng)該是因為2個字節(jié)不夠，所以才用4個字節(jié)，一般不會使用3個字節(jié)）。而英文字符用ASCII碼表示僅需要1個字節(jié)，使用Unicode反而會使頻繁使用的英文字符的開銷變?yōu)樵瓉淼?倍。

首先我們來看一下Python中不同形式的str對象的大小差異：

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

由此可見，Python內(nèi)部對Unicode對象進(jìn)行了優(yōu)化：根據(jù)文本內(nèi)容，選擇底層存儲單元。

Unicode對象底層存儲根據(jù)文本字符的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

對應(yīng)枚舉如下：

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

根據(jù)不同的分類，選擇不同的存儲單元：

/* 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;

對應(yīng)關(guān)系如下：

由于Unicode內(nèi)部存儲結(jié)構(gòu)因文本類型而異，因此類型kind必須作為Unicode對象公共字段進(jìn)行保存。Python內(nèi)部定義了一些標(biāo)志位，作為Unicode公共字段：（介于筆者水平有限，這里的字段在后續(xù)內(nèi)容中不會全部介紹，大家后續(xù)可以自行了解。抱拳~）

• interned：是否為interned機(jī)制維護(hù)
• kind：類型，用于區(qū)分字符底層存儲單元大小
• compact：內(nèi)存分配方式，對象與文本緩沖區(qū)是否分離
• asscii：文本是否均為純ASCII

通過PyUnicode_New函數(shù)，根據(jù)文本字符數(shù)size以及最大字符maxchar初始化Unicode對象。該函數(shù)主要是根據(jù)maxchar為Unicode對象選擇最緊湊的字符存儲單元以及底層結(jié)構(gòu)體：（源碼比較長，這里就不列出了，大家可以自行了解，下面以表格形式展現(xiàn)）

3 Unicode對象的底層結(jié)構(gòu)體

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對象標(biāo)志位

wstr：緩存C字符串的一個wchar_t指針，以“\0”結(jié)束（這里和我看的另一篇文章講得不太一樣，另一個描述是：ASCII文本緊接著位于PyASCIIObject結(jié)構(gòu)體后面，我個人覺得現(xiàn)在的這種說法比較準(zhǔn)確，畢竟源碼結(jié)構(gòu)體后面沒有別的字段了）

圖示如下：

（注意這里state字段后面有一個4字節(jié)大小的空洞，這是結(jié)構(gòu)體字段內(nèi)存對齊造成的現(xiàn)象，主要是為了優(yōu)化內(nèi)存訪問效率）

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

3.2 PyCompactUnicodeObject

如果文本不全是ASCII，Unicode對象底層便由PyCompactUnicodeObject結(jié)構(gòu)體保存。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的基礎(chǔ)上增加了3個字段：

utf8_length：文本UTF8編碼長度

utf8：文本UTF8編碼形式，緩存以避免重復(fù)編碼運(yùn)算

wstr_length：wstr的“長度”（這里所謂的長度沒有找到很準(zhǔn)確的說法，筆者也不太清楚怎么能打印出來，大家可以自行研究下）

注意到，PyASCIIObject中并沒有保存UTF8編碼形式，這是因為ASCII本身就是合法的UTF8，這也是ASCII文本底層由PyASCIIObject保存的原因。

結(jié)構(gòu)圖示：

3.3 PyUnicodeObject

PyUnicodeObject則是Python中str對象的具體實現(xiàn)。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 示例

在日常開發(fā)時，要結(jié)合實際情況注意字符串拼接前后的內(nèi)存大小差別：

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

4 interned機(jī)制

如果str對象的interned標(biāo)志位為1，Python虛擬機(jī)將為其開啟interned機(jī)制，

源碼如下：（相關(guān)信息在網(wǎng)上可以看到很多說法和解釋，這里筆者能力有限，暫時沒有找到最確切的答案，之后補(bǔ)充。抱拳~但是我們通過分析源碼應(yīng)該是能看出一些門道的）

/* 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對應(yīng)的引用計數(shù)是+2了的（具體可以看PyDict_SetDefault()的源碼），所以在50行時會將計數(shù)-2，保證引用計數(shù)的正確。

考慮下面的場景：

>>> 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’，這會浪費(fèi)大量的內(nèi)存。而str是不可變對象，因此Python內(nèi)部將有潛在重復(fù)可能的字符串都做成單例模式，這就是interned機(jī)制。Python具體做法就是在內(nèi)部維護(hù)一個全局dict對象，所有開啟interned機(jī)制的str對象均保存在這里，后續(xù)需要使用的時候，先創(chuàng)建，如果判斷已經(jīng)維護(hù)了相同的字符串，就會將新創(chuàng)建的這個對象回收掉。

示例：

由不同運(yùn)算生成’abc’，最后都是同一個對象：

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

5 總結(jié)

個人反思：在寫這篇博客時查閱了很多資料，看到了很多已有的但是不同的說法，在整理學(xué)習(xí)的時候感覺有些吃力，不過盡可能地沒有直接輸出不確切的觀點(diǎn)，而是基于真正的源碼來為大家分析。并且str的相關(guān)內(nèi)容應(yīng)該是目前為止內(nèi)建類型中最多最雜的，后續(xù)會補(bǔ)充的list和dict的相關(guān)內(nèi)容都比它要清晰明確，當(dāng)然其中最大的問題肯定還是筆者的能力。博客中應(yīng)該還是有錯誤和不足的地方，但盡量對源碼部分的解釋做到準(zhǔn)確。目前筆者能力有限，今后進(jìn)步之后再對該篇博客中錯誤和不足的地方進(jìn)行修正補(bǔ)充。抱拳~

以上就是Python內(nèi)建類型str源碼學(xué)習(xí)的詳細(xì)內(nèi)容，更多關(guān)于Python內(nèi)建類型str的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論