python - 无限嵌套列表中到底发生了什么？

Question

可以在Python中创建无限的嵌套列表。这很明显，尽管不受欢迎并且绝对没有用，但这是一个已知事实。

>>> a = [0]
>>> a[0] = a
>>> a
[[...]]
>>> a[0] == a
True

我的问题是，这里发生了什么:

>>> a = [0]
>>> b = [0]
>>> a[0], b[0] = b, a
>>> a
[[[...]]]
>>> b
[[[...]]]
>>> a == b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: maximum recursion depth exceeded in cmp
>>> a[0] == b
True
>>> a[0][0] == b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: maximum recursion depth exceeded in cmp
>>> a[0][0][0] == b
True
>>> 

当我试图理解它时，会更深入地了解我，就像我的大脑将要爆炸一样。我看到，a包含b，其中包含a依此类推...

现在我对这一问题提出疑问。我们这里真的有两个列表，还是只有一个？这样的事情如何存储在内存中？使程序员实现如此奇怪的东西的目的可能是什么？

拜托，不要把这个问题当回事。并且不要忘记，编程有时会很有趣。

Answer 1

免责声明:我不使用Python，所以我说的某些话可能是错误的。 Python专家，随时纠正我。

好问题。我认为中心的误解(如果我什至不能这样称呼；您到达所用思维过程的方式是完全合理的)，这会提示您提出以下问题:

当我编写b[0] = a时，并不意味着a在b中。这意味着b包含指向a指向的对象的引用。

变量a和b本身甚至都不是“事物”，它们本身也只是指向内存中其他匿名“事物”的指针。

引用的概念是从非编程世界的一大飞跃，因此，请牢记这一点，逐步完成程序:

>>> a = [0]

您创建一个列表，其中恰好有东西(暂时忽略该列表)。重要的是列表。该列表将存储在内存中。假设它存储在内存位置1001中。然后，分配 =创建一个变量 a，编程语言允许您稍后使用它。此时，内存中有一些列表对象以及对它的引用，可以使用名称 a进行访问。

>>> b = [0]

这对 b做同样的事情。在存储位置1002中存储了一个新列表。编程语言创建了一个引用 b，您可以使用它来引用存储位置并进而引用该列表对象。

>>> a[0], b[0] = b, a

这完成了两个相同的事情，所以让我们专注于一个: a[0] = b。这确实很花哨。由于 b是对它的引用，因此它首先评估等式的右侧，查看变量 b并获取内存中的相应对象(内存对象＃1002)。同样，在左侧发生的事情也很奇特。 a是一个指向列表(内存对象＃1001)的变量，但是内存对象＃1001本身具有许多引用。这些引用具有诸如 a的数字索引，而不是使用诸如 b和 0这样的名称的引用。因此，现在，此操作是 a拉起一堆索引引用的内存对象＃1001，然后转到索引为0的引用(以前，此引用指向实际数字 0，这是您所做的事情)在第1行中)，然后将该引用(即，存储对象＃1001中的第一个也是唯一的引用)重新指向方程右侧的内容求值。因此，现在，对象＃1001的第0个引用指向对象＃1002。

>>> a
[[[...]]]
>>> b
[[[...]]]

这只是编程语言的幻想。当您只是要求它评估 a时，它将拉出内存对象(位置＃1001的列表)，使用自身的魔法检测到它是无限的，并如此渲染自己。

>>> a == b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: maximum recursion depth exceeded in cmp

该语句的失败与Python如何进行比较有关。当您将一个对象与其自身进行比较时，它会立即求值为true。当您比较并反对另一个对象时，它使用“魔术”来确定相等性是对还是错。对于Python中的列表，它将查看每个列表中的每个项目并检查它们是否相等(依次使用项目自己的相等性检查方法)。因此，当您尝试 a == b时。它的工作是首先挖掘b(对象＃1002)和a(对象＃1001)，然后意识到它们在内存中是不同的，因此转到其递归列表检查器。它通过遍历两个列表来做到这一点。对象＃1001具有一个索引为0的元素，该元素指向对象＃1002。对象＃1002具有一个索引为0的元素，该元素指向对象＃1001。因此，程序得出以下结论:如果对象＃1001和＃1002的所有引用都指向同一事物，则它们相等；如果＃1002(＃1001的唯一引用指向)和＃1001(＃1002的唯一引用指向)，则认为是错误。同样的事情。这种平等检查永远不会停止。在任何不停止的列表中都会发生同样的事情。您可以这样做 c = [0]; d = [0]; c[0] = d; d[0] = c和 a == c将引发相同的错误。

>>> a[0] == b
True

正如我在上一段中所暗示的那样，由于Python采用了快捷方式，因此这立即变为true。它不需要比较列表内容，因为 a[0]指向对象＃1002，而 b指向对象＃1002。 Python检测到它们在字面意义上是相同的(它们是相同的“事物”)，甚至不用费心检查内容。

>>> a[0][0] == b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: maximum recursion depth exceeded in cmp

由于 a[0][0]最终指向对象＃1001，因此回到错误状态。身份检查失败，然后退回递归内容检查，该检查永远不会结束。

>>> a[0][0][0] == b
True

a[0][0][0]再次指向对象＃1002， b也指向对象。跳过递归检查，比较立即返回true。

与您的特定代码段不直接相关的高级jibber jabber:

因为所有引用都引用了其他对象，所以即使存在“无限”嵌套，a所引用的对象(如我所说的对象＃1001)和b所引用的对象(＃ 1002)的内存大小相同。实际上，该大小非常小，因为它们都是指向各个其他内存位置的列表。

还值得注意的是，在较少“通用”语言中，将两个引用与==进行比较将返回true ，只有在它们指向的内存对象相同的意义上，即两个引用都指向内存中的同一位置，才会返回。 Java就是一个例子。这种语言中出现的风格惯例是在对象本身上定义方法/函数(对于Java，通常称为equals())以进行自定义相等性测试。 Python为列表开箱即用。我并不特别了解Python，但至少在Ruby中，==重载是因为在执行someobject == otherobject时，它实际上在==上调用了一个称为someobject的方法(可以覆盖)。从理论上讲，没有什么可以阻止您使someobject == otherobject返回 bool 值以外的东西。