App下載

什么是python字符串駐留技術(shù)?詳解python字符串駐留!

猿友 2021-07-22 10:09:17 瀏覽數(shù) (2099)
反饋

前言

每種編程語言為了表現(xiàn)出色,并且實(shí)現(xiàn)卓越的性能,都需要有大量編譯器級與解釋器級的優(yōu)化。

由于字符串是任何編程語言中不可或缺的一個部分,因此,如果有快速操作字符串的能力,就可以迅速地提高整體的性能。

在本文中,我們將深入研究 Python 的內(nèi)部實(shí)現(xiàn),并了解 Python 如何使用一種名為字符串駐留(String Interning)的技術(shù),實(shí)現(xiàn)解釋器的高性能。本文的目的不僅在于介紹 Python 的內(nèi)部知識,而且還旨在使讀者能夠輕松地瀏覽 Python 的源代碼;因此,本文中將有很多出自CPython的代碼片段。

全文提綱如下:

字符串駐留

1、什么是“字符串駐留”?

字符串駐留是一種編譯器/解釋器的優(yōu)化方法,它通過緩存一般性的字符串,從而節(jié)省字符串處理任務(wù)的空間和時間。

這種優(yōu)化方法不會每次都創(chuàng)建一個新的字符串副本,而是僅為每個適當(dāng)?shù)牟豢勺冎当A粢粋€字符串副本,并使用指針引用之。每個字符串的唯一拷貝被稱為它的intern,并因此而得名 String Interning。

String Interning 一般被譯為“字符串駐留”或“字符串留用”,在某些語言中可能習(xí)慣用 String Pool(字符串常量池)的概念,其實(shí)是對同一種機(jī)制的不同表述。intern 作為名詞時,是“實(shí)習(xí)生、實(shí)習(xí)醫(yī)生”的意思,在此可以理解成“駐留物、駐留值”。

查找字符串 intern 的方法可能作為公開接口公開,也可能不公開?,F(xiàn)代編程語言如 Java、Python、PHP、Ruby、Julia 等等,都支持字符串駐留,以使其編譯器和解釋器做到高性能。

字符串駐留原理

2、為什么要駐留字符串?

字符串駐留提升了字符串比較的速度。如果沒有駐留,當(dāng)我們要比較兩個字符串是否相等時,它的時間復(fù)雜度將上升到 O(n),即需要檢查兩個字符串中的每個字符,才能判斷出它們是否相等。

但是,如果字符串是固定的,由于相同的字符串將使用同一個對象引用,因此只需檢查指針是否相同,就足以判斷出兩個字符串是否相等,不必再逐一檢查每個字符。由于這是一個非常普遍的操作,因此,它被典型地實(shí)現(xiàn)為指針相等性校驗(yàn),僅使用一條完全沒有內(nèi)存引用的機(jī)器指令。

字符串駐留減少了內(nèi)存占用。Python 避免內(nèi)存中充斥多余的字符串對象,通過享元設(shè)計模式共享和重用已經(jīng)定義的對象,從而優(yōu)化內(nèi)存占用。

3、Python的字符串駐留

像大多數(shù)其它現(xiàn)代編程語言一樣,Python 也使用字符串駐留來提高性能。在 Python 中,我們可以使用is運(yùn)算符,檢查兩個對象是否引用了同一個內(nèi)存對象。

因此,如果兩個字符串對象引用了相同的內(nèi)存對象,則is運(yùn)算符將得出True,否則為False。

 >>> 'python' is 'python'

  True

我們可以使用這個特定的運(yùn)算符,來判斷哪些字符串是被駐留的。在 CPython 的,字符串駐留是通過以下函數(shù)實(shí)現(xiàn)的,聲明在 unicodeobject.h 中,定義在 unicodeobject.c 中。

PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **);

為了檢查一個字符串是否被駐留,CPython 實(shí)現(xiàn)了一個名為PyUnicode_CHECK_INTERNED的宏,同樣是定義在 unicodeobject.h 中。

這個宏表明了 Python 在PyASCIIObject結(jié)構(gòu)中維護(hù)著一個名為interned的成員變量,它的值表示相應(yīng)的字符串是否被駐留。

#define PyUnicode_CHECK_INTERNED(op) 
      (((PyASCIIObject *)(op))->state.interned)

4、字符串駐留的原理

在 CPython 中,字符串的引用被一個名為interned的 Python 字典所存儲、訪問和管理。 該字典在第一次調(diào)用字符串駐留時,被延遲地初始化,并持有全部已駐留字符串對象的引用。

