为什么我们需要 Python 中的元组（或任何不可变数据类型）？

Question

我已经阅读了一些 Python 教程（其中之一是 Dive Into Python），以及 Python.org 上的语言参考 - 我不明白为什么该语言需要元组。

与列表或集合相比，元组没有方法，如果我必须将元组转换为集合或列表才能对它们进行排序，那么首先使用元组有什么意义？

不变性？

为什么有人会关心变量在内存中的位置是否与最初分配时不同？ Python 中的整个不可变性业务似乎被过分强调了。

在 C/C++ 中，如果我分配一个指针并指向某个有效内存，我不关心地址的位置，只要在我使用它之前它不为空即可。

每当我引用该变量时，我不需要知道指针是否仍指向原始地址。我只是检查 null 并使用它（或不使用它）。

在 Python 中，当我分配一个字符串（或元组）将其分配给 x，然后修改该字符串时，我为什么要关心它是否是原始对象？只要变量指向我的数据，这就是最重要的。

>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

x还是引用了我想要的数据，为什么还要关心它的id是相同还是不同呢？

Answer 1

1. 不可变对象可以进行大量优化；这大概就是为什么字符串在 Java 中也是不可变的，Java 是完全独立开发但与 Python 几乎同时开发的，而且在真正的函数式语言中几乎所有东西都是不可变的。

2. 尤其是在 Python 中，只有不可变对象可以是可散列的（因此，集合的成员或字典中的键）。同样，这提供了优化，但不仅仅是“实质性”（设计体面的哈希表存储完全可变的对象是一场噩梦——要么你在散列后立即复制所有内容，要么检查对象的散列是否是噩梦自从你上次提到它后，它已经变了。

优化问题示例：

$ python -mtimeit '["fee", "fie", "fo", "fum"]'
1000000 loops, best of 3: 0.432 usec per loop
$ python -mtimeit '("fee", "fie", "fo", "fum")'
10000000 loops, best of 3: 0.0563 usec per loop

Answer 2

以上答案都没有指出元组与列表的真正问题，许多 Python 新手似乎并不完全理解。

元组和列表有不同的用途。列表存储同质数据。你可以而且应该有一个这样的列表：

["Bob", "Joe", "John", "Sam"]

正确使用列表的原因是因为这些都是同质类型的数据，特别是人名。但请列出这样的清单：

["Billy", "Bob", "Joe", 42]

该列表是一个人的全名，以及他们的年龄。这不是一种数据。存储该信息的正确方法是在元组或对象中。假设我们有一些：

[("Billy", "Bob", "Joe", 42), ("Robert", "", "Smith", 31)]

元组和列表的不变性和可变性并不是主要区别。列表是相同类型项目的列表：文件、名称、对象。元组是一组不同类型的对象。它们有不同的用途，许多 Python 编码人员滥用列表来理解元组的用途。

请不要。

---

编辑：

我认为这篇博文解释了为什么我认为这比我做的更好：

• Understanding tuples vs. lists in Python - E-Scribe

Answer 3

如果我必须将元组转换为集合或列表才能对它们进行排序，那么首先使用元组有什么意义？

在这种特殊情况下，可能没有意义。这不是问题，因为这不是您考虑使用元组的情况之一。

正如您所指出的，元组是不可变的。具有不可变类型的原因适用于元组：

• 复制效率：与其复制不可变对象，不如给它取别名（将变量绑定到引用）
• 比较效率：当您使用按引用复制时，您可以通过比较位置而不是内容来比较两个变量
• 实习：您最多需要存储任何不可变值的一份副本
• 无需在并发代码中同步对不可变对象的访问
• const 正确性：不应允许某些值更改。这（对我而言）是不可变类型的主要原因。

请注意，特定的 Python 实现可能无法使用上述所有功能。

字典键必须是不可变的，否则更改键对象的属性会使底层数据结构的不变量无效。因此元组可以潜在地用作键。这是 const 正确性的结果。

另见“Introducing tuples”，来自Dive Into Python。

Answer 4

有时我们喜欢使用对象作为字典键

不管怎样，最近 (2.6+) 元组增长了 index() 和 count() 方法

Answer 5

