列表 VS 元组

一个 Python 初学者的普遍疑问：列表与元组的区别是什么？

答案是：它们之间有两点不同，并且二者之间有着复杂的相互作用。它们分别是”技术上”的差异和“文化上”的差异。

首先，有一点是相同的：列表与元组都是容器，是一系列的对象。

Python

 

1 2 3 4 5 6

>>> my_list = [1, 2, 3] >>> type(my_list) <class 'list'> >>> my_tuple = (1, 2, 3) >>> type(my_tuple) <class 'tuple'>

二者都可以包含任意类型的元素甚至可以是一个序列，还可以包含元素的顺序（不像集合和字典）。

Python

 

1 2 3 4 5 6 7

>>> my_list[1] = "two" >>> my_list [1, 'two', 3] >>> my_tuple[1] = "two" Traceback (most recent call last):   File "<stdin>", line 1, in <module> TypeError: 'tuple' object does not support item assignment

现在来讲讲区别。列表和元组的“技术差异”是，列表是可变的，而元组是不可变的。这是在 Python 语言中二者唯一的差别。

尽管有好几种表现方式，但这是列表和元组唯一的“技术差异”。比如：列表有一个 append() 的方法来添加更多的元素，而元组却没有这个方法：

Python

 

1 2 3 4 5 6 7

>>> my_list.append("four") >>> my_list [1, 'two', 3, 'four'] >>> my_tuple.append("four") Traceback (most recent call last):   File "<stdin>", line 1, in <module> AttributeError: 'tuple' object has no attribute 'append'

元组并不需要一个 append() 方法，因为元组不能修改。

“文化差异“是指二者在实际使用中的差异：在你有一些不确定长度的相同类型队列的时候使用列表；在你提前知道元素数量的情况下使用元组，因为元素的位置很重要。

举个例子，假设你有一个函数是用来在目录中查找结尾为 *.py 的文件。函数返回的应该是一个列表，因为你并不知道你会找到多少个文件，而这些文件都有相同的含义：它们仅仅是你找到的另一个文件。

Python

 

1 2	>>> find_files("*.py") ["control.py", "config.py", "cmdline.py", "backward.py"]

另一方面，让我们假设你需要存储五个值来代表气象观测站的位置：id ,城市，国家，纬度，经度。元组就比列表更适用于这种情况：

Python

 

1 2 3

>>> denver = (44, "Denver", "CO", 40, 105) >>> denver[1] 'Denver'

(让我们暂时不要讨论使用类来表示的这种情况)。第一个元素是 id ，第二个元素是城市，等等。位置决定了它的意义。

把这种“文化差异”放到 C 语言来讲，列表像是数组，元组则像是 structs 结构体。

Python 采用了命名元组的方法来使含义更加明确：

Python

 

1 2 3 4 5 6 7 8 9

>>> from collections import namedtuple >>> Station = namedtuple("Station", "id, city, state, lat, long") >>> denver = Station(44, "Denver", "CO", 40, 105) >>> denver Station(id=44, city='Denver', state='CO', lat=40, long=105) >>> denver.city 'Denver' >>> denver[1] 'Denver'

对元组和列表之间“文化差异”的一个总结是：元组是不需要名字的命名元组。

“技术差异”和“文化差异”这种区分也并不准确，因为有时候他们并不稳定。为什么同种元素的序列可变，而不同元素的序列不可变呢？举个例子，我不能修改我的气象站，因为命名元组是不可变的元组。

Python

 

1 2 3 4

>>> denver.lat = 39.7392 Traceback (most recent call last):   File "<stdin>", line 1, in <module> AttributeError: can't set attribute

有时技术考量要比文化考量重要。比如你不能把列表当做字典的关键字，因为只有不可变的值才能进行哈希运算，因此只有不可变的值才能作为关键字。要使用列表做关键字，你需要把它转化为元组：

Python

 

1 2 3 4 5 6 7 8 9

