列表和元组之间有什么区别？

有什么不同？

元组/列表的优点/缺点是什么？

1> nikow..：

---

除了元组是不可变的之外,还有一个语义上的区别应该指导它们的使用.元组是异构数据结构(即,它们的条目具有不同的含义),而列表是同构序列.元组有结构,列表有顺序.

使用这种区别使代码更加明确和易懂.

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

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

然后,您可以将其用作字典中的键来存储位置注释.另一方面,列表可用于存储多个位置.当然,人们可能希望在列表中添加或删除位置,因此列表是可变的是有意义的.另一方面,在现有位置添加或删除项目没有意义 - 因此元组是不可变的.

在某些情况下,您可能希望更改现有位置元组中的项目,例如在遍历页面行时.但元组不变性迫使您为每个新值创建一个新的位置元组.这看起来很不方便,但使用这样的不可变数据是价值类型和函数式编程技术的基石,它们具有很大的优势.

关于这个问题有一些有趣的文章,例如"Python元组不仅仅是常量列表"或"理解Python中的元组与列表".官方Python文档也提到了这一点

"元组是不可变的,通常包含异构序列......".

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

最后在Python中有一个namedtuple,这是有道理的,因为元组已经被认为具有结构.这强调了元组是类和实例的轻量级替代品的想法.

---

"列表是同类序列" - 我是Python的新手,但不是异构的列表吗？来自http://docs.python.org/py3k/tutorial/introduction.html:"列表项不一定都具有相同的类型.但也许你说的是正式的概念,而不是Python对它的看法.

---

说元组是异构的并且列表是同质的,这不是误导吗？例如,列表可以具有不同数据类型的混合,即l = [1,2,'a'].我不明白你在说什么.

---

"元组"的良好语义同义词可能是"记录".它是特定序列中相关数据项的集合.事实上,我觉得`collections.namedtuple`会更好地称为`collections.record`.换掉客户记录中的名称和地址是没有意义的; 事实上,这样做通常会是一个错误,元组的不变性会阻止你提交.

---

+1,特别是你的第二个链接,一个很好的例子.喜欢这句话:"这个元组充当轻量级记录或结构."

---

@nikow:关于"你会用这样的清单做什么？",当ppl使用缺乏幻想作为论据时,我总是颤抖.使用混合类型列表非常有用,例如对于某些分层数据结构,其中每个列表由子列表和值元素组成.

---

与'C'这样的语言并行绘制是正确的,说元组类似于`struct`s而列表类似于数组？

---

@Celeritas严格来说这是误导性的,因为这种语言并没有强化列表中的同质性(毕竟Python是为了成年人的同意).关键在于在社区惯例中编写代码.在这样的上下文中,元组和列表具有不同的语义含义,可以阐明代码的用途.

---

@abarnert:是的,这是一个重点(我不反对这一点).在某种程度上,这符合语义上的区别,因为可能有更多情况下您将使用结构化元组作为字典键或设置值而不是列表(例如,使用书籍位置作为字典键是有意义的,使用位置列表作为关键不太常见).但是当然有合法的反例(例如,以标准方式编码的多项式,如`[3,0,0,1]`).

---

@Akshay:是的,确实(特别是有名的元组).

2> Nikita..：

---

列表和元组之间的区别

文字

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

尺寸

a = tuple(range(1000))
b = list(range(1000))

a.__sizeof__() # 8024
b.__sizeof__() # 9088

由于元组操作的大小较小,它变得快一点,但在你拥有大量元素之前没有多少提及.

允许的操作

b    = [1,2]   
b[0] = 3       # [3, 2]

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

这也意味着您无法删除元素或对元组进行排序.但是,您可以向列表和元组添加新元素,唯一的区别是您将通过添加元素来更改元组的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

用法

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

a    = (1,2)
b    = [1,2] 

c = {a: 1}     # OK
c = {b: 1}     # Error

可清洗的 元组是可以清洗而列表则不是.散列函数返回对象的散列值(如果有).

---

@WanderingMind:存储列表值的内存地址与存储列表对象本身的内存地址不同.

---