我一直发现为相同的基本数据结构（数组）设置两种完全不同的类型是一种尴尬的设计，但在实践中并不是一个真正的问题。 （每种语言都有其缺陷，包括 Python，但这不是一个重要的。）

为什么有人会关心变量在内存中的位置是否与最初分配时不同？ Python 中的整个不可变性业务似乎被过分强调了。

这些是不同的东西。可变性与它在内存中的存储位置无关。这意味着它指向的东西不能改变。

Python 对象在创建后不能更改位置，无论是否可变。 （更准确地说，id() 的值不能改变——实际上也是一样。）可变对象的内部存储可以改变，但这是一个隐藏的实现细节。

>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

这不是修改（“变异”）变量；它正在创建一个具有相同名称的新变量，并丢弃旧变量。与变异操作比较：

>>> a = [1,2,3]
>>> id(a)
3084599212L
>>> a[1] = 5
>>> a
[1, 5, 3]
>>> id(a)
3084599212L

正如其他人所指出的，这允许使用数组作为字典的键，以及其他需要不变性的数据结构。

请注意，字典的键不必是完全不可变的。只有用作密钥的部分需要是不可变的；对于某些用途，这是一个重要的区别。例如，您可以有一个代表用户的类，它通过唯一用户名比较相等性和哈希值。然后，您可以在类上挂起其他可变数据——“用户已登录”等。由于这不会影响相等性或散列，因此将其用作字典中的键是可能且完全有效的。这在 Python 中并不常见。我只是指出这一点，因为有几个人声称密钥需要是“不可变的”，这只是部分正确。不过，我在 C++ 地图和集合中使用过很多次。

Answer 6

正如 gnibbler 在评论中提供的那样，Guido 的 opinion 未被完全接受/欣赏：“列表用于同质数据，元组用于异构数据”。当然，许多反对者将此解释为意味着列表的所有元素都应该属于同一类型。

我喜欢以不同的方式看待它，不像others过去也有：

blue= 0, 0, 255
alist= ["red", "green", blue]

请注意，我认为 alist 是同质的，即使 type(alist[1]) != type(alist[2])。

如果我可以更改元素的顺序并且我的代码不会出现问题（除了假设，例如“它应该被排序”），那么应该使用一个列表。如果不是（如上面的元组blue），那么我应该使用一个元组。

Answer 7

它们很重要，因为它们向调用者保证它们传递的对象不会发生变异。 如果你这样做：

a = [1,1,1]
doWork(a)

调用者无法保证调用后a的值。 不过，

a = (1,1,1)
doWorK(a)

现在您作为调用者或作为此代码的读者知道 a 是相同的。 在这种情况下，您始终可以复制列表并传递它，但现在您正在浪费周期，而不是使用更具语义意义的语言构造。

Answer 8

你可以看到here对此进行一些讨论

Answer 9

您的问题（以及后续 cmets）关注 id() 是否在分配期间发生变化。关注不可变对象替换和可变对象修改之间差异的这种后续影响而不是差异本身可能不是最好的方法。

在我们继续之前，请确保下面展示的行为是您对 Python 的期望。

>>> a1 = [1]
>>> a2 = a1
>>> print a2[0]
1
>>> a1[0] = 2
>>> print a2[0]
2

在这种情况下，a2 的内容发生了变化，尽管只有 a1 被分配了一个新值。对比如下：

>>> a1 = (1,)
>>> a2 = a1
>>> print a2[0]
1
>>> a1 = (2,)
>>> print a2[0]
1

在后一种情况下，我们替换了整个列表，而不是更新其内容。 对于元组等不可变类型，这是唯一允许的行为。

为什么这很重要？假设你有一个字典：

>>> t1 = (1,2)
>>> d1 = { t1 : 'three' }
>>> print d1
{(1,2): 'three'}
>>> t1[0] = 0  ## results in a TypeError, as tuples cannot be modified
>>> t1 = (2,3) ## creates a new tuple, does not modify the old one
>>> print d1   ## as seen here, the dict is still intact
{(1,2): 'three'}

使用元组，字典可以安全地将其键“从其下方”更改为散列为不同值的项。这对于高效实施至关重要。