>>> d = {} >>> nums = [1, 2, 3] >>> d[nums] = "hello" Traceback (most recent call last):   File "<stdin>", line 1, in <module> TypeError: unhashable type: 'list' >>> d[tuple(nums)] = "hello" >>> d {(1, 2, 3): 'hello'}

技术和文化的另一个冲突是：在 Python 中元组使用的地方，列表也起着重要作用。当你定义一个带参函数，元组作为参数传入，即使这个值的位置并不显著，至少 Python 知道这是一个元组。你可能会说这是个元组因为你不能改变被传进来的值，但这只是重视了技术上的差异而非文化上的差异。

我知道：在参数数组中，位置很重要，因为他们是位置参数。但是在函数中，它会接收参数数组并传入另一个函数，它仅仅是一组参数，与其他参数并无不同。其中一些会在调用中变化。

Python 之所以在这里使用元组是因为元组比列表更节省空间。列表被重复分配使得在添加元素上更快。这体现了 Python 的实用性：相比于在参数数组上，列表/元组的语义差别，在这种情况下，使用这种数据结构更好。

大部分情况下，你应该根据文化差异来选择使用列表还是元组。思考下你数据的含义。如果实际上根据你的程序来计算，你的数据长度并不固定，那么可能用列表更好。如果在写代码时你知道第三个元素的含义，那么用元组更好。

另一方面，函数式编程强调使用不可变的数据结构来避免产生使代码变得更难解读的副作用。如果你喜欢使用函数式编程，那么你可能因为元组的不可变而更喜欢它们。

一、列表和元组的区别

列表是动态数组，它们可变且可以重设长度（改变其内部元素的个数）。
元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变。
元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。
这些区别结实率两者在设计哲学上的不同：

列表可被用于保存多个互相独立对象的数据集合
元组用于描述一个不会改不安的事务的多个属性

二、列表（List）

列表一旦创建了我们就可以根据自己的需要随意改变它的内容：

>>> l = [1, 2, 3, 4, 5, 6]
>>> l[0] = l[2] * l[3]
>>> l
[12, 2, 3, 4, 5, 6]

另外我们可以给列边添加新的数据来增加其大小：

>>> len(l)
6
>>> l.append(7)
>>> l
[12, 2, 3, 4, 5, 6, 7]
>>> len(l)
7

这是因为动态数组支持resize操作，可以增加数组的容量。当一个大小为N的列表第一次需要添加数据时，Python会创建一个新的列表，足够放原来的N个元素以及额外添加的元素。不过，实际分配的并不是N+1个元素，而是M个元素，M > N, 这是为了给未来的添加预留空间。然后旧列表的数据被复制到新列表中，旧列表则会被销毁。从设计理念上来说，第一次添加可能是后续多次添加的开始，通过预留空间的做法，我们就可以减少这一分配空间的操作次数以及内存复制的次数。这点非常重要，因为内存复制可能非常的昂贵，特别是当列表大小开始增长以后。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GdQpXs7R-1599024560319)(./image/列表的添加操作.jpg)]

三、元组（Tuple）
元组是固定且不可改变的。这意味着一旦元组被创建，和列表不同，它的内容无法被修改或它的大小也无法被改变。
 

>>> t = (1, 2, 3, 4)
>>> t[0] = 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

虽然它们不支持改变大小，但是我们可以将两个元组合并成一个新元组。这一操作类似列表的resize操作，但我们不需要为新生的元组分配任何额外的空间：

>>> t1 = (1, 2, 3, 4)
>>> t2 = (5, 6, 7, 8)
>>> t1 + t2
(1, 2, 3, 4, 5, 6, 7, 8)

如果我们将其与列表的append操作比较，我们会看到它的复杂度是O(n)而不是列表的O(1)。这是因为对元组每添加一个新元素都会有分配和复制操作，而不是像列表那样仅在额外的空间耗尽时发生。所以元组并没有提供一个类似append的自增操作，任意两个元组相加始终返回一个新分配的元组。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nIsaGxH8-1599024560321)(./image/元组的合并操作.jpg)]

该网站为Python Tutor,一个能够对python运行内存可视化的网站，非常适合初学者研究，在运行过程中内存发生了什么。