4.1 如何駐留字符串?

負(fù)責(zé)駐留字符串的核心函數(shù)是PyUnicode_InternInPlace,它定義在 unicodeobject.c 中,當(dāng)調(diào)用時,它會創(chuàng)建一個準(zhǔn)備容納所有駐留的字符串的字典interned,然后登記入?yún)⒅械膶ο?,令其鍵和值都使用相同的對象引用。

以下函數(shù)片段顯示了 Python 實(shí)現(xiàn)字符串駐留的過程。

void
  PyUnicode_InternInPlace(PyObject **p)
  {
      PyObject *s = *p;
  ?
      .........
  ?
      // Lazily build the dictionary to hold interned Strings
      if (interned == NULL) {
          interned = PyDict_New();
          if (interned == NULL) {
              PyErr_Clear();
              return;
          }
      }
  ?
      PyObject *t;
  ?
      // Make an entry to the interned dictionary for the
      // given object
      t = PyDict_SetDefault(interned, s, s);
  ?
      .........
 
      // The two references in interned dict (key and value) are
      // not counted by refcnt.
      // unicode_dealloc() and _PyUnicode_ClearInterned() take
      // care of this.
      Py_SET_REFCNT(s, Py_REFCNT(s) - 2);
  ?
      // Set the state of the string to be INTERNED
      _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;
  }

4.2 如何清理駐留的字符串?

清理函數(shù)從interned字典中遍歷所有的字符串,調(diào)整這些對象的引用計數(shù),并把它們標(biāo)記為NOT_INTERNED,使其被垃圾回收。一旦所有的字符串都被標(biāo)記為NOT_INTERNED,則interned字典會被清空并刪除。

這個清理函數(shù)就是_PyUnicode_ClearInterned,在unicodeobject.c 中定義。

void
  _PyUnicode_ClearInterned(PyThreadState *tstate)
  {
      .........
  ?
      // Get all the keys to the interned dictionary
      PyObject *keys = PyDict_Keys(interned);
  ?
      .........
  ?
      // Interned Unicode strings are not forcibly deallocated;
      // rather, we give them their stolen references back
      // and then clear and DECREF the interned dict.
  ?
      for (Py_ssize_t i = 0; i < n; i++) {
          PyObject *s = PyList_GET_ITEM(keys, i);
  ?
          .........
  ?
          switch (PyUnicode_CHECK_INTERNED(s)) {
          case SSTATE_INTERNED_IMMORTAL:
              Py_SET_REFCNT(s, Py_REFCNT(s) + 1);
              break;
          case SSTATE_INTERNED_MORTAL:
              // Restore the two references (key and value) ignored
              // by PyUnicode_InternInPlace().
              Py_SET_REFCNT(s, Py_REFCNT(s) + 2);
              break;
          case SSTATE_NOT_INTERNED:
              /* fall through */
          default:
              Py_UNREACHABLE();
          }
  ?
          // marking the string to be NOT_INTERNED
          _PyUnicode_STATE(s).interned = SSTATE_NOT_INTERNED;
      }
  ?
      // decreasing the reference to the initialized and
      // access keys object.
      Py_DECREF(keys);
  ?
      // clearing the dictionary
      PyDict_Clear(interned);
  ?
      // clearing the object interned
      Py_CLEAR(interned);
  }

5、字符串駐留的實(shí)現(xiàn)

既然了解了字符串駐留及清理的內(nèi)部原理,我們就可以找出 Python 中所有會被駐留的字符串。

為了做到這點(diǎn),我們要做的就是在 CPython 源代碼中查找PyUnicode_InternInPlace 函數(shù)的調(diào)用,并查看其附近的代碼。下面是在 Python 中關(guān)于字符串駐留的一些有趣的發(fā)現(xiàn)。

5.1 變量、常量與函數(shù)名

CPython 對常量(例如函數(shù)名、變量名、字符串字面量等)執(zhí)行字符串駐留。

以下代碼出自codeobject.c,它表明在創(chuàng)建新的PyCode對象時,解釋器將對所有編譯期的常量、名稱和字面量進(jìn)行駐留。

