当前位置：首页 > article >正文

【五分钟】熟悉python列表和元组的异同点【看这篇够用！建议收藏】

article 2024/11/15 1:01:39

引言

Python，是一种广泛应用于数据科学、机器学习等领域的高级编程语言，支持多种丰富多样的数据类型，其中包括列表和元组。尽管这两种数据结构都可用于存储多个值，但它们在功能和特性上存在着明显的差异。在接下来的博客中，我们将深入探讨Python列表和元组的异同点，帮助你更好地理解和使用这两种数据结构。

列表和元组的定义

列表可以视为一个有序的元素集合，它支持包含各种类型的对象，例如整数、字符串，甚至可以包含其他列表。在Python中，列表使用方括号[]来表示，元素之间用逗号,进行分隔。

示例代码

# 构建列表，包含整数对象、元组对象、字符串对象、列表对象、字典对象
my_list = [1, (2,), 'three', [4, 5]]
for element in my_list:
    # 打印元素的数据类型
    print(type(element), end="\t")
# 输出
<class 'int'>	<class 'tuple'>	<class 'str'>	<class 'list'>	<class 'dict'>

元组也是一个有序的集合，同样可以包含任意类型的对象，包括数字、字符串、甚至其他元组。元组使用圆括号()来表示，其中的元素用逗号,分隔。例如：

# 构建元组，包含整数对象、列表对象、字符串对象、元组对象
my_tuple = (1, [2], 'three', (4, 5))
for element in my_tuple:
    # 打印元素的数据类型
    print(type(element), end="\t")
# 输出
<class 'int'>	<class 'list'>	<class 'str'>	<class 'tuple'>

列表和元组的相同点

都可以通过索引访问元素：列表和元组都包含一组有序的元素 ⇒ 可以通过索引访问每个元素
数据类型多样化：列表和元组都可以同时包含多种类型的对象，例如整数、浮点数、字符串、布尔值，甚至还可以包含列表或元组本身

示例代码：

list1 = [1, (2,), 'three', [4, 5], {6: 7}]
tuple1 = (1, [2], 'three', (4, 5))
# 输出列表list1的第2个元素和最后一个元素
print("{} | {}".format(list1[1], list1[-1]))
# (2,) | {6: 7}

# 输出列表tuple1的第2个元素和最后一个元素
print("{} | {}".format(tuple1[1], tuple1[-1]))
# [2] | (4, 5)

都支持切片操作：列表和元组都支持切片操作，可以通过切片获取子序列。

示例代码：

list1 = [1, (2,), 'three', [4, 5], {6: 7}]
tuple1 = (1, [2], 'three', (4, 5))

# 通过切片操作将列表list1分成两个子列表
print("{} | {}".format(list1[:3], list1[3:]))
# [1, (2,), 'three'] | [[4, 5], {6: 7}]

# 通过切片操作将元组tuple1分成两个子元组
print("{} | {}".format(tuple1[:3], tuple1[3:]))
# (1, [2], 'three') | ((4, 5),)

都是可迭代对象：列表和元组都是可迭代的，可以通过循环遍历它们的元素。

示例代码

list1 = [1, (2,), 'three', [4, 5], {6: 7}]
tuple1 = (1, [2], 'three', (4, 5))

for i, element in enumerate(list1):
    print("列表list1的第{}个元素是:\t{}".format(i+1, element))
# 列表list1的第1个元素是:	1
# 列表list1的第2个元素是:	(2,)
# 列表list1的第3个元素是:	three
# 列表list1的第4个元素是:	[4, 5]
# 列表list1的第5个元素是:	{6: 7}

for i, element in enumerate(tuple1):
    print("元组tuple1的第{}个元素是:\t{}".format(i + 1, element))
# 元组tuple1的第1个元素是:	1
# 元组tuple1的第2个元素是:	[2]
# 元组tuple1的第3个元素是:	three
# 元组tuple1的第4个元素是:	(4, 5)

都支持连接操作：列表可以通过+操作符和另一个列表连接组成新列表；元组也可以通过+操作符和另一个元组连接组成新元组。

示例代码：

list1 = [1, (2,), 'three', [4, 5], {6: 7}]
list2 = [8, "9", (10,)]
tuple1 = (1, [2], 'three', (4, 5))
tuple2 = ("six", 7)

print(list1 + list2)
# [1, (2,), 'three', [4, 5], {6: 7}, 8, '9', (10,)]
print(tuple1 + tuple2)
# (1, [2], 'three', (4, 5), 'six', 7)

都支持重复操作：列表和元组都支持使用*操作符对其本身进行复制操作。

示例代码

list3 = ["+"]
print(list3 * 10)
# ['+', '+', '+', '+', '+', '+', '+', '+', '+', '+']

tuple3 = ("+",)
print(tuple3 * 10)
# ('+', '+', '+', '+', '+', '+', '+', '+', '+', '+')

