调用参数堆栈如何在 Python 中工作？

Question

我正在学习 python 并试图了解堆栈在 python 中是如何工作的。我有些疑惑。我知道堆栈是如何工作的，并且我已经阅读了很多关于它的文章和教程。我在stackoverflow上阅读了很多帖子，它们都很好，但我仍然有些疑问。

到目前为止，我已经阅读了堆栈存储和函数的返回值。它由 LIFO 负责人工作。

只有堆栈的第一个值会返回并存储在顶部。

所以我的问题是 - 假设有四个变量：

a = 9
b = 2
c = 13
d = 4

它们按函数调用值的顺序存储在堆栈中，例如：

sum = a + d
sum = b + c

a = 9
d = 4
b = 2
c = 13

他们会从上到下返回。现在我的困惑是-如果任何操作需要使用d和c，而堆栈从顶部返回值，堆栈将如何获取值d和c，只要它们在堆栈中间. stack会先返回a再返回d吗？？

这就是混乱。

Answer 1

如果您对 python 在底层的工作原理感兴趣，可以使用标准 CPython 库 dis。 这是您的测试代码的输出：

>>> import dis
>>> def test():
...     a = 9
...     b = 2
...     c = 13
...     d = 14
...     sum1 = a + d
...     sum2 = b + c
... 
>>> dis.dis(test)
  2           0 LOAD_CONST               1 (9)
              3 STORE_FAST               0 (a)

  3           6 LOAD_CONST               2 (2)
              9 STORE_FAST               1 (b)

  4          12 LOAD_CONST               3 (13)
             15 STORE_FAST               2 (c)

  5          18 LOAD_CONST               4 (14)
             21 STORE_FAST               3 (d)

  6          24 LOAD_FAST                0 (a)
             27 LOAD_FAST                3 (d)
             30 BINARY_ADD          
             31 STORE_FAST               4 (sum1)

  7          34 LOAD_FAST                1 (b)
             37 LOAD_FAST                2 (c)
             40 BINARY_ADD          
             41 STORE_FAST               5 (sum2)
             44 LOAD_CONST               0 (None)
             47 RETURN_VALUE        

如您所见，它与堆栈无关。 即使调整后的代码也不会这样做，比如

>>> def test2(a,b,c,d):
...     sum1 = a + d
...     sum2 = b + c
... 
>>> dis.dis(test2)
  2           0 LOAD_FAST                0 (a)
              3 LOAD_FAST                3 (d)
              6 BINARY_ADD          
              7 STORE_FAST               4 (sum1)

  3          10 LOAD_FAST                1 (b)
             13 LOAD_FAST                2 (c)
             16 BINARY_ADD          
             17 STORE_FAST               5 (sum2)
             20 LOAD_CONST               0 (None)
             23 RETURN_VALUE        

如果您对计算中的一般堆栈概念感兴趣，您应该切换到一些低级（2.5 代语言，如 C），或者更深入地学习汇编语言。

阅读各种调用约定可能也是另一个不错的起点（例如x86 calling conventions）

Answer 2

虽然堆栈作为后进先出法工作，但您必须小心哪些数据结构正在被堆栈。例如，许多编程语言在调用函数时使用堆栈来存储参数和局部变量。但堆叠的是整个调用框架，而不是框架中的单个变量。

例如，在 C 中，我可能有局部变量 a、b、c、d “在堆栈上”，但这意味着它们存储在距帧开始的已知固定偏移处。变量可以按任何顺序访问，并且它们不会四处移动（除了编译器可能正在做的优化）。

Python 让它变得更复杂一些。至少在 CPython 中，幕后有一个堆栈框架，但您看到的局部变量实际上存储在一个函数实例对象上的一个数组中（参见下面的 shadowranger 注释），该实例对象构成函数的本地命名空间。任何时候都可以通过dict访问所有变量。

在这些情况下，局部变量本身不是 LIFO，只要您知道它们在命名空间字典中的偏移量或名称，就可以任意访问。