嗯...这篇文章中的所有代码*除了* 3下的第一个方框。允许的操作`首先显示元组的大小写。我知道通常会先显示成功，然后显示错误，但这使我的头有些混乱。

3> dan-gph..：

---

如果你去散步,你可以在(x,y)元组的任何瞬间记下你的坐标.

如果您想记录您的旅程,您可以每隔几秒将您的位置附加到列表中.

但你不能反过来这样做.

---

@Iceberg,我的回答是为了帮助培养直觉.它并不意味着探索该主题的每一个细微差别.

---

这个例子看起来只是一个惯例.人们可以争辩说"如果我愿意,我仍然可以使用[x,y]来记录坐标".因此,这个答案被认为是未完成的,除非再说一句:"阅读@nikow的帖子,了解为什么你不应该使用list来存储坐标"

---

很好的例子+1.它强调了元组元素(这里是坐标)的互补性,这就是为什么不允许修改其中任何一个元素的原因 - 因为它改变了整个元组的含义(这里是一个点的位置).

4> Dave Webb..：

---

关键的区别在于元组是不可变的.这意味着一旦创建了元组,就无法更改元组中的值.

因此,如果您需要更改值,请使用List.

对元组的好处:

性能略有提升.

由于元组是不可变的,因此它可以用作字典中的键.

如果你不能改变它既不可以别人,这是说你不需要担心任何API函数等,改变你的元组没有被要求.

---

请注意,元组只有不可变_if所有元素都是__.您可以说所有不可变集合都是如此,例如`frozenset`或各种第三方冻结字典/树/等.类型,但没有一个允许您添加可变元素.(当然,如果元组的所有元素都是可以清除的,那么它是通常的EAFP方式的句柄,所以`d [1,[2]]`会引发`TypeError:unhashable type:'list'`.)

5> duffymo..：

---

列表是可变的; 元组不是.

来自docs.python.org/2/tutorial/datastructures.html

元组是不可变的,并且通常包含异构的元素序列,这些元素可以通过解包(参见本节后面部分)或索引(甚至是在namedtuples的情况下通过属性)来访问.列表是可变的,它们的元素通常是同类的,可以通过遍历列表来访问.

---

随意编辑您的答案以包含相关链接.

---

很高兴看到这里的其他答案如此具有相同的质量,但只有这一点因为一个评论者说"-1"而受到憎恨.而另一个答案只有0.5倍的质量,但只有0.1倍的downvotes.

---

@duffymo我认为这个答案在本页面上是最清晰,最简洁的.它命名了元组和列表之间唯一真正重要的区别,并且不会无休止地喋喋不休地讨论这种公然虚假的同质与异构的hogwash.

6> Shep..：

---

它被提及的差异主要语义:人们期待一个元组,并列出来代表不同的信息.但这比指南更进一步; 一些库实际上根据传递的内容表现不同.以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列表和元组中是完全不同的东西.

---

这不是一个真正有用的答案.区别在于`type(a_list)!= type(a_tuple)`,因此任何基于`type(x)`的库代码分支都会表现得不同

7> Srinivas Red..：

---

列表用于循环,元组用于结构,即"%s %s" %tuple.

列表通常是同类的,元组通常是异构的.

列表用于可变长度,元组用于固定长度.

8> Afflatus..：

---

这是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列表和元组是相似的,因为它们都是有序的值集合.除了使用括号"[...,...]"和使用括号"(...,...)"的元组创建列表的浅层差异之外,核心技术"Python语法中的硬编码"之间存在差异是特定元组的元素是不可变的,而列表是可变的(...所以只有元组是可以清除的,可以用作字典/散列键!).这导致了它们可以或不可以使用的方式(通过语法强制执行)和人们如何选择使用它们的差异(鼓励作为'最佳实践,'后验,这是聪明的程序员所做的).当使用元组与使用列表时区分后验的主要区别在于人们赋予元素顺序的意义.

对于元组,"顺序"仅表示用于保存信息的特定"结构".在第一个字段中找到的值可以很容易地切换到第二个字段,因为每个字段提供跨两个不同维度或比例的值.它们提供不同类型问题的答案,通常具有以下形式:对于给定的对象/主题,它的属性是什么？对象/主体保持不变,属性不同.

对于列表,"顺序"表示序列或方向性.第二个元素必须位于第一个元素之后,因为它基于特定和常见的比例或维度位于第二个位置.这些元素作为一个整体提供,并且主要提供表格的单个问题的答案,对于给定的属性,这些对象/主题如何比较？属性保持不变,对象/主题不同.

流行文化和程序员中有无数的例子不符合这些差异,并且有无数人可能会使用沙拉叉作为他们的主菜.在一天结束时,它很好,通常都可以完成工作.

总结一些更精细的细节

相似点:

重复 - 元组和列表都允许重复

索引,选择和切片 - 使用括号内的整数值对元组和列表进行索引.所以,如果你想要给定列表或元组的前3个值,语法将是相同的:

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

比较和排序 - 两个元组或两个列表都通过它们的第一个元素进行比较,如果存在平局,则通过第二个元素进行比较,依此类推.在先前元素显示出差异之后,不再进一步关注后续元素.

>>> [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

差异: - 根据定义,先验

语法 - 列表使用[],元组使用()

可变性 - 给定列表中的元素是可变的,给定元组中的元素是不可变的.

# 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 "", line 1, in 
TypeError: 'tuple' object does not support item assignment

Hashtables(字典) - 由于哈希表(字典)要求其键是可清除的,因此不可变,只有元组可以充当字典键,而不是列表.

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

#Tuples CAN act as keys for hashtables(dictionaries)
>>> my_dict = {("John","Wayne"): 90210}
>>> my_dict
{('John', 'Wayne'): 90210}

差异 - 后验,使用中

Homo与元素的异构性 - 通常列表对象是同质的,元组对象是异构的.也就是说,列表用于相同类型的对象/主题(如所有总统候选人,或所有歌曲,或所有参赛者),尽管它不是强制的,但是元组更多用于异类对象.

循环与结构 - 尽管两者都允许循环(对于my_list中的x ...),但只对列表进行循环才有意义.元组更适合于构造和呈现信息(%s%s居住在%s中是%s,目前%s%("John","Wayne",90210,"Actor","Dead"))

9> 小智..：

---

列表的值可以随时更改,但元组的值不能更改.

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

10> 小智..：

---

列表和元组之间的区别

元组和列表在Python中看似相似的序列类型.

文字语法

我们使用括号() to construct tuples and square brackets [ ]以获得新列表.此外,我们可以使用适当类型的调用来获取所需的结构 - 元组或列表.

someTuple = (4,6)
someList  = [2,6] 

可变性

元组是不可变的,而列表是可变的.这一点是以下几点的基础.

内存使用情况

由于可变性,您需要更多的内存用于列表,而更少的内存用于元组.

扩展

您可以向元组和列表添加新元素,唯一的区别是元组的id将被更改(即,我们将有一个新对象).

哈希

元组是可以清洗的,而列表则不是.这意味着您可以使用元组作为字典中的键.该列表不能用作字典中的键,而可以使用元组

tup      = (1,2)
list_    = [1,2] 

c = {tup   : 1}     # ok
c = {list_ : 1}     # error

语义

这一点更多的是关于最佳实践.您应该使用元组作为异构数据结构,而列表是同质序列.

11> 小智..：

---

列表旨在是同构序列,而元组是异构数据结构.

---

在这一点上,这个答案并没有为讨论添加任何内容,因为还有许多其他更好的答案.

12> Daksh..：

---

正如人们在这里已经回答的那样tuples，虽然lists可变但可变是不变的，但是使用元组有一个重要方面，我们必须记住

如果中tuple包含一个list或dictionary内部，则即使它们tuple本身是不可变的，也可以更改它们。

例如，假设我们有一个元组，其中包含一个列表和一个字典，如下所示

my_tuple = (10,20,30,[40,50],{ 'a' : 10})

我们可以将列表的内容更改为

my_tuple[3][0] = 400
my_tuple[3][1] = 500

这使得新的元组看起来像

(10, 20, 30, [400, 500], {'a': 10})

我们也可以将元组中的字典更改为

my_tuple[4]['a'] = 500

这将使整个元组看起来像

(10, 20, 30, [400, 500], {'a': 500})

发生这种情况是因为list和dictionary是对象，而这些对象并没有改变，而是其指向的内容。

因此，这些tuple遗物毫无例外地保持不变