在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代碼細節。

更新中.....

總結

以上是生活随笔為你收集整理的python cpython关系_第3篇:CPython内部探究:PyASCIIObject的初始化的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。