列表和元组有什么区别？

有什么不同？

元组/列表有什么优点/缺点？

Answer 1

除了元组是不可变的，还有一个应该指导它们用法的语义区别。 元组是异构数据结构（即它们的条目具有不同的含义），而列表是同类的序列。 元组有结构，名单有序。

使用这种区别使得代码更加明确和易于理解。

一个例子是成对的页面和行号来引用书中的位置，例如：

 my_location = (42, 11) # page number, line number 

然后，您可以将其作为字典中的键来存储位置上的笔记。 另一方面，列表可以用来存储多个位置。 当然，人们可能想要添加或删除列表中的位置，所以列表是可变的。 另一方面，从现有位置添加或移除项目是没有意义的，因此元组是不可变的。

可能有些情况下，您想要更改现有位置元组中的项目，例如在遍历页面的行时。 但是元组的不可变性迫使你为每个新值创build一个新的位置元组。 这看起来似乎很不方便，但是像这样使用不可变的数据是价值types和函数式编程技术的基石，它们可以具有实质性的优点。

在这个问题上有一些有趣的文章，例如“Python元组不仅仅是常量列表”或者“在Python中理解元组与列表” 。 官方的Python文档也提到了这一点 （ “元组是不可变的，通常包含一个异构的序列…” ）。

在像Haskell这样的静态types语言中，元组中的值通常具有不同的types，并且元组的长度必须是固定的。 在一个列表中，值都是相同的types，长度不固定。 所以差异非常明显。

最后是Python中的namedtuple ，这是有道理的，因为一个元组已经有了结构。 这强调了元组是类和实例的轻量级替代的想法。

Answer 2

列表和元组之间的区别

1. 文字

    someTuple = (1,2) someList = [1,2] 

2. 尺寸

    a = tuple(range(1000)) b = list(range(1000)) a.__sizeof__() # 8024 b.__sizeof__() # 9088 

   由于元组操作的规模较小，所以它变得更快一些，但是除非你有大量的元素，否则就不必多说了。

3. 允许的操作

    b = [1,2] b[0] = 3 # [3, 2] a = (1,2) a[0] = 3 # Error 

   这也意味着你不能删除一个元素或sorting元组。 然而，你可以添加新元素到列表和元组，唯一的区别是你将通过添加元素来改变元组的id

    a = (1,2) b = [1,2] id(a) # 140230916716520 id(b) # 748527696 a += (3,) # (1, 2, 3) b += [3] # [1, 2, 3] id(a) # 140230916878160 id(b) # 748527696 

4. 用法

   由于列表是可变的，因此不能将其用作字典中的键，而可以使用元组。

    a = (1,2) b = [1,2] c = {a: 1} # OK c = {b: 1} # Error 

Answer 3

如果你去散步，你可以在（x，y）元组中随时记下你的坐标。

如果你想logging你的旅程，你可以每隔几秒将你的位置添加到列表中。

但是你不能这样做。

Answer 4

关键的区别是元组是不可变的。 这意味着，一旦创build了元组，就不能更改元组中的值。

所以，如果你需要改变值使用列表。

对元组的好处：

1. 性能略有提高。
2. 作为一个元组是不可变的，它可以用作字典中的一个键。
3. 如果你不能改变任何人，也就是说你不需要担心任何API函数等等，而不会被要求改变你的元组。

Answer 5

列表是可变的; 元组不是

从docs.python.org/2/tutorial/datastructures.html

元组是不可变的，并且通常包含通过解包（参见本节后面的内容）或索引（甚至在命名的情况下通过属性）访问的异构元素序列。 列表是可变的，并且它们的元素通常是同类的，并且通过迭代列表来访问。

Answer 6

列表用于循环，元组是用于结构，即"%s %s" %tuple 。

列表通常是同构的，元组通常是异构的。

列表是可变长度的，元组是固定长度的。

Answer 7

