文章详情

登录

短信预约-IT技能 免费直播动态提醒

选择考试省份

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团

请输入下面的图形验证码

提交验证

短信预约提醒成功

深入 Python 解释器源码，我终于搞明白了字符串驻留的原理！

2024-12-03 11:26

关注

每种编程语言为了表现出色，并且实现卓越的性能，都需要有大量编译器级与解释器级的优化。

由于字符串是任何编程语言中不可或缺的一个部分，因此，如果有快速操作字符串的能力，就可以迅速地提高整体的性能。

在本文中，我们将深入研究 Python 的内部实现，并了解 Python 如何使用一种名为字符串驻留(String Interning)的技术，实现解释器的高性能。 本文的目的不仅在于介绍 Python 的内部知识，而且还旨在使读者能够轻松地浏览 Python 的源代码;因此，本文中将有很多出自 CPython 的代码片段。

全文提纲如下：

 

(在 Python猫 公众号回复数字“0215”，下载思维导图)

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

字符串驻留是一种编译器/解释器的优化方法，它通过缓存一般性的字符串，从而节省字符串处理任务的空间和时间。

这种优化方法不会每次都创建一个新的字符串副本，而是仅为每个适当的不可变值保留一个字符串副本，并使用指针引用之。

每个字符串的唯一拷贝被称为它的intern，并因此而得名 String Interning。

Python猫注：String Interning 一般被译为“字符串驻留”或“字符串留用”，在某些语言中可能习惯用 String Pool(字符串常量池)的概念，其实是对同一种机制的不同表述。intern 作为名词时，是“实习生、实习医生”的意思，在此可以理解成“驻留物、驻留值”。

查找字符串 intern 的方法可能作为公开接口公开，也可能不公开。现代编程语言如 Java、Python、PHP、Ruby、Julia 等等，都支持字符串驻留，以使其编译器和解释器做到高性能。

 

2、为什么要驻留字符串?

字符串驻留提升了字符串比较的速度。 如果没有驻留，当我们要比较两个字符串是否相等时，它的时间复杂度将上升到 O(n)，即需要检查两个字符串中的每个字符，才能判断出它们是否相等。

但是，如果字符串是固定的，由于相同的字符串将使用同一个对象引用，因此只需检查指针是否相同，就足以判断出两个字符串是否相等，不必再逐一检查每个字符。由于这是一个非常普遍的操作，因此，它被典型地实现为指针相等性校验，仅使用一条完全没有内存引用的机器指令。

字符串驻留减少了内存占用。 Python 避免内存中充斥多余的字符串对象，通过享元设计模式共享和重用已经定义的对象，从而优化内存占用。

3、Python的字符串驻留

像大多数其它现代编程语言一样，Python 也使用字符串驻留来提高性能。在 Python 中，我们可以使用is运算符，检查两个对象是否引用了同一个内存对象。

因此，如果两个字符串对象引用了相同的内存对象，则is运算符将得出True，否则为False。

  1. >>> 'python' is 'python' 
  2. True 

我们可以使用这个特定的运算符，来判断哪些字符串是被驻留的。在 CPython 的，字符串驻留是通过以下函数实现的，声明在 unicodeobject.h 中，定义在 unicodeobject.c 中。

  1. PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **); 

为了检查一个字符串是否被驻留，CPython 实现了一个名为PyUnicode_CHECK_INTERNED的宏，同样是定义在 unicodeobject.h 中。

这个宏表明了 Python 在PyASCIIObject结构中维护着一个名为interned的成员变量，它的值表示相应的字符串是否被驻留。

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

4、字符串驻留的原理

在 CPython 中，字符串的引用被一个名为interned的 Python 字典所存储、访问和管理。 该字典在第一次调用字符串驻留时，被延迟地初始化，并持有全部已驻留字符串对象的引用。

4.1 如何驻留字符串?

负责驻留字符串的核心函数是PyUnicode_InternInPlace，它定义在 unicodeobject.c 中，当调用时，它会创建一个准备容纳所有驻留的字符串的字典interned，然后登记入参中的对象，令其键和值都使用相同的对象引用。

