Wu_Candy

V1

2022/09/04阅读:9主题:默认主题

深入剖析 Python 最常用数据结构:列表(List) & 元组(Tuple)

1. 定义

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

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

示例

列表 List = ['Tom', 22, 33, 'tony']

元组 Tuple = ('China', 10)

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

2. 区别

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

input:

test_list = ['Tom'2233'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'2233'tony''100''200']
['xiaomin'2233'tony''100''200']
['xiaomin'2233'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 5in <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'1020'xiaomin')

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

3. 索引

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

input:

test_list = [100200300400500]
# 列表支持区间索引取值: 取索引下标为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'1020'tom')
# 元组支持区间索引取值: 取索引下标为1至倒数第2个元素之间的所有元素,规则:左闭右开
print(test_tuple[1:-1])
# 元组支持单个正数索引取值: 取正数第2个元素
print(test_tuple[2])
# 元组支持单个负数索引取值: 取倒数第2个元素
print(test_tuple[-2])
# 元组支持非区间索引取值: 从倒数第2个元素一直往前取所有
print(test_tuple[:-1])

output:

[200300400]
300
400
[100200300400]
********************
(1020)
20
20
('jack'1020)

4. 嵌套 & 数据类型强转

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

1). 嵌套

input:

# 列表内的元素支持嵌套,元素可以是一个列表
test_list = [[100200300], [400500]]
print("test_list列表中第1个元素的数据类型,{}".format(type(test_list[0])))
# 元组内的元素支持嵌套,元素可以是一个元组
test_tuple = (('jack'1020'tom'), (456))
print("test_tuple列表中第1个元素的数据类型,{}".format(type(test_tuple[0])))

output:

test_list列表中第1个元素的数据类型,<class 'list'>
test_tuple列表中第1个元素的数据类型,<class 'tuple'>
2). 数据类型强转

input:

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

output:

test_list列表使用tuple()函数进行强转后,元素输出结果为:(100200300)
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 = [100200300100400]
test_tuple = ('jack'1020'tom'102010)
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 = [100200300100400]
test_tuple = ('jack'1020'tom'102010)
print("test_list列表中返回元素100第1次出现的索引值为:{}".format(test_list.index(100)))
print("test_tuple元组中返回元素10第1次出现的索引值为:{}".format(test_tuple.index(10)))

output:

test_list列表中返回元素1001次出现的索引值为:0
test_tuple元组中返回元素101次出现的索引值为:1
3). list.reverse()

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

input:

test_list = [100200300100400]
test_list.reverse()
print("test_list列表原地倒转后返回元素为:{}".format(test_list))

output:

test_list列表原地倒转后返回元素为:[400100300200100]
4). list.sort()

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

input:

test_list = [100200300100400]
test_list.sort()
print("test_list列表原地倒转后返回元素为:{}".format(test_list))

output:

test_list列表原地倒转后返回元素为:[100100200300400]

6. 存储方式

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

input:

test_list = [100200300]
print("初始化相同元素,列表所占用的大小为:{}".format(test_list.__sizeof__()))
test_tuple = (100200300)
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

作者介绍

Wu_Candy
V1