列表是可变的。而元组是不可变的。在元组中访问带有索引的偏移量元素比在列表中更有意义，因为元素及其索引不能被更改。

这是一个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 lists and tuples are similar in that they both are ordered collections of values. Besides the shallow difference that lists are created using brackets "[ ... , ... ]" and tuples using parentheses "( ... , ... )", the core technical "hard coded in Python syntax" difference between them is that the elements of a particular tuple are immutable whereas lists are mutable (...so only tuples are hashable and can be used as dictionary/hash keys!). This gives rise to differences in how they can or can't be used (enforced a priori by syntax) and differences in how people choose to use them (encouraged as 'best practices,' a posteriori, this is what smart programers do). The main difference a posteriori in differentiating when tuples are used versus when lists are used lies in what meaning people give to the order of elements.

对于元组，“order”只是表示用于保存信息的特定“结构”。在第一个字段中找到的值可以很容易地切换到第二个字段中，因为每个字段提供跨越两个不同维度或尺度的值。它们为不同类型的问题提供答案，通常的形式是:对于给定的对象/主题，它的属性是什么?对象/主题保持不变，属性不同。

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

在流行文化和程序员中，有无数的人不符合这些差异，也有无数的人可能会用沙拉叉吃主菜。在一天结束的时候，这很好，两者通常都可以完成工作。

总结一些更精细的细节

相似之处:

Duplicates - Both tuples and lists allow for duplicates Indexing, Selecting, & Slicing - Both tuples and lists index using integer values found within brackets. So, if you want the first 3 values of a given list or tuple, the syntax would be the same: >>> my_list[0:3] [0,1,2] >>> my_tuple[0:3] [a,b,c] Comparing & Sorting - Two tuples or two lists are both compared by their first element, and if there is a tie, then by the second element, and so on. No further attention is paid to subsequent elements after earlier elements show a difference. >>> [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

区别:-根据定义，是先验的

Syntax - Lists use [], tuples use () Mutability - Elements in a given list are mutable, elements in a given tuple are NOT mutable. # 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 Hashtables (Dictionaries) - As hashtables (dictionaries) require that its keys are hashable and therefore immutable, only tuples can act as dictionary keys, not lists. #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}

差异——用法上的后验

Homo vs. Heterogeneity of Elements - Generally list objects are homogenous and tuple objects are heterogeneous. That is, lists are used for objects/subjects of the same type (like all presidential candidates, or all songs, or all runners) whereas although it's not forced by), whereas tuples are more for heterogenous objects. Looping vs. Structures - Although both allow for looping (for x in my_list...), it only really makes sense to do it for a list. Tuples are more appropriate for structuring and presenting information (%s %s residing in %s is an %s and presently %s % ("John","Wayne",90210, "Actor","Dead"))

list和tuple的区别

Literal someTuple = (1,2) someList = [1,2] Size a = tuple(range(1000)) b = list(range(1000)) a.__sizeof__() # 8024 b.__sizeof__() # 9088 Due to the smaller size of a tuple operation, it becomes a bit faster, but not that much to mention about until you have a huge number of elements. Permitted operations b = [1,2] b[0] = 3 # [3, 2] a = (1,2) a[0] = 3 # Error That also means that you can't delete an element or sort a tuple. However, you could add a new element to both list and tuple with the only difference that since the tuple is immutable, you are not really adding an element but you are creating a new tuple, so the id of will change 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 Usage As a list is mutable, it can't be used as a key in a dictionary, whereas a tuple can be used. a = (1,2) b = [1,2] c = {a: 1} # OK c = {b: 1} # Error

最重要的区别是时间!当你不想改变列表里面的数据时最好使用元组!下面是为什么使用tuple的例子!

import timeit
print(timeit.timeit(stmt='[1,2,3,4,5,6,7,8,9,10]', number=1000000)) #created list
print(timeit.timeit(stmt='(1,2,3,4,5,6,7,8,9,10)', number=1000000)) # created tuple 

在本例中，我们执行了这两条语句100万次

输出:

0.136621
0.013722200000000018

任何人都能清楚地注意到时差。

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

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

但你不能反过来做。

正如人们已经提到的区别，我将写一下为什么是元组。

为什么首选元组?

小元组的分配优化 为了减少内存碎片和加快分配速度，Python重用旧元组。如果一个 元组不再需要，并且只有少于20个项而不是删除 Python会永久地将它移到一个空闲列表中。 一个空闲列表被分为20个组，每个组代表一个 长度为n的元组列表，从0到20。每组都可以储存 到2000个元组。第一个(零)组只包含一个元素和 表示空元组。

>>> a = (1,2,3)
>>> id(a)
4427578104
>>> del a
>>> b = (1,2,4)
>>> id(b)
4427578104

在上面的例子中，我们可以看到a和b有相同的id。这是 因为我们立即占用了一个被破坏的元组 空闲列表。 列表的分配优化 由于列表可以被修改，Python不会像元组那样使用相同的优化方法。然而, Python列表也有一个free列表，但它只用于空列表 对象。如果一个空列表被GC删除或收集，它可以被删除 以后重用。

>>> a = []
>>> id(a)
4465566792
>>> del a
>>> b = []
>>> id(b)
4465566792

来源:https://rushter.com/blog/python-lists-and-tuples/

为什么元组比列表更高效?- > https://stackoverflow.com/a/22140115