深入剖析Python的列表和元组

目录

• 1. 定义
• 2. 区别
• 3. 索引
• 4. 嵌套 & 数据类型强转
• 1). 嵌套
• 2). 数据类型强转
• 5. 常用内置函数
• 1). count(item)
• 2). index(item)
• 3). list.reverse()
• 4). list.sort()
• 6. 存储方式

1. 定义

列表和元组，都是一个可以放置任意数据类型的有序集合。

在大多数编程语言中，集合内元素的数据类型必须保持一致，但在 Python 的列表与元组中，没有这个约束。

示例

列表 List = [‘Tom’, 22, 33, ‘tony’]

元组 Tuple = (‘China’, 10)

如上列表与元组的示例，列表与元组集合内同时存放了 int 类型和 string 类型的元素

2. 区别

列表是动态的，长度大小不固定，可以随意地新增、删除、修改集合内元素

input:

test_list = ['Tom', 22, 33, 'tony']
test_tuple = ('jack', 10)
# test_list新增元素
test_list.append('100')
test_list.append('200')
print(test_list)
# test_list修改元素
test_list[0] = 'xiaomin'
print(test_list)
# test_list删除元素
test_list.pop()
print(test_list)

output:

['Tom', 22, 33, 'tony', '100', '200']
['xiaomin', 22, 33, 'tony', '100', '200']
['xiaomin', 22, 33, 'tony', '100']

从输入，输出可以证明列表支持集合内元素的新增、删除、修改

元组是静态的，长度大小固定，不可以新增、删除、修改集合内元素

input:

test_tuple = ('jack', 10)
# test_tuple修改元素
test_tuple[0] = 'xiaomin'
print(test_tuple)

output:

Traceback (most recent call last):
File "test001.py", line 5, in <module>
test_tuple[0] = 'xiaomin'
TypeError: 'tuple' object does not support item assignment

从输入，输出可以证明元组不支持集合内元素的修改，新增和删除也不支持，大家可以自己动手实验下。

这也证明了Python中元组是静态不可变的。如果就想在原有元组集合中添加元素，有没有办法可以实现呢？

答案：“有的”，见如下示例

input:

test_tuple = ('jack', 10)
new_test_tuple = test_tuple + (20, 'xiaomin')
print(new_test_tuple)

output:

('jack', 10, 20, 'xiaomin')

虽然能实现想要的效果，但并不是真正意义上的原元组集合基础上元素的添加，而是创建了一个新的元组 new_test_tuple 来实现。

3. 索引

Python 中的列表和元组都支持正负数索引，正常索引区间，非正常索引区间取值。验证如下：

input:

test_list = [100, 200, 300, 400, 500]
# 列表支持区间索引取值: 取索引下标为1至倒数第2个元素之间的所有元素，规则：左闭右开
print(test_list[1:-1])
# 列表支持单个正数索引取值: 取正数第2个元素
print(test_list[2])
# 列表支持单个负数索引取值: 取倒数第2个元素
print(test_list[-2])
# 列表支持非区间索引取值: 从倒数第2个元素一直往前取所有
print(test_list[:-1])
print("*" * 20)
test_tuple = ('jack', 10, 20, 'tom')
# 元组支持区间索引取值: 取索引下标为1至倒数第2个元素之间的所有元素，规则：左闭右开
print(test_tuple[1:-1])
# 元组支持单个正数索引取值: 取正数第2个元素
print(test_tuple[2])
# 元组支持单个负数索引取值: 取倒数第2个元素
print(test_tuple[-2])
# 元组支持非区间索引取值: 从倒数第2个元素一直往前取所有
print(test_tuple[:-1])

output:

[200, 300, 400]
300
400
[100, 200, 300, 400]
********************
(10, 20)
20
20
('jack', 10, 20)

4. 嵌套 & 数据类型强转

列表和元组都可以随意嵌套和数据类型转换，见如下示例。

1). 嵌套

input:

# 列表内的元素支持嵌套，元素可以是一个列表
test_list = [[100, 200, 300], [400, 500]]
print("test_list列表中第1个元素的数据类型，{}".format(type(test_list[0])))
# 元组内的元素支持嵌套，元素可以是一个元组
test_tuple = (('jack', 10, 20, 'tom'), (4, 5, 6))
print("test_tuple列表中第1个元素的数据类型，{}".format(type(test_tuple[0])))

output:

test_list列表中第1个元素的数据类型，<class 'list'>
test_tuple列表中第1个元素的数据类型，<class 'tuple'>

2). 数据类型强转

input:

