本文介紹了 python 內部是如何管理字串物件，以及字串查詢操作是如何實現的。
PyStringObject 結構體
Python 中的字串物件在內部對應一個名叫 PyStringObject 的結構體。“ob_shash” 對應字串經計算過的 hash值， “ob_sval” 指向一段長度為 “ob_size” 的字串，且該字串以‘null’結尾（為了相容C）。“ob_sval”的初始大小為1個位元組，且 ob_sval[0]=0（對應空字串）。若你還想知道“ob_size”被定義的位置，可以看一看 object.h 標頭檔案中 PyObject_VAR_HEAD 對應部分。“ob_sstate” 用來指示某個字串是否已經存在於intern機制對應的字典中，後面我們會再次提到這一點。
|
1 2 3 4 5 6 |
typedef struct { PyObject_VAR_HEAD long ob_shash; int ob_sstate; char ob_sval[1]; } PyStringObject; |
字串物件的建立
如下所示，當將一個新的字串賦給一個變數時，發生了什麼？
|
1 |
1>>> s1 = 'abc' |
執行以上程式碼時，內部的 C 函式 “PyString_FromString” 將被呼叫並生成類似下面的虛擬碼：
|
1 2 3 4 5 6 7 |
arguments: string object: 'abc' returns: Python string object with ob_sval = 'abc' PyString_FromString(string): size = length of string allocate string object + size for 'abc'. ob_sval will be of size: size + 1 copy string to ob_sval return object |
每次用到新的字串時，都將分配一個字串物件。
共享字串物件
Python 有一個優雅的特性，就是變數之間的短字串是共享的，這一特性可以節省所需的記憶體空間。短字串就是那些長度為 0 個或者 1 個位元組的字串。而全域性變數 “interned” 對應一個用於索引這些短字串的字典。陣列 “characters” 也可用於索引那些長度為 1 個位元組的字串，比如單個字母。後面我們將看到陣列 “characters” 是如何被使用的。
|
1 2 |
static PyStringObject *characters[UCHAR_MAX + 1]; static PyObject *interned; |
下面一起看看：當你在 Python 指令碼中將一個短字串賦值給一個變數時，背後發生了哪些事情。
|
1 2 |
static PyStringObject *characters[UCHAR_MAX + 1]; static PyObject *interned; |
內容為 ‘a’ 的字串物件將被新增到 “interned” 字典中。字典中鍵（key）是一個指向該字串物件的指標，而對應的值 就是一個相同的指標。在陣列 “characters” 中，這一新的字串物件在偏移量為 97 的位置被引用，因為字元 ‘a’ 的ASCII碼值便是 97。變數 “s2” 也指向了這一字串物件。
而，當另外一個變數也被相同的字串 ‘a’ 賦值時，又會如何呢？
|
1 |
1>>> s3 = 'a' |
上述程式碼執行後，將返回之前已建立的內容相同的字串物件。因此，‘s1’ 和 ‘s3’ 兩個變數都將指向同一個字串物件。 陣列 “characters” 便是用於檢測字串 ‘a’ 是否已經存在，若存在，則返回指向該字串物件的指標。
|
1 2 3 4 5 |
if (size == 1 && (op = characters[*str & UCHAR_MAX]) != NULL) { ... return (PyObject *)op; } |
下面我們新建一個內容為 ‘c’ 的短字串：
|
1 |
1>>> s4 = 'c' |
那麼，我們將得到如下結果：
我們還能發現，當按照下面 Python 指令碼中的方式對一個字串元素進行訪問時，陣列 “characters” 仍有用武之地。
|
1 2 3 |
>>> s5 = 'abc' >>> s5[0] 'a' |
上面第二行程式碼中，返回的是陣列 “characters” 偏移量為 97 的位置內的指標元素，而非新建一個值為 ‘a’的字串。當我們訪問某個字串中的元素時，一個名叫 “string_item” d的函式將被呼叫，下方給出了函式體程式碼。其中，引數 ‘a’ 便對應著字串 “abc”，而引數 ‘i’ 便是訪問陣列的索引值（本例中便為 0 ），函式返回的是指向某個字串物件的指標。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
static PyObject * string_item(PyStringObject *a, register Py_ssize_t i) { char pchar; PyObject *v; ... pchar = a->ob_sval[i]; v = (PyObject *)characters[pchar & UCHAR_MAX]; if (v == NULL) // allocate string else { ... Py_INCREF(v); } return v; } |
陣列 “characters” 也可用於函式名長度為 1 時的情形，如下所示：
|
1 |
>>> def a(): pass |
字串查詢
下面看看，當你在如下 Python 程式碼中進行字串查詢操作時，又會有那些事情發生呢？
|
1 2 3 |
>>> s = 'adcabcdbdabcabd' >>> s.find('abcab') >>> 11 |
函式 “find” 返回一個索引值，說明是在字串 “abcd” 的哪個位置找到字串 “s” 的。若字串未找到，函式返回值為 -1。
那麼，內部到底幹了些啥事情？內部呼叫了一個名為 “fastsearch” 的函式。這個函式是一個介於 BoyerMoore 和 Horspool 演算法之間的混合版本，它兼具兩者的優良特性。
我們將 “s”（s = ‘adcabcdbdabcabd’）稱作主字串，而將 “p”（p = ‘abcab’）稱作模式串。n 和 m 分別表示字串 s 和 字串 p 的長度，其中，n = 15, m = 5。
在如下程式碼段中，明顯看到，程式將進行首次判定：若 m > n,我們就知道必然不能找到這樣的索引號，因此函式直接返回 -1 即可。
|
1 2 3 |
w = n - m; if (w < 0) return -1; |
當 m = 1 時，程式便在字串 s 中一個個字元地進行遍歷，若匹配成功則返回對應的索引位置。在本例中，變數 mode 值為 FAST_SEARCH，意味著我們想獲取的是在主字串中首次匹配的位置，而非模式串在主字串中成功匹配的次數。
|
1 2 3 4 5 6 7 8 9 10 11 |
if (m <= 1) { ... if (mode == FAST_COUNT) { ... } else { for (i = 0; i < n; i++) if (s[i] == p[0]) return i; } return -1; } |
考慮其他情況，比如 m > 1。首先建立一個壓縮的boyer-moore delta 1 table（對應BM演算法中的壞字元規則）,在此過程中需要宣告兩個變數：“mask” 和 “skip”。
“mask” 是一個 32 位的位掩碼（bitmask），將其最低的 5 個特徵位作為開關位。該掩碼是通過和模式串 “p” 進行操作產生的。它設計成一個布隆過濾器（bloom filter），用於檢測一個字元是否出現在當前字串中。這種機制使查詢操作十分迅速，但是存在偽正的情況（false positives）。關於布隆過濾器，你想有更多瞭解的話可以看看 這裡 。對於本例，下方說明了位掩碼具體是如何產生的。
|
1 2 3 4 5 6 7 |
mlast = m - 1 /* process pattern[:-1] */ for (mask = i = 0; i < mlast; i++) { mask |= (1 << (p[i] & 0x1F)); } /* process pattern[-1] outside the loop */ mask |= (1 << (p[mlast] & 0x1F)); |
字串 “p” 的第一個字元為 ‘a’。字元‘a’的二進位制表示為 97 = 1100001。保留最低的 5 個特徵位，我們得到了 00001，因此變 “mask” 初次被設定為 10（1 << 1）。當整個字串 “p” 都經過處理後，mask 值為 1110。那麼，我們應該如何使用這個位掩碼呢？通過下方這行程式碼，我們用其來檢測字元 “c” 位於字串 “p” 哪個位置。
|
1 |
if ((mask & (1 << (c & 0x1F)))) |
那麼，字元 ‘a’ 在字串 “p”（‘abcab’）中是否存在呢？1110 & (1 << (‘a’ & 0X1F)) 運算結果的值是否為 true 呢？由於 1110 & (1 << (‘a’ & 0X1F)) = 1110 & 10 = 10，可知 ‘a’ 確實存在於 ‘abcab’。當檢測字元 ‘d’時，我們得到的是 false，對於其他字元（從 ‘e’ 到 ‘z’）也是同樣結果。因此，在本例中此類過濾器表現十分出眾。 變數 “skip” 對應目標字元在主字串中最後一個成功匹配的字元的索引位置（從後向前匹配）。假若模式串的最後一個匹配字元在主字串中不存在，則 “skip” 值為 模式串 “p” 的長度減去 1。本例中，模式串最後一個為匹配字元位 ‘b’,由於其在主串查詢的當前位置向後跳兩個字元後能夠匹配到，因此變數 “skip” 的值為2。這個變數應用於一種名叫壞字元跳躍（bad-character skip）的規則。在如下示例中，p = ‘abcab’，s = ‘adcabcaba’。從主串 “s” 的 4 號索引位置（從 0 開始計算）開始匹配，若字元匹配成功則向前繼續匹配。第一個匹配失敗的索引位置為 1（此處 ‘b’ 不等於 ‘d’）。我們可以看到，在模式串和主串最開始匹配的末端位置往後數三個字元，主串中也有一個 ‘b’,而字元 ‘c’ 也存在於 “p” 中，因此我們跳過了隨後的 ‘b’。
下面，看下查詢操作的迴圈部分（真實程式碼為 C 實現，而非 Python）：
|
1 2 3 4 5 6 7 8 9 10 11 12 |
for i = 0 to n - m = 13: if s[i+m-1] == p[m-1]: if s[i:i+mlast] == p[0:mlast]: return i if s[i+m] not in p: i += m else: i += skip else: if s[i+m] not in p: i += m return -1 |
“s[i+m] not in p” 這行測試程式碼是基於位掩碼實現的，“i += skip” 便對應壞字元跳躍。當主串下一個待匹配的字元在 “p” 中並未找到時，則執行 “i += m” 這行程式碼。
下面來看看，對於字串 “p” 和 “s” 的匹配，演算法具體是如何執行的。前三個步驟與上面類似，接著，字元 ‘d’ 在字串 “p” 並未找到，因此我們直接跳過等於“p”字串長度的字元數，之後便迅速找到了一個匹配。
有關Python字串物件完整的程式碼實現， 去這裡看看 。