有人提到 ，差异主要是语义上的：人们期望一个元组和列表来表示不同的信息。 但是这不仅仅是一个指导方针， 一些图书馆的行为实际上是基于他们所传递的信息。 拿NumPy为例（复制从另一个职位 ，我要求更多的例子）：

 >>> import numpy as np >>> a = np.arange(9).reshape(3,3) >>> a array([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) >>> idx = (1,1) >>> a[idx] 4 >>> idx = [1,1] >>> a[idx] array([[3, 4, 5], [3, 4, 5]]) 

重点是，虽然NumPy可能不是标准库的一部分，但它是一个主要的 Python库，在NumPy列表和元组中是完全不同的东西。

Answer 8

这是Python列表的一个例子：

 my_list = [0,1,2,3,4] top_rock_list = ["Bohemian Rhapsody","Kashmir","Sweet Emotion", "Fortunate Son"] 

这是Python元组的一个例子：

 my_tuple = (a,b,c,d,e) celebrity_tuple = ("John", "Wayne", 90210, "Actor", "Male", "Dead") 

Python列表和元组是相似的，它们都是有序的值集合。 除了使用括号“[…，…]”和使用圆括号“（…，…）”的元组创build列表之间的浅表差异之外，核心技术“Python语法中的硬编码”差异是特定元组的元素是不可变的，而列表是可变的（…所以只有元组是可哈希的，可以用作字典/哈希键！）。 这导致了他们如何使用或不能使用（由语法强制先验）以及人们如何select使用它们的差异（被鼓励为'最佳实践'，后验，这是聪明的程序员所做的）。 在使用元组和使用列表时区分后验差异的主要区别在于人们赋予元素的顺序的含义 。

对于元组来说，“秩序”只不过是一个保存信息的特定“结构”。 在第一个字段中find的值可以很容易地切换到第二个字段，因为每个字段提供了两个不同维度或尺度的值。 它们为不同types的问题提供答案，并且通常具有以下forms： 对于给定的对象/主题，它的属性是什么？ 对象/主题保持不变，属性不同。

对于列表，“顺序”表示顺序或方向性。 第二个元素必须位于第一个元素之后 ，因为它位于第二个位置，基于特定的公共比例或维度。 这些元素是作为一个整体来考虑的，主要为一个典型的单个问题提供答案， 对于一个给定的属性，这些对象/主题是如何比较的？ 属性保持不变，对象/主题不同。

stream行文化和程序员中有不计其数的例子，不符合这些差异，有无数的人可能会用沙拉叉作主菜。 在一天结束的时候，这很好，都可以完成工作。

总结一些更好的细节

相似点：

1. 重复 – 元组和列表都允许重复

2. 索引，select和切片 – 元组和列表索引使用括号内的整数值。 所以，如果你想要一个给定的列表或元组的前3个值，语法将是相同的：

    >>> my_list[0:3] [0,1,2] >>> my_tuple[0:3] [a,b,c] 

3. 比较和sorting – 两个元组或两个列表通过它们的第一个元素进行比较，如果有联系，则通过第二个元素进行比较，依此类推。 先前的元素显示不同之后，没有再关注随后的元素。

    >>> [0,2,0,0,0,0]>[0,0,0,0,0,500] True >>> (0,2,0,0,0,0)>(0,0,0,0,0,500) True 

差异：根据定义，先验

1. 语法 – 列表使用[]，元组使用（）

2. 可变性 – 给定列表中的元素是可变的，给定元组中的元素不可变。

    # Lists are mutable: >>> top_rock_list ['Bohemian Rhapsody', 'Kashmir', 'Sweet Emotion', 'Fortunate Son'] >>> top_rock_list[1] 'Kashmir' >>> top_rock_list[1] = "Stairway to Heaven" >>> top_rock_list ['Bohemian Rhapsody', 'Stairway to Heaven', 'Sweet Emotion', 'Fortunate Son'] # Tuples are NOT mutable: >>> celebrity_tuple ('John', 'Wayne', 90210, 'Actor', 'Male', 'Dead') >>> celebrity_tuple[5] 'Dead' >>> celebrity_tuple[5]="Alive" Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment 

3. 散列表（字典） – 由于散列表（字典）要求其键是可散列的，因此是不可变的，只有元组可以作为字典键，而不是列表。

    #Lists CAN'T act as keys for hashtables(dictionaries) >>> my_dict = {[a,b,c]:"some value"} Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list' #Tuples CAN act as keys for hashtables(dictionaries) >>> my_dict = {("John","Wayne"): 90210} >>> my_dict {('John', 'Wayne'): 90210} 

差异 – 使用中的后验

1. 元素的异质性与元素的异质性 – 通常列表对象是同质的，元组对象是异构的。 也就是说，列表是用于相同types的对象/主体（如所有总统候选人，或所有歌曲，或所有跑步者），虽然它不是被迫的），而元组更多是异构对象。

2. 循环与结构 – 虽然两者都允许循环（对于my_list中的x），但只有在列表中才有意义。 元组更适合构造和呈现信息（％s％s存在于％s中，是％s，现在是％s％（“John”，“Wayne”，90210，“Actor”，“Dead”））

Answer 9

列表旨在是同构序列，而元组是异构数据结构。

Answer 10

列表的值可以随时更改，但是元组的值不能改变。

优点和缺点取决于使用。 如果你有这样一个你永远不想改变的数据，那么你应该使用元组，否则列表是最好的select。

Answer 11

PEP 484-Type Hints指出tuple的元素types可以单独input; 所以你可以说Tuple[str, int, float] ; 但是Listtypes的类只能使用一个types参数： List[str] ，这意味着2的区别实际上是前者是异构的，而后者本质上是同类的。

此外，标准库大多使用元组作为返回值的标准函数返回一个struct 。

Answer 12

首先，它们都是Python中的非标量对象（也称为复合对象）。

• 元组，有序元素序列（可以包含任何没有锯齿问题的对象）
  • 不可变（tuple，int，float，str）
  • 使用+连接（当然会创build全新的元组）
  • 索引
  • 切片
  • 单身(3,) # -> (3)而不是(3) # -> 3
• 列表（其他语言的数组），有序的值序列
  • 易变的
  • 辛格尔顿[3]
  • 克隆new_array = origin_array[:]
  • 清单理解[x**2 for x in range(1,7)]给你[1,4,9,16,25,36] （不可读）

使用列表也可能会导致别名错误（两个不同的path指向同一个对象）。

Answer 13

从5.3的文档方向引用。 元组和序列 ：

尽pipe元组可能看起来与列表类似，但是它们通常用于不同的情况和不同的目的。 元组是不可变的 ，并且通常包含通过解包 （本节后面的内容）或索引 （甚至在命名的情况下通过属性）访问的异构元素序列 。 列表是可变的 ，并且它们的元素通常是同类的 ，并且通过迭代列表来访问。

Answer 14

列表是可变的，元组是不可变的。 可变和不可变的主要区别是当你尝试附加一个项目时的内存使用情况。

当你创build一个variables时，一些固定的内存被分配给variables。 如果它是一个列表，分配的内存比实际使用的多。 例如，如果当前的内存分配是100个字节，当你想追加第101个字节时，可能会分配另外的100个字节（在这种情况下总共200个字节）。

但是，如果你知道你不经常添加新的元素，那么你应该使用元组。 元组指定所需内存的大小，从而节省内存，特别是在使用大块内存时。

Answer 15

列表是可变的，元组是不可变的。 只要考虑这个例子。

 a = ["1", "2", "ra", "sa"] #list b = ("1", "2", "ra", "sa") #tuple 

现在改变列表和元组的索引值。

 a[2] = 1000 print a #output : ['1', '2', 1000, 'sa'] b[2] = 1000 print b #output : TypeError: 'tuple' object does not support item assignment. 

因此certificate下面的代码对于元组是无效的，因为我们试图更新一个不允许的元组。