以下函数片段显示了 Python 实现字符串驻留的过程。

  1. void 
  2. PyUnicode_InternInPlace(PyObject **p) 
  3. { 
  4.     PyObject *s = *p; 
  5.  
  6.     ......... 
  7.  
  8.     // Lazily build the dictionary to hold interned Strings 
  9.     if (interned == NULL) { 
  10.         interned = PyDict_New(); 
  11.         if (interned == NULL) { 
  12.             PyErr_Clear(); 
  13.             return; 
  14.         } 
  15.     } 
  16.  
  17.     PyObject *t; 
  18.  
  19.     // Make an entry to the interned dictionary for the 
  20.     // given object 
  21.     t = PyDict_SetDefault(interned, s, s); 
  22.  
  23.     ......... 
  24.      
  25.     // The two references in interned dict (key and value) are 
  26.     // not counted by refcnt. 
  27.     // unicode_dealloc() and _PyUnicode_ClearInterned() take 
  28.     // care of this. 
  29.     Py_SET_REFCNT(s, Py_REFCNT(s) - 2); 
  30.  
  31.     // Set the state of the string to be INTERNED 
  32.     _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL; 
  33. } 

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

清理函数从interned字典中遍历所有的字符串，调整这些对象的引用计数，并把它们标记为NOT_INTERNED，使其被垃圾回收。一旦所有的字符串都被标记为NOT_INTERNED，则interned字典会被清空并删除。

这个清理函数就是_PyUnicode_ClearInterned，在 unicodeobject.c 中定义。

  1. void 
  2. _PyUnicode_ClearInterned(PyThreadState *tstate) 
  3. { 
  4.     ......... 
  5.  
  6.     // Get all the keys to the interned dictionary 
  7.     PyObject *keys = PyDict_Keys(interned); 
  8.  
  9.     ......... 
  10.  
  11.     // Interned Unicode strings are not forcibly deallocated; 
  12.     // rather, we give them their stolen references back 
  13.     // and then clear and DECREF the interned dict. 
  14.  
  15.     for (Py_ssize_t i = 0; i < n; i++) { 
  16.         PyObject *s = PyList_GET_ITEM(keys, i); 
  17.  
  18.         ......... 
  19.  
  20.         switch (PyUnicode_CHECK_INTERNED(s)) { 
  21.         case SSTATE_INTERNED_IMMORTAL: 
  22.             Py_SET_REFCNT(s, Py_REFCNT(s) + 1); 
  23.             break; 
  24.         case SSTATE_INTERNED_MORTAL: 
  25.             // Restore the two references (key and value) ignored 
  26.             // by PyUnicode_InternInPlace(). 
  27.             Py_SET_REFCNT(s, Py_REFCNT(s) + 2); 
  28.             break; 
  29.         case SSTATE_NOT_INTERNED: 
  30.              
  31.         default: 
  32.             Py_UNREACHABLE(); 
  33.         } 
  34.  
  35.         // marking the string to be NOT_INTERNED 
  36.         _PyUnicode_STATE(s).interned = SSTATE_NOT_INTERNED; 
  37.     } 
  38.  
  39.     // decreasing the reference to the initialized and 
  40.     // access keys object. 
  41.     Py_DECREF(keys); 
  42.  
  43.     // clearing the dictionary 
  44.     PyDict_Clear(interned); 
  45.  
  46.     // clearing the object interned 
  47.     Py_CLEAR(interned); 
  48. } 

5、字符串驻留的实现

既然了解了字符串驻留及清理的内部原理，我们就可以找出 Python 中所有会被驻留的字符串。

为了做到这点，我们要做的就是在 CPython 源代码中查找PyUnicode_InternInPlace 函数的调用，并查看其附近的代码。下面是在 Python 中关于字符串驻留的一些有趣的发现。

5.1 变量、常量与函数名

CPython 对常量(例如函数名、变量名、字符串字面量等)执行字符串驻留。

以下代码出自codeobject.c，它表明在创建新的PyCode对象时，解释器将对所有编译期的常量、名称和字面量进行驻留。

  1. PyCodeObject * 
  2. PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount, 
  3.                           int nlocals, int stacksize, int flags, 
  4.                           PyObject *code, PyObject *consts, PyObject *names, 
  5.                           PyObject *varnames, PyObject *freevars, PyObject *cellvars, 
  6.                           PyObject *filename, PyObject *name, int firstlineno, 
  7.                           PyObject *linetable) 
  8. { 
  9.  
  10.     ........ 
  11.  
  12.     if (intern_strings(names) < 0) { 
  13.         return NULL; 
  14.     } 
  15.  
  16.     if (intern_strings(varnames) < 0) { 
  17.         return NULL; 
  18.     } 
  19.  
  20.     if (intern_strings(freevars) < 0) { 
  21.         return NULL; 
  22.     } 
  23.  
  24.     if (intern_strings(cellvars) < 0) { 
  25.         return NULL; 
  26.     } 
  27.  
  28.     if (intern_string_constants(consts, NULL) < 0) { 
  29.         return NULL; 
  30.     } 
  31.  
  32.     ........ 
  33.  
  34. } 

5.2 字典的键

CPython 还会驻留任何字典对象的字符串键。

