Видео с мероприятий {speach!
CPython向生态过度暴露类型槽位与全局状态导致生态产生不可逆依赖,直接封死了解除全局解释器锁与实现现代内存优化的技术路径。
AI-assisted summary of How Python was Shaped by leaky Internals, Armin Ronacher, Flask framework — original source. Check the original for full context.
Source published:
Key ideas
- Armin Ronacher 指出 CPython 将大量底层实现细节无保留地暴露给生态,导致解释器被深度锁死,无法轻易移除 GIL 或支持多版本库共存。 (17:52)
- 教程中宣称的运算符重载等价于双下划线方法其实是“善意谎言”,CPython 在字节码与 C API 层依靠硬编码槽位(slots)和复杂的特化分支执行,而非动态查找 __add__。 (5:36)
- sys._getframe 和 sys.modules 的公开赋予了 Sentry 与 Django 极强的实时调试与反射能力,但也导致难以在单进程多线程中嵌入隔离的解释器实例,阻碍了底层现代化。 (32:46)
- 针对性能优化,Armin 认为盲目堆砌 C 特化分支会破坏 CPU 缓存局部性,解释器应通过精简对象模型与代码体积来提升现代硬件上的执行效率。 (46:36)
Detailed notes
## Background 该视频由 YouTube 频道“Видео с мероприятий {speach!”于 2016 年 7 月 13 日发布,内容为著名开源开发者、Flask 框架作者 Armin Ronacher 的技术演讲。原页面未提供额外的文字简介或详细说明。
## TL;DR Armin Ronacher 在演讲中深入剖析了 CPython 虚拟机繁复的底层实现细节,指出初学者教程中所谓“a + b 纯粹等价于 a.__add__(b)”的说法本质上是一个美好的谎言,解释器内部充斥着 C 槽位(slots)与复杂的硬编码快速路径。他展示了 sys._getframe、sys.modules 等解释器内部机制如何在毫无保留暴露给用户空间的同时,反向塑造了整个语言生态,并直接导致全局解释器锁(GIL)难以移除、多版本库无法并行隔离加载以及进程内多解释器实例嵌入受阻等沉重历史包袱。最后,他反思了过度特化常见路径对现代 CPU 缓存的不利影响,并对比 JavaScript 等语言,强调了极简公开 API 对语言长期演进的重要性。
## Atmosphere & style 整场演讲呈现出一种既坦诚锐利又带有几分幽默调侃的技术解剖风格。Armin 顶着著名框架作者和拥有 CPython 提交权限的资深开发者光环,却选择以一种好奇“旁观者”的视角来无情戳破语言表层抽象的华丽外衣,言谈间充满了对历史架构包袱的无奈与反思。现场氛围专注且略带震撼,听众随着他一步步剥开解释器深处如迷宫般的 C 源码,直面 Python 光鲜外表下脆弱复杂的底层现实,并在最后的问答交锋中引发了深层次的工程共鸣。
## Bulletin - [17:52](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1072s) Armin Ronacher 指出 CPython 将大量底层实现细节无保留地暴露给生态,导致解释器被深度锁死,无法轻易移除 GIL 或支持多版本库共存。 - [05:36](https://www.youtube.com/watch?v=qCGofLIzX6g&t=336s) 教程中宣称的运算符重载等价于双下划线方法其实是“善意谎言”,CPython 在字节码与 C API 层依靠硬编码槽位(slots)和复杂的特化分支执行,而非动态查找 __add__。 - [32:46](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1966s) sys._getframe 和 sys.modules 的公开赋予了 Sentry 与 Django 极强的实时调试与反射能力,但也导致难以在单进程多线程中嵌入隔离的解释器实例,阻碍了底层现代化。 - [46:36](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2796s) 针对性能优化,Armin 认为盲目堆砌 C 特化分支会破坏 CPU 缓存局部性,解释器应通过精简对象模型与代码体积来提升现代硬件上的执行效率。
## Key takeaways - [02:52](https://www.youtube.com/watch?v=qCGofLIzX6g&t=172s) Python 表面上有清晰的概念模型,但底层高度依赖暴露的解释器机制,导致其比 Ruby 更动态、更难进行全局深度优化。 - [02:52](https://www.youtube.com/watch?v=qCGofLIzX6g&t=172s) 底层实现的泄漏直接阻碍了 Python 的现代化进程,包括 GIL 的移除、进程内多版本库共存以及多实例隔离运行。 - [05:36](https://www.youtube.com/watch?v=qCGofLIzX6g&t=336s) 基础运算 a + b 并没有在字典中查找 __add__,而是直接分发至底层 C 结构体的槽位(slots)及专门的整数、字符串快速路径。 - [08:34](https://www.youtube.com/watch?v=qCGofLIzX6g&t=514s) Python 存在两套完全不同的 Slot 概念:语言层用于省内存的 __slots__ 与 CPython 解释器层用于函数指针偏移的 Type Slots。 - [10:39](https://www.youtube.com/watch?v=qCGofLIzX6g&t=639s) 由于历史上 C 类型与 Python 类的分裂以及数值槽与序列槽的双重存在,几乎没有开发者能完全预判 a + b 的所有底层分支。 - [17:52](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1072s) Python 将 slot_wrapper 等底层内部对象暴露给用户层,破坏了如 JavaScript 那般“万物皆为统一函数”的一致性模型。 - [23:51](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1431s) 新式类将双下划线特殊方法的解析强制绑定在 Type 上,终结了 Python 2.4 旧式类通过 __getattr__ 实现 100% 透明代理的机制。 - [25:27](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1527s) 为维持对单个字符 O(1) 随机访问的直觉假设,Python 早期坚持采用固定宽度的 UCS 存储而非变长 UTF-8,造成了严重的内存开销与架构束缚。 - [32:46](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1966s) sys._getframe 暴露了调用栈帧的完整内部状态,虽然牺牲了解释器重构自由度,却构成了 Django 调试页、Flask 及 Sentry 异常监控的核心底气。 - [37:35](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2255s) sys.modules 作为扁平全局单例字典暴露给外界,加上 pickle 序列化对此机制的永久固化,使得同一进程内并行加载多版本库的方案彻底破产。 - [39:57](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2397s) 内置类型(如 PyInt_Type)作为 C 全局静态变量存在,使得 CPython 无法在单进程的多线程宿主中原生嵌入互不干扰的独立解释器实例。 - [43:19](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2599s) 引用计数与 C API 的强耦合让现代多线程隔离模型无法落地,同时也逼迫解释器必须硬编码快速路径,反而在部分元编程场景下牺牲了动态性。 - [46:36](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2796s) 相比 Python 的深度暴露,现代语言设计(如 JavaScript)应当尽量保持极小的公共暴露 API,避免生态过度耦合底层实现。 - [46:36](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2796s) 频繁堆砌特化分支会增加指令体积并引发 CPU 缓存失效,精简整体架构与对象模型反而能在现代硬件体系下获得更优的通用执行效率。
## Detailed walkthrough ### [00:06](https://www.youtube.com/watch?v=qCGofLIzX6g&t=6s) 演讲主题与 Armin Ronacher 的 Python 背景
演讲者 Armin Ronacher 明确了本次演讲的主题:深入探讨 Python 虚拟机(VM)的内部实现机制,以及这些底层设计如何深刻影响并塑造了 Python 这门编程语言本身。由于解释器底层的很多技术细节可能枯燥繁杂,他开场便鼓励台下听众随时提问互动。谈及对这门语言的感受时,他指出大家都喜欢用 Python,但很少有人意识到解释器内部是多么繁琐细致(nitty-gritty);这种机制既限制了我们能做什么,又在某些方面赋予了我们极大的灵活性。
Armin 随后分享了自己的 Python 经历。他最早接触 Python 是从 2.0 版本开始,真正开始深度写代码则是在 2.2 版本。出于对语言演变与解释器进化的好奇,他曾尝试回溯编译非常古老的版本,甚至在现代计算机上成功编译了 Python 1.3 并获得了可执行文件。这让他发现,Python 解释器中有大量核心机制在过去数十年间几乎从未改变。
作为活跃的开源开发者,Armin 介绍了自己在生态中的角色。他的日常主职工作是在 Sentry(一款主要基于 Django 框架构建的 Python 开源错误收集与监控系统)进行开发;在此之外,他主导开发了 Flask 框架、静态站点内容管理系统 Lektor,以及 Jinja、MarkupSafe、Werkzeug 等大量基础库。尽管他在 Python 核心仓库拥有代码提交权限(Commit access),但他打趣说这“出于某些无法解释的原因”,自己极少向解释器本身贡献代码,而更偏向于以好奇的旁观者视角去研究解释器的各种机制。
- 接触时间线:初识 Python 2.0,真正深度开发始于 Python 2.2,曾成功在现代机器上编译测试 Python 1.3。 - 开源履历:Sentry 核心开发、Flask 框架作者、Lektor 创始人,以及 Jinja、Werkzeug、MarkupSafe 等核心库作者。 - 角色定位:拥有 CPython 提交权限,但主要以应用层框架开发者与探索者的视角审视 CPython 源码。
---
[02:52](https://www.youtube.com/watch?v=qCGofLIzX6g&t=172s) 动态语言光谱:Python 与 Ruby 的对比及演化困局
编程语言通常分布在从“极度动态”到“极度静态”的光谱两端。Armin 借用 Ruby 来与 Python 进行对比:Ruby 社区常以高度动态自豪,开发者甚至可以直接修改内置 `Float` 类的加法方法,将其行为强行篡改成减法。虽然 Python 不支持直接篡改内置 `float` 的 `__add__`,但 Armin 提出了一个更为激进的观点:
> “I actually think that python as a language is way more Dynamic and as a result way harder to optimize than it is to optimize ruy”——Armin Ronacher
在 Armin 看来,Python 实际上比 Ruby 更加动态,因而更难进行深度优化。网络上的通用教程往往给开发者灌输了一套美好的“概念模型”,但一旦深入底层,就会发现语言的真实运转机制根本不是那回事。更棘手的是,大量用户在实际代码中以非常古怪(bizarre)的方式深度依赖了这些解释器内部细节,导致核心团队难以对底层实现做出大刀阔斧的重构。
这些底层历史包袱直接导致了 Python 诸多长期悬而未决的痛点: 1. **全局解释器锁(GIL)难以剥离**:GIL 的移除牵涉到解释器最初的设计保证,导致并发模型难以演化。 2. **多版本隔离加载受限**:无法在同一个进程内方便地同时加载同一个第三方库的不同版本。 3. **解释器进程内隔离困难**:很难在同一个可执行程序中并排运行多个互不干扰、不共享状态的解释器实例。 4. **底层基础类型体系僵化**:无法轻易更改类型运作的基本原则。 5. **Python 3 的历史堆叠**:随着时间推移,越来越多复杂的特性被堆砌在已非常臃肿的底层之上,Armin 认为其中不少新设计甚至缺乏足够的同行评审(peer review)。
---
[05:36](https://www.youtube.com/watch?v=qCGofLIzX6g&t=336s) 语法抽象与底层现实:加法操作的真相
为了揭示底层细节与教程抽象之间的巨大鸿沟,Armin 举了一个极其简单的示例:定义全局变量 `magic = 42`,随后定义函数 `add_magic(a)` 返回 `a + magic`。许多网络教程和书籍都会宣称,这里的加法在语义上完全等价于调用对象的双下划线方法(即 `a.__add__(magic)`)。但 Armin 指出,这完全是一个巨大的谎言。
在解释器内部,Python 会先将代码编译为字节码,加法对应的操作码指令是 `BINARY_ADD`。解释器的主循环位于庞大的 `ceval.c` 文件中(该文件有数千行之多,本质是一个巨大无比的 `switch-case` 分发循环)。遇到 `BINARY_ADD` 指令时,解释器会从求值栈中弹出两个操作数,紧接着执行一长串充满特殊判断的分支逻辑:
```mermaid flowchart TD accTitle: CPython 加法操作码的分发逻辑 accDescr: 展示 BINARY_ADD 在 CPython 内部如何分流到具体快路径或通用求值函数
subgraph EvalLoop["ceval.c: BINARY_ADD"] A["从栈中弹出操作数 V 与 W"] --> B{"V 和 W 是否均为纯正 int?"} B -- "是" --> C["执行专门的快速整数加法分支"] B -- "否" --> D{"V 和 W 是否均为纯正 str?"} D -- "是" --> E["执行专门的字符串拼接分支"] D -- "否" --> F["调用 PyNumber_Add(V, W)"] end
subgraph GenericAdd["PyNumber_Add 逻辑"] F --> G{"检查 nb_add 槽位"} G -- "存在槽位" --> H["调用 binary_op1 执行运算"] G -- "非数值类型" --> I["进入序列拼接特殊处理分支"] end ```
如果两个操作数不是纯正的原生类型(不包括子类),解释器便会调用 C API 中的 `PyNumber_Add`。Armin 吐槽该函数虽然名字叫“Number”,但实际上完全是个坏名字(bad name),因为它内部还包含了序列(Sequence)拼接的特殊处理,实质上相当于 `PyObject_Add`。最关键的是,在这一长串 C 源码中,根本找不到对属性名 `"__add__"` 的字典查找过程,而是直接调用了 C 结构体上的槽位函数(slot)。
- 专用快速路径:CPython 会在字节码层面对纯整数(exact integer)和纯字符串(exact string)进行类型短路优化,避开通用分发。 - 源码膨胀:仅仅是把两个数字加在一起这一项操作,穿透整个解释器链路所触及的 C 源码就长达约 400 行。
---
[08:34](https://www.youtube.com/watch?v=qCGofLIzX6g&t=514s) 揭秘“槽位(Slots)”与被掩盖的真实机制
在讨论到加法调用的具体实现时,Armin 向现场观众提问究竟什么是 Python 中的“Slot”。他指出,在 Python 语境下其实存在两套完全不同的“Slot”概念:
| 槽位类型 | 所在层面 | 作用机制 | 核心目的 | |:--- |:--- |:--- |:--- | | **`__slots__`** | Python 语言层 | 在类定义中声明属性列表,阻止为每个实例生成 `__dict__` | 节省内存空间,加快属性访问 | | **C 结构体槽位(Type Slots)** | CPython 解释器层 | 定义在 `PyTypeObject` 结构体内部的特定函数指针成员(如 `tp_as_number->nb_add`) | 避免运行时的字典查找,直接通过指针偏移调用 C 级操作 |
在 C 语言层面,每个 Python 对象都有一个 `ob_type` 指针指向其类型对象(Type Object)。类型对象内部维护着庞大的结构体,其中包含各种协议簇指针(例如处理数值操作的 `tp_as_number`)。当执行加法时,解释器检查的是结构体偏移中的 `nb_add` 函数指针,而不是从对象或类型的字典里查找字符串 `"__add__"`。
解释器会根据参与运算的两个对象的类型关系,调用对应的槽位函数。整个过程涉及约 400 行 C 语言逻辑,但没有任何地方涉及到属性字符串查找。Armin 直言:
> “Where is `__add__`? It doesn't appear anywhere, sort of that's the big lie, the big lie is that we we invoking this special things, but we're not; instead we're looking at this stupid slots things.”——Armin Ronacher
这种通过 C 结构体硬编码槽位来加速操作的底层实现,虽然兼顾了性能,却彻底打破了“所有运算符重载都等价于在字典中查找对应双下划线方法”的浅层抽象模型,构成了 Python 内部实现向外渗透(leaky internals)的经典例证。
[10:39](https://www.youtube.com/watch?v=qCGofLIzX6g&t=639s) a + b 背后不可捉摸的语义与历史分裂
尝试从 Python 解释器的角度推导运行时行为是一件令人惊讶且沮丧的事情。按理说,对于对象 $a$ 和对象 $b$,当对其执行加法、减法或乘法时,理应有一套极其明确且标准化的规则——就像 JavaScript 近年来通过明确规范做到的那样,标准巨细靡遗地规定了两个对象相加的具体结果。然而在 Python(尤其是 Python 2)中,想要准确预知 `a + b` 会发生什么几乎是不可能的,它不仅取决于对象上的底层标志位(flags),还取决于两者之间错综复杂的类型层级关系。Armin Ronacher 对此直言不讳:“I would argue that there is probably not a single programmer in in the python Community who could tell you exactly what happens if you add two objects together um and I I kind of assume this from the fact that there's the pipie project and the pipie project tries to implement the Python language in Python um and it's kind of interesting sometimes when pipy disagrees with the implementation that cpython has and you would think that they must get it right but then they still disagree in in certain ways.”
这一切复杂性的根源在于 CPython 历史上的“槽”(slots)机制。所谓 slot,本质上是解释器为每个类型维护的 C 结构体(`struct`)中的一个函数指针槽位。早在 1995 年左右,Python 世界割裂为两套互不相干的体系:一套是基于 C 语言实现的内置类型(C types),另一套则是后来引入的 Python 类(Python classes)。如果将两个用 C 编写的内置整数相加,解释器会调用专门的 C 槽方法 `nb_add`;而当语言加入了 Python 类并希望支持自定义加法时,设计者引入了特殊的回调方法 `__add__`。
为了弥合两者的鸿沟,解释器引入了一套同步机制:当 C 类定义了 slot 时,C 底层逻辑会通过某些机制将该 slot 包装并作为特殊方法暴露给 Python 层;反过来,当 Python 类定义了 `__add__` 时,解释器会获取该函数并将其塞入底层 C 类型的相应 slot 中。这种试图让 `foo.__add__` 与底层 C 类型的 `tp_as_number->nb_add` 始终保持同步的设想,由于早期架构决策而变得异常脆弱。早在 Python 诞生初期,Guido van Rossum 将相加操作分化为两大独立概念:数值相加(numbers)与序列拼接(sequences)。因此解释器内部同时存在数值槽(number slots)和序列槽(sequence slots),加法操作符 `+` 必须同时兼顾这两者,导致底层状态极易出现不同步。
```mermaid flowchart TD accTitle: Python 中 a + b 的解释器求值决策流 accDescr: 展示 Python 解释器在执行 a + b 时经历的多重分支与槽位查找逻辑
Start["执行表达式 a + b"] --> FastInt{"a 与 b 是否均为整数?"}
subgraph FastPath ["快速路径"] FastInt -- "是" --> DoIntAdd["执行底层整数快速加法"] FastInt -- "否" --> FastStr{"a 与 b 是否均为字符串?"} FastStr -- "是" --> DoStrConcat["执行底层字符串快速拼接"] end
subgraph NumberSlots ["数值槽路径 (nb_add)"] FastStr -- "否" --> CheckNum{"a 或 b 是否实现数值槽?"} CheckNum -- "是" --> ResolveTypeRel["根据复杂类型关系解析优先级"] ResolveTypeRel --> InvokeNumSlot["调用数值槽 nb_add 解析结果"] end
subgraph SequenceSlots ["序列槽路径 (sq_concat)"] CheckNum -- "否" --> CheckSeq{"a 是否实现序列槽?"} InvokeNumSlot -- "未实现 / 失败" --> CheckSeq CheckSeq -- "是" --> InvokeSeqConcat["调用序列槽 sq_concat 拼接"] CheckSeq -- "否" --> TypeError["抛出 TypeError 异常"] end ```
[15:00](https://www.youtube.com/watch?v=qCGofLIzX6g&t=900s) 教程谎言与解释器内复杂的快速路径
市面上绝大多数 Python 教程对运算符重载的解释完全是一种“善意的谎言”。入门教程通常写道:执行 `a + b` 等价于调用 `a.__add__(b)`;稍微严谨一点的教程会纠正为调用 `type(a).__add__(a, b)`。然而这两种说法在 CPython 实现面前都是错误的。当在解释器中写下 `a + b` 时,底层经历了一套极度复杂的快速路径判定逻辑: - 首先检查 $a$ 和 $b$ 是否都是整数,若是,则直接进入解释器内部专设的整数快速加法通道; - 接着检查两者是否都是字符串,若是,则走专用的字符串快速拼接通道; - 随后尝试走数值加法:检查 $a$ 是否实现了数值槽并解析其 slot,再检查 $b$ 是否实现数值槽;根据两者之间极其复杂的继承关系决定调用顺序,通常最终解析为由 $a$ 的槽函数接收 $a$ 和 $b$; - 若数值槽尝试失败,解释器才会退回到另一套独立的执行路径,尝试进行序列拼接(sequence concatenation)。
相比之下,直接在 Python 中写 `a.__add__(b)` 的查找逻辑反而极其简单直接:仅仅是在类型对象上查找名为 `__add__` 的属性并将其作为普通方法调用。令人啼笑皆非的是,解释器为了追求极限性能而在底层堆砌的 slot 快速路径,其判定与调度逻辑远比暴露给用户的上层模型复杂得多。在某些边界情况下,手动编写 `a.__add__(b)` 的执行速度甚至反而比操作符 `a + b` 更快。
面对如此庞杂的包袱,人们很自然会产生一个疑问:为什么不直接重构解释器,把 `a + b` 在底层彻底规范化为直接调用 `a.__add__(b)` 并对其进行统一优化?Armin 强调,之所以无法推翻重来,根本原因在于 CPython 历史上一贯的做法是将底层内部实现毫无保留地泄露给了整个周边生态系统:“And the reason for this is that unfortunately we expose so much of the language to the ecosystem around it that we can't change The Interpreter anymore.”
[17:52](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1072s) C API 的泄露与万物皆非统一函数的类型泥潭
任何编写过 Python C 扩展的人,都深知 Python C API 的抽象层级有多么底层。每一个自定义的 C 类型都必须直接了解并填充底层结构体的 slots。这种内部细节不仅暴露在 C 层,甚至被原封不动地暴露给了 Python 运行时的普通用户。哪怕是从未接触过底层原理的新手,也经常在日常报错中撞见诸如 `'slot_wrapper' object has no attribute '...'` 这样充斥着内部黑话的异常信息。
这种底层泄漏导致了高层语义的严重不一致。若在 Python 中定义一个继承自 `object` 的普通类并赋予其 `__add__` 方法,访问该类的 `__add__` 得到的是一个普通的未绑定方法(Unbound method,底层为函数或 lambda);但如果访问 C 内置类型的 `int.__add__`,拿到的却是一个名为 `slot_wrapper` 的底层特殊对象。`slot_wrapper` 本质上是在 C 解释器层面包裹 C 函数的代理,却赤裸裸地暴露在用户层。这与 JavaScript 形成了鲜明的对比——在 JavaScript 中“万物皆为函数”(everything is a function),无论是用 JS 写的还是 C++ 底层实现的,在外部视角下完全一致。而 Python 内部却分裂出一大批拥有微妙行为差异的调用物类型: - 普通函数(functions) - 内置函数(built-in functions) - 槽包装器(slot wrappers) - 方法描述符(method descriptors) - 各类可调用对象(callable objects)
这些细微的实现差异最终演化成了生态中被广泛依赖的隐式契约。例如,如果把一个普通类的未绑定方法 `__add__` 提取出来赋值给另一个类作为属性,它会扮演描述符(descriptor)的角色,在调用时自动绑定实例并将 `self` 作为第一个参数传入;但如果将一个 C 类型的 `slot_wrapper` 做同样的操作,它却不会表现出这种自动绑定行为。许多开发者甚至写过形如 `conversion_function = int` 这样的类属性代码,其运行完全依赖于 `int` 作为 C 类型不会被错误当作方法描述符去绑定 `self`。这种隐形依赖形成了一道死锁:解释器核心开发者永远无法重构和清理这些怪异行为,因为现有的成千上万行代码正依赖着这些泄漏出来的缝隙存活;而像 PyPy 这样的替代编译器项目,为了实现 100% 的兼容性,也不得不原样复制 CPython 这套充满历史包袱的底层怪癖。
[21:45](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1305s) C 扩展与解释器内部行为的穿透泄漏
Armin Ronacher 强调,开发者必须深入理解这些底层细节,原因在于“它非常复杂,而且每个人都在使用它,这使得性能优化几乎变得不可能”(“it's very complex and everybody uses it and it makes optimizations almost impossible”)。当将 Python 代码移植到其他语言运行时,必须对这些行为进行模拟;更严重的是,这些实现细节直接塑造了 Python 自身代码的行为模式。他举了一个虽然在新版中已被修复、但极具代表性的历史怪异问题:标准库中的 `re`(正则表达式)模块。在旧版 Python 中编译正则表达式后,返回的对象类型形如 `SRE_Pattern`。令人震惊的是,如果尝试访问该对象的 `__class__` 属性,Python 会直接抛出 `AttributeError`;同时,它也没有 `__repr__` 属性。在常规认知中,Python 里的任何对象都应该拥有类属性,这种完全不响应特殊属性的行为显得极为不可思议。
出现这种现象的根源在于,该对象完全是由 C 语言编写的底层扩展。编写该 C 对象的开发者定制了它暴露给 Python 层的全部外观行为,导致 C 解释器眼中的对象结构与 Python 代码所能看到的内容完全脱节。例如,如果尝试用纯 Python 编写内置的 `repr()` 函数逻辑去调用目标对象的 `__repr__`,对该对象将永远失效,因为其类型信息和表示方法只能在 C 语言层面上读取,Python 脚本层根本无法触及。这生动地证明了 Python 的 C-API 机制允许底层实现一套对上层解释层完全不可见或严重失真的定制行为。
- 在 Python 2.7 之前的旧版本中,`re.compile()` 返回的内部正则对象缺少 `__class__` 和 `__repr__` 等基本特殊属性。 - 解释器 C 层面与 Python 脚本层面的对象模型存在割裂,导致部分高级反射机制在 C 扩展对象上彻底失灵。
---
[23:51](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1431s) 旧式类、代理转发与对象模型的历史包袱
Armin 接着展示了 Python 2.4 时代的旧式类(Old-style Classes)行为。在那个年代,如果定义一个不继承自 `object` 的类,并在其中实现 `__getattr__` 来代理转发另一个底层对象,所有的特殊双下划线方法(Dunder Methods)都会被平滑透传。比如实例化类 `A` 并让其代理整数 `42`,当解释器尝试寻找该实例的 `__repr__` 时,会直接触发 `__getattr__` 并在内部的整数 `42` 上解析该方法,从而让实例完美呈现为 `42` 的形态,实现 100% 的透明代理。
然而,现代 Python 采用的新式类(New-style Classes)打破了这种设计,不再通过实例字典或 `__getattr__` 查找特殊双下划线方法,而是强制直接从对象的类(Type)上查找。这意味着旧式类为了保持对古老版本的兼容,必须依赖专门的 `instance` 内部类型来进行繁琐复杂的属性与调用转发。Armin 指出,过去在教学中向初学者传授的“所有属性访问都会走到 `__getattr__`”这一逻辑,在早期确实是真实的底层实现,但随着类型系统的演进,这套机制演变成了充斥着各种妥协与不一致的沉重代理负担。
```mermaid flowchart TD accTitle: Python 属性查找机制历史演变 accDescr: 对比 Python 旧式类与新式类在调用双下划线特殊方法时查找路径的区别。
subgraph OldStyle["Python 2.4 旧式类 (透明代理)"] A1["调用 repr(obj)"] --> B1["查询 obj.__getattr__('__repr__')"] B1 --> C1["转发至底层对象 (如 int 42)"] C1 --> D1["成功执行代理对象的 __repr__"] end
subgraph NewStyle["现代 Python 新式类"] A2["调用 repr(obj)"] --> B2["直接查找 type(obj).__repr__"] B2 --> C2{"类上是否存在实现?"} C2 -- "是" --> D2["直接执行"] C2 -- "否" --> E2["抛出 AttributeError (绕过 __getattr__)"] end ```
---
[25:27](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1527s) 字符串与 Unicode 的演变:固定宽度引申的架构陷阱
话题转入更加直观却同样充满内幕的 Unicode 实现。Armin 解释道,理解这一机制必须回顾 Python 诞生之初的背景:早期的 Python 根本没有 Unicode 概念,字符串就是纯粹的字节序列,每个字符的数值范围落在 0 到 256 之间(即单字节)。这种物理布局催生了 Python 程序员极度依赖的一种直觉假设:访问字符串的第 1、第 2、第 3 个字符是绝对廉价且瞬时的 $O(1)$ 随机索引操作。
当 Unicode 逐渐普及并被引入 Python 时,开发团队为了维持这种“可以直接按下标取字符”的心智模型,做出了一个深远且代价高昂的决定:简单地把固定宽度数组从 0-256 扩大到 0-65,535(两字节的 UCS-2 编码)。随着人类语言文字的不断扩充,两字节迅速饱和,解释器后来又加入了支持更大数字的编译选项。尽管这种设计在直觉上很便利,但从工程角度来看却埋下了巨大的遗憾。
- 早期 Python 字符串本质为单字节数组,随机下标访问具备先天的硬件级性能优势。 - 引入 Unicode 后,为了保持对单个字符的常数级下标访问,Python 选择了固定宽度的内部表示,而不是变长流式布局。
---
[26:43](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1603s) UCS-2、UCS-4 与 UTF-8 的标准之争及内存膨胀
Armin 回顾了大约 25 年前字符编码标准演进的戏剧性历史。当时有两个独立的组织在尝试解决 ASCII 的全球化扩充问题:Unicode 联盟最初天真地认为“65,000 个字符对全世界所有人都足够了”(“65,000 characters is enough for everyone... they were wrong”);而 ISO 委员会则主张搞一套 $2^{32}$ 容量的超大标准,但因其过于庞大且缺乏高效的物理编码方式而未被广泛采纳。随着 Emoji 表情符号的爆炸式普及,字符序号迅速突破 65,535,至少需要 3 个字节以上才能表示。
与此相对,业界逐渐意识到 UTF-8 这种变长编码的优越性:绝大多数文本(ASCII 或西里尔字母等低码位文本)只需要 1 到 2 个字节,能够极大地压缩体积并避免内存中充满大量的填充零。而如果 Python 2 解释器在编译时选用了基于固定 2 字节的 UCS-2,当文本中包含 Emoji 时,一个单独的 Emoji 字符会被硬生生切碎成两半(作为代理对存在),必须通过访问两个连续字符才能拼出一个完整表情;开发者若要解决这个问题,就必须在编译解释器时开启 UCS-4 选项,使得字符串中的**每一个字符**都强行占用 4 个字节。Armin 直言这构成了极其惊人的内存浪费,因为即便是 Unicode 的终极上限也只需要 21 位(刚刚超过 2 个字节半),分配 4 个字节意味着绝大多数内存位都在白白闲置。
| 编码方案 | 单字符内存占用 | 访问特定字符的时间复杂度 | 对 Emoji 的处理缺陷 | 空间利用率 | |:--- |:--- |:--- |:--- |:--- | | **UTF-8** | 1 至 4 字节(变长) | $O(N)$(必须线性扫描前置字节) | 原生单码点支持,无截断 | 极高(无冗余零字节) | | **UCS-2** | 固定 2 字节(16 位) | $O(1)$(直接按偏移量跳转) | 字符被拆成两半(代理对溢出) | 仅在 BMP 范围内较高 | | **UCS-4** | 固定 4 字节(32 位) | $O(1)$(直接按偏移量跳转) | 支持完整码位,无拆分 | 极低(Unicode 上限仅 21 位,大量浪费) |
---
[30:03](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1803s) 抽象泄漏对现代语言设计的启示
面对为何 Python 宁愿承受巨大的内存浪费也不直接将内部存储切换为 UTF-8 的质问,Armin 给出了关键答案:Python 历史性地向开发者做出了“访问索引 1 就能精确瞬时拿到第 1 个字符”的语义承诺。如果内部采用 UTF-8,要定位第 $N$ 个字符就必须从头进行全量字节扫描;而采用固定宽度的 UCS-2 或 UCS-4,解释器仅需简单的乘法偏移即可跳至目标位置。虽然 UTF-8 在近十年已无可争议地成为全行业的事实标准(例如 Go 语言全盘拥抱 UTF-8 且原生不提供直接的字符随机索引,Rust 与 Swift 亦在此类设计上保持克制,避免误导开发者以为随机索引字符是无成本的),但 Python 却被早期的内部假设紧紧绑架。
尽管 Python 3 通过动态自适应内部表示(根据字符串中最大字符动态选用 1、2 或 4 字节)在一定程度上缓解了内存问题,但它依然死守着“固定索引”的抽象承诺。Armin 评价道:“我们所使用的语言,几乎完完全全就是那个现存的解释器本身”(“the language that we use is pretty much exactly The Interpreter as it exists”)。这种解释器底层逻辑向上层语法的直接穿透,一方面极大地阻碍了全局性能优化,在底层与上层脱节时会表现得极其诡异;但从另一个角度来看,这也塑造了 Python 程序员独特的思维方式。相比于 JavaScript 开发者习惯被局限在高度沙盒化、高度抽象且只能被动接受限制的浏览器运行时环境中,Python 开发者能够透过语法直接触及运行时的裸机机制,形成了完全不同的技术世界观。
[032:46] `sys._getframe`:暴露执行状态的双刃剑
在 Python 中,解释器的内部实现一直毫不遮掩地暴露给用户空间,这种深度穿透塑造了许多在其他编程语言中极为罕见的特性。Armin Ronacher 直言,尽管完全暴露的解释器让社区几乎无法彻底摆脱 GIL(全局解释器锁),也阻碍了大量激进的编译器优化,使 Python 始终受困于特定运行机制,但这也赋予了开发者极具威力的控制权。他在现场调查有多少人使用过或听说过 `sys._getframe()` 时,举手的人寥寥无几。Armin 表示,这个函数是让许多 Python 代码变得“充满刺激(spicy)但未必算得上优秀”的秘密原料。
任何时刻调用 `sys._getframe()`,解释器都会奉上当前调用栈的帧对象(Frame Object),直接暴露当时近乎完整的解释器内部状态。从纯粹的高级语言设计与性能考量出发,这种设计堪称疯狂:“如果去重新设计一门高级语言,所有人都会主张‘千万别提供这玩意,它太慢了、太荒谬了,根本不应该存在’。”然而 Python 在极早期就暴露了栈帧,并且大量现有代码深度依赖它,迫使 CPython 核心开发团队必须设法保证其运行性能。相比之下,Ruby 等语言虽然也有类似机制,但因极少有人使用而慢得无法直视。
通过帧对象,开发者可以随心所欲地读取局部变量、在某些场景下篡改局部变量、检查当前执行的文件名,以及读取当前帧正在处理的异常。这种机制催生了大量既精巧又带有“滥用”色彩的设计: - **Zope Interface**:其 `implements` 方法在被调用时,会动态向上探测一层调用栈,直接要求上一层的类对象注入新属性,在纯粹的函数调用语义层面完全不合常理。 - **warnings 模块**:能够根据传入的参数,将警告信息锚定到往上数若干层的调用栈位置,而不是硬编码在函数自身内部。 - **inspect 模块**:深度依赖该特性来反射和内省运行时代码结构。 - **logging 模块**:在记录日志时主动跳过日志库自身的内部调用帧,保证最终记录的文件名和行号精准指向业务调用的位置。
```mermaid flowchart TD accTitle: sys._getframe Call Stack Inspection accDescr: Diagram showing how sys._getframe traverses and exposes caller frame internals.
subgraph UserSpace["用户调用层"] A["业务代码 / 调用点<br/>(Local Vars, Exception Context)"] B["中间库 / 框架层<br/>(warnings / logging / zope.interface)"] end
subgraph FrameState["解释器运行时"] F1["Frame 0: logging.info()"] F2["Frame 1: Caller Frame<br/>(文件名、行号、局部作用域)"] F3["Frame 2: Root Caller"] end
A -->|"调用"| B B -->|"sys._getframe(1)"| F2 F2 -.->|"读取并剥离内部帧"| B ```
[035:54] 实时调试生态与崩溃追踪系统的底气
这种直通解释器底层的机制,孕育了极具特色的调试与排错生态。Armin 以近乎被遗忘的 `twisted.manhole` 为例:在工业界和许多公司内部,常有常驻的游戏服务器或后台进程在模拟世界中运行,当出现诡异行为却又不能停机重启时,工程师可以直接挂载一个调试器连入正在运行的 Python 进程,在 live 解释器中直接执行任意 Python 代码,检视所有运行状态。
作为 Sentry 的核心成员,Armin 指出这种灵活性是 Sentry 等崩溃监控平台的核心支柱。在常规语言中,发生崩溃时往往只能拿到浅层的错误堆栈;而在 Python 运行时中,Sentry 不仅能提取每一层调用栈的文件与行号,还能原汁原味地提取出崩溃发生瞬间每一帧内的所有局部变量数值,乃至精准的时间开销。对于普通开发者而言,Django 报错时呈现的华丽调试页,或者 Flask 崩溃时直接在浏览器 HTML 页面中内嵌交互式终端供人执行代码排查,其底层全都仰仗于 Python 对解释器运行状态的无保留暴露。
> “这种灵活性在绝大多数其他语言中根本不存在。作为 Python 程序员,我们对此习以为常,因为即便你自己不写这类代码,当你写一个 Django 应用而它崩溃时,Django 调试页弹出来,并打印出当时存在的所有状态……如果没有暴露这些底层,这根本不可能实现。” —— Armin Ronacher
[037:35] `sys.modules` 的全局单例锁定与多版本共存之困
解释器暴露的另一大核心状态是 `sys.modules` 字典。在 Python 中,模块一旦被加载就会被缓存在 `sys.modules` 中,这确保了应用中无论哪一部分再次 `import`(比如多个地方导入 `cgi` 模块),拿到的始终是完全相同的模块单例。然而,这个原本用于缓存的内部字典由于完全公开,成为了所有 Python 开发者默认依赖的事实标准: - 许多代码会先执行 `__import__(module_name)`,随后直接从 `sys.modules[module_name]` 中取出所需对象。 - 类反射、对象复制(如 `copy` 机制)以及动态加载广泛依赖它来反查类归属。 - **pickle 序列化**:深度依赖 `sys.modules` 来定位类并反序列化恢复对象。
这种全透明暴露带来的沉重代价是**多版本库共存的彻底破产**。长久以来社区多次尝试在同一个 Python 解释器进程中并行加载同一类库的不同版本,但由于整个生态都认定 `sys.modules` 是以扁平的模块名作为键,如果要支持版本隔离,就必须为字典引入版本标识符、命名空间作用域或多层间接寻址,这会直接击碎所有现存代码。
Armin 强调,这个设计包袱因 pickle 而被永久锁死:“因为每个人都依赖这个,尤其是 pickle,而且你必须明白,当人们把对象 pickle 序列化存盘时,是打算永远存下去的;Zope 的整个数据库完全建立在 pickle 对象之上。如果现在修改 pickle,所有历史上生成的 pickle 数据都会彻底损坏。所以在 pickle 彻底消亡之前,我们永远别想拥有带版本控制的 `sys.modules`,这令人沮丧。”
[039:57] 类型与类的底层分歧:为何 Python 难以原生嵌入?
在分析为什么移除 GIL 极其困难时,Armin 抛出了一个深层疑问:在 Python 的底层机制中,为什么内置的 `int` 是一个“类型(type)”,而用户自定义的 `int` 子类却是一个“类(class)”?(虽然在 Python 3 中表面上的打印输出有所统一,但底层的内存与查找模型依旧沿用原机制)。核心差异在于内存布局: 1. **内置类型(Type)**:拥有严格固定的内存地址,通常以 C 语言全局结构体变量(例如 `PyInt_Type`)的形式静态常驻在内存中。 2. **用户类(Class)**:是在运行时动态分配并保存在堆内存(Heap)上的普通对象。
当解释器执行两个数字相加等极高频操作时,为了避免昂贵的通用方法分发,底层必须以极快速度判定操作数是否为纯粹的整数。CPython 的做法极其直接:检查对象的类型指针是否精确等于静态全局变量 `&PyInt_Type` 的内存地址(单纯的指针比较)。
然而,这一优化引发了灾难性的连锁反应,使得 Python 几乎无法像其他现代引擎那样干净地嵌入到多线程宿主中:
| 运行时特性 | JavaScript 引擎 (如浏览器 V8) | CPython 解释器 | |:--- |:--- |:--- | | **隔离模型** | 每个 Tab 独立启动完全隔离的引擎实例 | 全局类型(如 `PyInt_Type`)以 C 全局变量形式存在 | | **多线程嵌入** | 宿主(如 Nginx、Browser)可分配多线程独立并发运行 | 无法在单进程内运行多个互不干扰的解释器 | | **对象修改风险** | 内部类型彼此状态隔离,无全局污染 | 静态类型的引用计数、属性补丁跨实例全局共享 |
如果像 Nginx 这样的高性能服务器希望将 Python 作为脚本语言,在四五个独立线程中分别启动一个完全独立的解释器实例,这在 CPython 中会直接崩溃或相互污染。因为所有解释器实例都会强行共享同一份带引用计数、可能被 monkey-patch 修改的全局 `PyTypeObject`。Armin 感慨道,这就是 Python 很难被真正嵌入到大型多线程系统中的首要病灶;他曾亲自尝试修改所有内置类型、引入一层间接寻址以实现线程级隔离的独立解释器,但整个解释器内部千丝万缕的紧密耦合让这项工程步履维艰。
[43:19](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2599s) 内部实现泄露的深远代价:GIL、多版本支持与性能天花板
Armin Ronacher 深入剖析了当解释器内部细节被暴露给外界后所引发的一连串无法挽回的后果。一旦开发者开始依赖这些底层机制,整个生态就掉入了一个“什么都无法再修改”的深不见底的兔子洞。最显著的代价就是无法移除全局解释器锁(GIL):在 CPython 中,全局仅有一套基础整型等静态类型定义,并在所有地方共享;这使得我们无法简单地在单个进程中让一个线程运行一个独立的解释器实例、另一个线程运行另一个互不干扰的解释器。更致命的是,解释器底层的引用计数(reference counting)等内存管理细节被直接暴露在每一个 C 扩展模块中,这种紧密耦合已经彻底烙印进语言生态,不破坏向后兼容就根本无法将其剥离。
与此同时,这种泄露还直接扼杀了更现代的语言特性演进。正如之前提到的,由于 `sys.modules` 作为一个完全暴露的解释器实现细节被广泛滥用,导致 Python 至今都极难实现多版本库共存(multi-version libraries)。整个解释器的复杂设计一路向上渗透,直接照射并影响到了 Python 语言的最顶层抽象。Armin 坦言,他现在完全理解 Python 现状的成因——这就是历史包袱,开发者不得不与这一段演进历史共存,哪怕是伤筋动骨的 Python 3 迁移也未能力挽狂澜。然而,对于正在设计或学习其他语言的人来说,绝不应该再重蹈覆辙。尽管这些设计对解释器执行速度和高并发能力构成了沉重的压制,形成了难以突破的技术天花板,但在当前绝大多数日常开发工作中,它尚不至于完全阻碍人们用 Python 把活干完。
在并行化和动态特性方面,Python 同样陷入了尴尬的夹缝境地。由于基础类型在全局共享,无法在多实例间隔离,使得并发改造寸步难行;而为了在如此繁复的内部机制下维持基本的运行速度,解释器又不得不在许多路径上“抄近道”,例如牺牲掉部分极度动态的元编程能力。相比之下,Ruby 可以自由地在运行时将加法操作动态重定义为减法,因为 Ruby 没有为整型加法硬编码特化的快速路径(fast path),而 Python 处于性能考量却不得不硬编码这些优化,从而在动态性上也失去了一定纯粹度。讲到这里,Armin 略带歉意地表示自己可能有些语无伦次,因为他意识到要用通俗易懂的方式向听众讲清解释器底层机制及其对生态的连锁反应确实相当困难,因此他建议听众不必拘泥于演讲主题,可以在接下来的提问环节自由发问。
- **无法摆脱 GIL**:共享的基础类型(如单一整型定义)与各 C 扩展中深度依赖的底层引用计数,导致现代线程隔离模型无法落地。 - **缺失多版本共存能力**:`sys.modules` 的透明暴露使得模块导入隔离和并行版本管理变得极其脆弱。 - **并发与性能天花板**:内部细节向高层渗透,锁死了运行时进行根本性优化的可能性。
```mermaid flowchart TD accTitle: 暴露内部实现对 Python 生态的连锁约束 accDescr: 展示 CPython 暴露底层细节如何导致引用计数渗透、静态类型共享,并最终形成无法移除 GIL 的锁死状态。
subgraph Leakage["泄露的底层细节"] L1["sys.modules 暴露"] L2["共享底层类型系统 (如单个全局整型)"] L3["引用计数与 C 扩展 API 深度绑定"] end
subgraph Consequences["架构与生态后果"] C1["难以支持多版本库共存"] C2["多线程解释器实例隔离失败"] C3["无法移除全局解释器锁 (GIL)"] C4["为维持性能硬编码快速路径,牺牲纯粹动态性"] end
L1 --> C1 L2 --> C2 L3 --> C3 L2 --> C3 C2 --> C3 L2 --> C4 ```
---
[46:36](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2796s) 问答交流:极小化公开 API 与字典特化优化的迷思
演讲结束后,一位现场听众提问并归纳核心观点:演讲的终极主旨是否在于“语言应当暴露出尽可能小的公共 API”?因为一旦把内部实现暴露在外且被外部大量依赖,后续就再也无法收回。Armin Ronacher 对此深表赞同,并以 JavaScript 为例进行了横向对比:JavaScript 在许多层面上做得非常出色,其暴露给宿主环境和开发者的底层解释器 API 极小甚至几乎不存在,因此开发者根本没有机会去依赖或滥用解释器的内部机制;而 Python 恰恰走了一条相反的路,暴露了庞大的底层细节,如今积重难返。Armin Ronacher 强调说:“因此,在很多方面,语言设计的正确做法就像 JavaScript 那样,保持公开暴露的解释器 API 非常小,甚至完全不存在,因为这样人们就绝不会陷入开始滥用它的境地。”
随后,该听众进一步追问特化分支(special cases)的问题:既然像整型加法特化或字典(dict)内部那样存在大量的特殊处理分支,若不采用这些特化逻辑,运行速度就会变得非常慢,那么到底能有什么替代方案?对此,Armin 提出了颠覆直觉的架构思考。他指出,CPython 为了性能不断塞入特殊分支的处理方式在现代硬件体系下走入了误区。现代计算机之所以能高效运行代码,核心依赖于 CPU 缓存友好性(cache locality)、极小的指令内存占用(footprint)以及对相同内存区域的循环复用,从而避免缓存失效(cache invalidation)。
在 Python 运行时中,解释器在字典查找和操作上耗费的时间往往超过了解释器主循环的其他所有部分。如果解释器能够大幅精简单个 Python 对象的数据结构与复杂度,不堆叠大量杂乱的分支逻辑,就能显著压缩高频热点代码(hot code paths)的体积。更少且更纯粹的代码更容易被 CPU 完整缓存在 L1/L2 Cache 中,分支预测成功的几率也大大提升。Armin 尖锐地指出了当下的讽刺现状:“我认为这里的讽刺之处在于,我们比 Ruby 缺乏动态性,但由于这一切,我们在每个操作码(op code)上的执行速度可能比 Ruby 还要慢。” 他认为,过去大家看到运行缓慢就盲目为常见情况(common cases)追加硬编码特化,但如果当初能坚持精简整体架构,反而能让不常见的通用情况获得大幅提速,同时兼顾更高的动态灵活性与硬件亲和力。提问者由衷感谢这一极具洞察力的解答,全场随之响起热烈掌声,演讲圆满结束。
- **API 暴露原则**:现代语言(如 JavaScript)通过隐藏解释器内部细节,避免了生态对底层实现的过度耦合,从而获得了极大的演进自由度。 - **缓存与现代硬件认知**:快速执行的核心不在于堆砌 C 语言层面的特殊条件分支,而在于降低指令占用、提升缓存局部性与分支预测成功率。 - **性能架构反思**:过度特化常见路径导致代码膨胀和缓存穿透,反而让整体操作码执行速度落后于设计更精简、更动态的解释器系统。
## Notable quotes > [46:36](https://www.youtube.com/watch?v=qCGofLIzX6g&t=2796s) 在很多方面,语言设计的正确做法就像 JavaScript 那样,保持公开暴露的解释器 API 非常小,甚至完全不存在,因为这样人们就绝不会陷入开始滥用它的境地。 — Armin Ronacher
> [30:03](https://www.youtube.com/watch?v=qCGofLIzX6g&t=1803s) 我们所使用的语言,几乎完完全全就是那个现存的解释器本身 — Armin Ronacher
## Mentioned Armin Ronacher, Python, CPython, PyPy, Ruby, JavaScript, Go, Rust, Swift, Flask, Django, Sentry, Lektor, Jinja, Werkzeug, MarkupSafe, Zope, twisted.manhole, Guido van Rossum, Unicode 联盟, ISO
[Source](https://www.youtube.com/watch?v=qCGofLIzX6g)