元组的静态特性的另一个好处体现在一些会在Python后台发生的事情：资源缓存。

Python是一门垃圾收集语言，这意味着当一个变量不再被使用时，Python会将该变量使用的内存释放回操作系统，以供其他程序（变量）使用。然而，对于长度为1~20的元组，即使它们不在被使用，它们的空间也不会立刻还给系统，而是留待未来使用。这意味着当未来需要一个同样大小的新的元组时，我们不再需要向操作系统申请一块内存来存放数据，因为我们已经有了预留的空间。

这看上去可能是个细微的好处，但是实际上是元组一个很神奇的地方：它们可以被轻松快速地创建，因为它们可以避免跟操作系统频繁的打交道，而后者会花很长的时间。

下面举个例子会非常直观的说明问题
 

In [1]: %timeit l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
93.7 ns ± 3.33 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [2]: %timeit t = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
18.5 ns ± 1.19 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

上面的示例中显示了初始化一个列表比初始化一个元组慢了5.1倍——如果这是在一个循环中，这点差别会很快的累加起来。

1. 列表(list)

1.1 列表创建、切片、删除、检索

• 是Python的内置数据类型，是一个元素的有序集合
• 一个列表中的数据类型可以不相同
• 列表中的每个数据称为元素
  
  

1.创建列表：列表名=[元素1，元素2]

list1 = ['Google', 'Runoob', 1997, 2000]

2.访问列表：列表名[索引]

list = ['red', 'green', 'blue', 'yellow', 'white', 'black']
print( list[0] )#输出为red
print( list[-1] )#输出为black

3.列表切片：列表名[始：末：步长]（“末”：不包含末尾的那一位）

# 读取第二位
print ("list[1]: ", list[1])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print ("list[1:-2]: ", list[1:-2])

4.增加元素

1)+

2)append()：向列表尾部添加一个新元素

3)extend()：讲一个新列表添加在原列表的尾部

4)insert()：将元素插入到指定位置

5.删除列表

1)del()：删除列表中指定位置的元素或列表

2)remove(值)：删除首次出现的指定元素

3)pop(索引)：删除指定元素

4)clear()：清空列表

6.检索元素

1)index()

2)count()：统计列表指定元素出现的次数

3)in：检索某个元素是否在列表中

1.2 列表常用函数

1)len(列表)：列表元素个数

2)max(列表)：返回列表元素最大值

3)min(列表)：返回列表元素最小值

4)list(seq)：将元组转换为列表

5)sum(列表)：对数值型列表元素求和

6)sorted(列表)：排序（默认升序）该方法不会改变原列表的顺序

• 升序：sorted(列表,reverse=True)
• 降序：sorted(列表,reverse=False)

7)列表.sort()：排序后的列表会覆盖原列表

• 升序：列表.sort(reverse=False)
• 降序：列表.sort(reverse=True)

8)列表.reverse()：对列表的元素翻转存放

2. 元组(tuple)

• Python 的元组与列表类似，不同之处在于元组的元素不能修改。
• 元组使用小括号 ( )，列表使用方括号 [ ]，逗号隔开
  
  

1.创建元组

• 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用

tup1 = ('Google', 'Runoob', 1997, 2000)
# 空元组
tup1 = ()
# 一个元素的元组
tup1 = (50,)

2.读取：元组名[索引]（同列表）

3.连接元组

# 创建一个新的元组
tup3 = tup1 + tup2

4.删除元组

• del 元组
  
  
  
  

3. 列表与元组区别及转换

列表与元组的区别

( 1 )元组的处理速度和访问速度比列表快。如果定义了一
系列常量值,主要对其进行遍历或者类似用途，而不需要对其
元素进行修改,这种情况-般使用元组。可以认为元组对不需
要修改的数据进行了“写保护”，可以使代码更安全。

(2 )作为不可变序列，元组(包含数值、字符串和其他元
组的不可变数据)可用作字典的键,而列表不可以充当字典的
键,因为列表是可变的。

列表转换为元组：tuple(列表)

元组转换为列表：list(元组)