都支持成员检测：列表和元组都支持使用in关键字检测一个元素是否存在于列表或元组中

示例代码

list1 = [1, (2,), 'three', [4, 5], {6: 7}]
print([4, 5] in list1) # True
print({6: 8} in list1) # False

tuple1 = (1, [2], 'three', (4, 5))
print([2] in tuple1) # True
print(2 in tuple1) # False

都支持长度查询：列表和元组都支持使用内置函数len()来查询它们的长度（元素个数）

示例代码

list1 = [1, (2,), 'three', [4, 5], {6: 7}]
print(len(list1) # 5

tuple1 = (1, [2], 'three', (4, 5))
print(len(tuple1) # 4

都支持元素赋值：

对于列表，可以通过索引操作修改对应元素；
对于元组，虽然元组本身不可变，但可以修改元组中的可变元素（例如列表）；

示例代码

list1 = [1, (2,), 'three', [4, 5], {6: 7}]
print("列表list1修改前", list1)
list1[0] = "1"
print("列表list1修改后", list1)
# 列表list1修改前 [1, (2,), 'three', [4, 5], {6: 7}]
# 列表list1修改后 ['1', (2,), 'three', [4, 5], {6: 7}]

tuple1 = (1, [2, 3], 'three', (4, 5))
print("元组tuple1修改前", tuple1)
# tuple1[1] = 3 会引发错误，因为元组是不可变的
tuple1[1][0] = 3 # 可以修改元组中的列表元素
print("元组tuple1修改后", tuple1)
# 元组tuple1修改前 (1, [2, 3], 'three', (4, 5))
# 元组tuple1修改后 (1, [3, 3], 'three', (4, 5))

都支持比较操作：列表和元组都支持使用比较操作符（例如==，!=，<，<=，>，>=）来进行元素比较。比较操作按照元素的顺序进行。

list2 = [8, "9", (10,)]
tuple2 = ("six", 7)
print(list2 == [8, "9", (10,)])  # True
print(tuple2 == ("six", 7))  # True
print(list2 == ["8", "9", (10,)])  # False
print(tuple2 == ("six", "7"))  # False

print(list2 != [8, "9", (10,)])  # False
print(tuple2 != ("six", 7))  # False
print(list2 != ["8", "9", (10,)])  # True
print(tuple2 != ("six", "7"))  # True

列表和元组的不同点

列表是可变的，而元组是不可变的 ⇒ 元组一旦创建，就不能通过索引修改它的元素，但可以修改元组中的可变元素。而列表创建后可以添加、删除或更改其元素。

示例代码

list1 = [1, 2, 3]
list1.append(4)  # 添加元素4到列表末尾
print(list1)  # [1, 2, 3, 4]

tuple1 = (1, 2, 3, [4, 5])
# tuple1[0] = 5  # 这会引发错误，因为元组是不可变的
tuple1[3][0] = 5  # 可以运行，因为元组最后一个元素是列表，列表可以修改元素
print(tuple1)  # (1, 2, 3, [5, 5])

语法：列表使用方括号[]来表示，而元组使用圆括号()来表示。
方法：列表有更多的内置方法，例如append(), extend(), insert(), remove(), pop()等。元组的方法较少，常用的有count()和index()。
内存占用：由于元组是不可变的，它们通常比列表占用的内存空间要少。在处理大量数据时，元组的速度通常比列表快。

示例代码

import sys

# 创建大量数据
list_data = [0] * 100000000
tuple_data = (0,) * 100000000

# 打印初始内存使用情况
print("初始内存使用情况（MB）:")
print(sys.getsizeof(list_data) / 1024 / 1024)  # 以MB为单位
print(sys.getsizeof(tuple_data) / 1024 / 1024)  # 以MB为单位

# 执行一些操作以查看内存使用情况
list_data.append(1)
tuple_data += (1,)

# 打印操作后的内存使用情况（增加的内存用于存储新添加的元素）
print("添加元素后的内存使用情况（MB）:")
print("列表", sys.getsizeof(list_data) / 1024 / 1024)  # 以MB为单位
print("元组", sys.getsizeof(tuple_data) / 1024 / 1024)  # 以MB为单位

# 运行结果
# 初始内存使用情况（MB）:
# 762.9395065307617
# 762.9394912719727
# 添加元素后的内存使用情况（MB）:
# 列表 858.3069686889648
# 元组 762.9394989013672

列表不可作为字典的键，而元组可以。

示例代码

# 使用元组作为字典的键
dict_with_tuple_key = {(1, 2): 'value'}
print(dict_with_tuple_key[(1, 2)])  # 输出：'value'

# 使用列表作为字典的键（这会引发错误，因为列表是可变的）
dict_with_list_key = {[1, 2]: 'value'}  # 报错