当在字典中插入元素时，解释器会对该元素的键作字符串驻留。以下代码出自 dictobject.c，展示了实际的行为。

有趣的地方：在PyUnicode_InternInPlace函数被调用处有一条注释，它问道，我们是否真的需要对所有字典中的全部键进行驻留?

  1. int 
  2. PyDict_SetItemString(PyObject *v, const char *key, PyObject *item) 
  3. { 
  4.     PyObject *kv; 
  5.     int err; 
  6.     kv = PyUnicode_FromString(key); 
  7.     if (kv == NULL) 
  8.         return -1; 
  9.  
  10.     // Invoking String Interning on the key 
  11.     PyUnicode_InternInPlace(&kv);  
  12.  
  13.     err = PyDict_SetItem(v, kv, item); 
  14.     Py_DECREF(kv); 
  15.     return err; 
  16. } 

5.3 任何对象的属性

Python 中对象的属性可以通过setattr函数显式地设置，也可以作为类成员的一部分而隐式地设置，或者在其数据类型中预定义。

CPython 会驻留所有这些属性名，以便实现快速查找。 以下是函数PyObject_SetAttr的代码片段，该函数定义在文件object.c中，负责为 Python 对象设置新属性。

  1. int 
  2. PyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value) 
  3. { 
  4.  
  5.     ........ 
  6.  
  7.     PyUnicode_InternInPlace(&name); 
  8.  
  9.     ........ 
  10. } 

5.4 显式地驻留

Python 还支持通过sys模块中的intern函数进行显式地字符串驻留。

当使用任何字符串对象调用此函数时，该字符串对象将被驻留。以下是 sysmodule.c 文件的代码片段，它展示了在sys_intern_impl函数中的字符串驻留过程。

  1. static PyObject * 
  2. sys_intern_impl(PyObject *module, PyObject *s) 
  3. { 
  4.  
  5.     ........ 
  6.  
  7.     if (PyUnicode_CheckExact(s)) { 
  8.         Py_INCREF(s); 
  9.         PyUnicode_InternInPlace(&s); 
  10.         return s; 
  11.     } 
  12.  
  13.     ........ 
  14. } 

6、字符串驻留的其它发现

只有编译期的字符串会被驻留。 在解释时或编译时指定的字符串会被驻留，而动态创建的字符串则不会。

Python猫注：这一条规则值得展开思考，我曾经在上面踩过坑……有两个知识点，我相信 99% 的人都不知道：字符串的 join() 方法是动态创建字符串，因此其创建的字符串不会被驻留;常量折叠机制也发生在编译期，因此有时候容易把它跟字符串驻留搞混淆。

包含 ASCII 字符和下划线的字符串会被驻留。 在编译期间，当对字符串字面量进行驻留时，CPython 确保仅对匹配正则表达式[a-zA-Z0-9_]*的常量进行驻留，因为它们非常贴近于 Python 的标识符。

Python猫注：关于 Python 中标识符的命名规则，在 Python2 版本只有“字母、数字和下划线”，但在 Python 3.x 版本中，已经支持 Unicode 编码。

参考材料字符串驻留(https://en.wikipedia.org/wiki/String_interning)

CPython优化(https://stummjr.org/post/cpython-optimizations/)

Python对象第三部分：字符串驻留(https://medium.com/@bdov_/https-medium-com-bdov-python-objects-part-iii-string-interning-625d3c7319de)

Python字符串驻留的内部原理(http://guilload.com/python-string-interning/)

Python优化机制：常量折叠(https://mp.weixin.qq.com/s/p1Zb_linFLWwPlNyA5Ui1Q)

join()方法的神奇用处与Intern机制的软肋(https://mp.weixin.qq.com/s/M2uHVqaHe_nyO5jT60V_6Q)

英文：https://arpitbhayani.me/blogs/string-interning

作者：arpit

译者：豌豆花下猫(“Python猫”公众号作者)

声明：本翻译是出于交流学习的目的，基于 CC BY-NC-SA 4.0 授权协议。为便于阅读，内容略有改动。

本文转载自微信公众号「Python猫」，可以通过以下二维码关注。转载本文请联系Python猫公众号。

 

来源：Python猫内容投诉

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析（完整版）

    难度     813人已做
    查看

  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看

  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看

  • 2024年上半年软考高项第一、二批次真题考点汇总（完整版）

    难度     435人已做
    查看

  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机

深入 Python 解释器源码，我终于搞明白了字符串驻留的原理！

后端开发Python解释器2024-12-03
位置：首页-资讯-后端开发
咦！没有更多了？去看看其它编程学习网 内容吧
首页课程
资料下载问答资讯