Python中列表和元组的区别是什么？

哪个更有效？每个的典型用途是什么？

列表是可变的（可以更改），元组是不可变的。典型用法：听起来很老套，但当需要更改值时，可以使用列表。元组通常更有效一些，因为它们是不可变的（除非您像列表一样使用它们并大量复制它们…

列表是可变的，您可以向其中添加元素。元组不是，这意味着它（稍微）更高效。元组也是可散列的，因此可以用作字典中的键

---

阅读。

列表是可变序列，有很多方法（包括变异和非变异方法），它们最常用作通用容器（它们的项可以是任何类型的对象，尽管有时认为列表具有相同类型的项或等效使用相同类型的项是更好的样式）

元组是不可变的序列，只有很少的方法（都是非变异的特殊方法），当您需要将容器用作集合中的项或dict中的键时（尽管这些项也必须是不可变的，例如字符串、数字或其他嵌套元组，才能工作），最常使用这些方法。它们的项可以是任何类型的对象，元组有许多不同类型的项是完全正常的

在某些情况下，元组或列表也可以起到同样的作用，在这种情况下，元组更小、构建速度更快的事实可以用来改变决策，支持元组。例如，当一个函数需要返回多个结果时，使用它是最正常的

return fee, fie, foo, fum

<pre>
Container   Notation     Index [n:m]   Mutable   Hashable
=========   ==========   ===========   =======   ========
String      ' ' or " "    position     Immutable    Yes
Range       range(,,)     position     Immutable    Yes
Tuple       (,)           position     Immutable    Yes
List        [,]           position     Yes          No
Set         {,}           No           Yes          No
Dict        {k:v,k:v}     by key       Yes          No
</pre>

i、 例如，返回一个包含四个相关项的元组，而不是

return [fee, fie, foo, fum]

i、 例如，返回一个包含四个项的列表——除了（性能上的小提高）“返回一个元组”这一常见习语还处理了一个问题，即返回的多个结果的类型通常不相同，也不可互换，因此，从风格上讲，使用列表可能被认为是一个更可疑的选择

tuple的一个有用变体是它的子类型（需要Python2.6或更高版本），它允许您通过名称（使用属性语法）以及索引（通常的方式）访问项目。例如，如果模块顶部有一个

import collections

，则上面的

return

语句可能会变成

freturn = collections.namedtuple('freturn', 'fee fie foo fum')

def f():
  ...
return freturn(fee, fie, foo, fum)

现在，

f（）

的调用者可以像以前一样将其返回值用作元组，但会得到很好的选择，例如…：

r = f()
print r.fie

而不是那些不那么清晰易读的

print r[1]

需要注意的是，与直接使用元组相比，使用

集合生成的命名元组子类。namedtuple

基本上没有额外的开销，或者如文档所述

它们重量轻，不需要任何材料 比常规元组内存更多

在阅读了一些之后，我创建了下表，以显示六个iterable容器之间的主要差异

而可变类型的键将导致TypeError：

>a[{5}]=56
回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
TypeError:无法损坏的类型：“set”
>>>a[[5]]=56
回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
TypeError:不可损坏的类型：“列表”
>>>a[{5:6}]=56
回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
TypeError:无法损坏的类型：“dict”
>>>a[-555]=666
>>> 

---

有关更多详细信息，请参阅和。

相关（如果不是重复）：@Adam-我认为不是重复的，但非常相关。该链接完全忽略了set（以及其他不太常用的集合，基本上是其他集合的变体-frozenset是一个不可变的集合，它是一个列表（带有一点语法糖），等等）。问题中仍然没有提到+1

set

，那么为什么要在回答中提到呢？是的，

set

和

frozenset

在

list

和

tuple

之间有可比的差异。虽然我没有像使用

list

s和

tuple

s那样频繁地使用

set

s，但它们是我工具箱中非常宝贵的工具。我在挑剔，但不变性并不意味着可散列性，就像可变意味着某些东西不可散列一样。例如，默认情况下，用户定义类的实例是可散列的，但这并不意味着它们是不可变的。诚然，不可变类型不可散列是不寻常的，但这肯定是可能的。我认为文档必须掩盖这一点，在命名元组的许多实例中进行调整，没有额外的开销，但使用了某些额外的内存，因为您有效地动态创建了一个新类型（当然，它有一些内存占用，尽管很小）。（顺便说一句，还是得到了+1，这是一个非常彻底的答案）。

>>> a
{range(2, 5, 2): 'range', 3: 15, 4.5: 16, 'llmjxm': 'c', -555: 666, -4.5: -25, (5, 6, 7): 'blue', 'abc3': 215, (1, 2, 3): 'red'}
>>> for item in a.keys():
...     print(item, '\t\t==>>', a[item])
... 
range(2, 5, 2)      ==>> range
3       ==>> 15
4.5         ==>> 16
llmjxm      ==>> c
-555        ==>> 666
-4.5        ==>> -25
(5, 6, 7)       ==>> blue
abc3        ==>> 215
(1, 2, 3)       ==>> red
>>> 

>>> a[{5}] = 56
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> a[[5]] = 56
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> a[{5:6}] = 56
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'dict'
>>> a[-555] = 666
>>>