test_list = [100, 200, 300]
print("test_list列表使用tuple()函数进行强转后，元素输出结果为：{}".format(tuple(test_list)))
print("test_list列表使用tuple()函数进行强转后，元素所属数据类型输出结果为：{}".format(type(tuple(test_list))))
print("*" * 60)
test_tuple = ('jack', 10, 20, 'tom')
print("test_tuple元组使用list()函数进行强转后，元素输出结果为：{}".format(list(test_tuple)))
print("test_tuple元组使用list()函数进行强转后，元素所属数据类型输出结果为：{}".format(type(list(test_tuple))))

output:

test_list列表使用tuple()函数进行强转后，元素输出结果为：(100, 200, 300)
test_list列表使用tuple()函数进行强转后，元素所属数据类型输出结果为：<class 'tuple'>
************************************************************
test_tuple元组使用list()函数进行强转后，元素输出结果为：['jack', 10, 20, 'tom']
test_tuple元组使用list()函数进行强转后，元素所属数据类型输出结果为：<class 'list'>

5. 常用内置函数

1). count(item)

表示统计列表 / 元组中 item(元素) 出现的次数

input:

test_list = [100, 200, 300, 100, 400]
test_tuple = ('jack', 10, 20, 'tom', 10, 20, 10)
print("test_list列表中统计元素100出现的次数为：{}".format(test_list.count(100)))
print("test_tuple元组中统计元素10出现的次数为：{}".format(test_tuple.count(10)))

output:

test_list列表中统计元素100出现的次数为：2
test_tuple元组中统计元素10出现的次数为：3

2). index(item)

表示返回列表 / 元组中 item(元素) 第一次出现的索引值

input:

test_list = [100, 200, 300, 100, 400]
test_tuple = ('jack', 10, 20, 'tom', 10, 20, 10)
print("test_list列表中返回元素100第1次出现的索引值为：{}".format(test_list.index(100)))
print("test_tuple元组中返回元素10第1次出现的索引值为：{}".format(test_tuple.index(10)))

output:

test_list列表中返回元素100第1次出现的索引值为：0
test_tuple元组中返回元素10第1次出现的索引值为：1

3). list.reverse()

表示原地倒转列表（注意：元组没有这个内置函数)

input:

test_list = [100, 200, 300, 100, 400]
test_list.reverse()
print("test_list列表原地倒转后返回元素为：{}".format(test_list))

output:

test_list列表原地倒转后返回元素为：[400, 100, 300, 200, 100]

4). list.sort()

表示排序列表（注意：元组没有这个内置函数)

input:

test_list = [100, 200, 300, 100, 400]
test_list.sort()
print("test_list列表原地倒转后返回元素为：{}".format(test_list))

output:

test_list列表原地倒转后返回元素为：[100, 100, 200, 300, 400]

6. 存储方式

PS: 以下示例使用的是 Python3.9版本

input:

test_list = [100, 200, 300]
print("初始化相同元素，列表所占用的大小为：{}".format(test_list.__sizeof__()))
test_tuple = (100, 200, 300)
print("初始化相同元素，元组所占用的大小为：{}".format(test_tuple.__sizeof__()))

output:

初始化相同元素，列表所占用的大小为：104
初始化相同元素，元组所占用的大小为：48

从输出结果可以看到，初始化相同元素，但是元组的存储空间，却比列表要少56字节，这是由于什么原因导致的呢？

1). 存储指针占用：8字节

因为列表是动态的，所以它需要存储指针，来指向对应的元素（上述例子中，对于int型，存储指针占用：8字节）

2). 分配8字节长度用于追踪列表空间使用情况

由于列表可变，所以需要额外存储已经分配的长度大小：8字节，用于实时追踪列表空间的使用情况，当空间不足时，及时分配额外空间

3). 预留3个元素的存储空间共24字节

因为列表是动态的，需要提前预留3个元素的存储空间，每个元素是8字节，可以大大节省频繁分配空间的开销

4). 空列表占用空间比空元组占用空间多16字节

空列表所占用的大小为：40字节，空元组所占用的大小为：24字节

所以，最终列表比元组多占用的 56字节 = 8字节 + 8字节 + 24字节 + 16字节

PS:

元组长度大小固定，元素不可变，所以存储空间固定，空元组占用24字节，在初始化3个元素时，每个元素占用8字节，最终共占用48字节。

从上面的示例可知，元组要比列表更加轻量级一些，所以总体上而言，元组的性能速度要略优于列表。

到此这篇关于深入剖析Python的列表和元组的文章就介绍到这了,更多相关Python的列表和元组内容请搜索自由互联以前的文章或继续浏览下面的相关文章希望大家以后多多支持自由互联！