PyCodeObject *
  PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,
                            int nlocals, int stacksize, int flags,
                            PyObject *code, PyObject *consts, PyObject *names,
                            PyObject *varnames, PyObject *freevars, PyObject *cellvars,
                            PyObject *filename, PyObject *name, int firstlineno,
                            PyObject *linetable)
  {
  ?
      ........
  ?
      if (intern_strings(names) < 0) {
          return NULL;
      }
  ?
      if (intern_strings(varnames) < 0) {
          return NULL;
      }
  ?
      if (intern_strings(freevars) < 0) {
          return NULL;
      }
  ?
      if (intern_strings(cellvars) < 0) {
          return NULL;
      }
  ?
      if (intern_string_constants(consts, NULL) < 0) {
          return NULL;
      }
  ?
      ........
  ?
  }

5.2 字典的鍵

CPython 還會駐留任何字典對象的字符串鍵。

當(dāng)在字典中插入元素時,解釋器會對該元素的鍵作字符串駐留。以下代碼出自dictobject.c,展示了實(shí)際的行為。

有趣的地方:在PyUnicode_InternInPlace函數(shù)被調(diào)用處有一條注釋,它問道,我們是否真的需要對所有字典中的全部鍵進(jìn)行駐留?

int
  PyDict_SetItemString(PyObject *v, const char *key, PyObject *item)
  {
      PyObject *kv;
      int err;
      kv = PyUnicode_FromString(key);
      if (kv == NULL)
          return -1;
  ?
      // Invoking String Interning on the key
      PyUnicode_InternInPlace(&kv); /* XXX Should we really? */
  ?
      err = PyDict_SetItem(v, kv, item);
      Py_DECREF(kv);
      return err;
  }

5.3 任何對象的屬性

Python 中對象的屬性可以通過setattr函數(shù)顯式地設(shè)置,也可以作為類成員的一部分而隱式地設(shè)置,或者在其數(shù)據(jù)類型中預(yù)定義。

CPython 會駐留所有這些屬性名,以便實(shí)現(xiàn)快速查找。以下是函數(shù)PyObject_SetAttr的代碼片段,該函數(shù)定義在文件object.c中,負(fù)責(zé)為 Python 對象設(shè)置新屬性。

int
  PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value)
  {
  ?
      ........
  ?
      PyUnicode_InternInPlace(&name);
  ?
      ........
  }

5.4 顯式地駐留

Python 還支持通過sys模塊中的intern函數(shù)進(jìn)行顯式地字符串駐留。

當(dāng)使用任何字符串對象調(diào)用此函數(shù)時,該字符串對象將被駐留。以下是sysmodule.c文件的代碼片段,它展示了在sys_intern_impl函數(shù)中的字符串駐留過程。

static PyObject *
  sys_intern_impl(PyObject *module, PyObject *s)
  {
  ?
      ........
  ?
      if (PyUnicode_CheckExact(s)) {
          Py_INCREF(s);
          PyUnicode_InternInPlace(&s);
          return s;
      }
  ?
      ........
  }

6、字符串駐留的其它發(fā)現(xiàn)

只有編譯期的字符串會被駐留。在解釋時或編譯時指定的字符串會被駐留,而動態(tài)創(chuàng)建的字符串則不會。

Python貓注:這一條規(guī)則值得展開思考,我曾經(jīng)在上面踩過坑……有兩個知識點(diǎn),我相信 99% 的人都不知道:字符串的 join() 方法是動態(tài)創(chuàng)建字符串,因此其創(chuàng)建的字符串不會被駐留;常量折疊機(jī)制也發(fā)生在編譯期,因此有時候容易把它跟字符串駐留搞混淆。推薦閱讀《join()方法的神奇用處與Intern機(jī)制的軟肋》

包含 ASCII 字符和下劃線的字符串會被駐留。在編譯期間,當(dāng)對字符串字面量進(jìn)行駐留時,CPython確保僅對匹配正則表達(dá)式[a-zA-Z0-9_]*的常量進(jìn)行駐留,因?yàn)樗鼈兎浅YN近于 Python 的標(biāo)識符。

注:關(guān)于 Python 中標(biāo)識符的命名規(guī)則,在 Python2 版本只有“字母、數(shù)字和下劃線”,但在 Python 3.x 版本中,已經(jīng)支持 Unicode 編碼。這部分內(nèi)容推薦閱讀《醒醒!Python已經(jīng)支持中文變量名啦!》

小結(jié)

以上就是字符串駐留是什么的詳細(xì)介紹,更多python相關(guān)的學(xué)習(xí)資料請關(guān)注W3Cschool其它相關(guān)文章!


0 人點(diǎn)贊