Python元组 vs 列表：相似之处和区别，解释

在本指南中，您将学习Python元组和列表之间的相似之处和不同之处。您还将了解何时应该使用元组。

列表和元组都是Python中的内置数据结构。它们可以用于存储一组元素。

从支持索引和切片到包含异构数据类型，元组和lists可能具有类似的功能。因此，了解这两者之间的相似之处和不同之处可以帮助您决定使用哪种数据结构。

让我们开始吧。

👩🏽‍💻 您可以启动Python REPL并跟随本教程。您还可以使用Geekflare’s online Python editor进行编码。

Python元组 vs 列表：相似之处是什么？

让我们从了解列表和元组之间的相似之处开始。为了更好地学习，我们展示了列表和元组的示例。

#1. Python可迭代对象

在Python中，列表用一对square括号括起来，而元组用圆括号括起来。您还可以通过逗号分隔的一组值来创建元组，而不使用parentheses括号。

它们都是可迭代对象；因此，您可以使用for循环遍历它们。

下面的代码单元格演示了如何通过列表进行迭代。

nums = [2,6,7,10]
print(f"nums的类型为{type(nums)}")
for num in nums:
  print(num)

# 输出
nums的类型为
2
6
7
10

如下所述，您也可以使用循环遍历元组

nums = (2,6,7,10)

# 注意：nums = 2,6,7,10 也是一个有效的元组。如果需要，请快速检查！

print(f"nums的类型为{type(nums)}")
for num in nums:
  print(num)

# 输出
nums的类型为
2
6
7
10

#2. 支持从其他序列创建

列表和元组的另一个相似之处是它们可以从现有序列（如字符串）创建。

sample_str = "Coding!"

下面的代码单元格演示了list(string)返回一个列表，其中的列表项是字符串中的字符。

list_from_str = list(sample_str)
print(list_from_str)

# 输出
['C', 'o', 'd', 'i', 'n', 'g', '!']

类似地，可以使用tuple(sequence)从字符串或其他序列创建元组。下面的代码单元格演示了如何做到这一点。

tuple_from_str = tuple(sample_str)
print(tuple_from_str)

# 输出
('C', 'o', 'd', 'i', 'n', 'g', '!')

#3. 支持索引和切片

Python支持零索引，其中第一个元素位于索引零，第二个元素位于索引一，依此类推。Python还支持负索引，其中最后一个元素位于索引-1，倒数第二个元素位于索引-2，依此类推。

list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!']
print(list_from_str[1])
# o

索引为-2的项是倒数第二个项，即'g'。

tuple_from_str = ('C', 'o', 'd', 'i', 'n', 'g', '!')
print(tuple_from_str[-2])
# g

在想要处理列表或元组的一小部分时，可以使用切片。list[start:end]返回从索引start开始，直到end-1的列表切片。开始的默认值为0，结束的默认值为可迭代对象的最后一个元素。

您可以使用相同的语法切片元组。让我们创建之前创建的列表和元组的切片。

list_from_str = ['C', 'o', 'd', 'i', 'n', 'g', '!']
print(list_from_str[0:5])

['C', 'o', 'd', 'i', 'n']

除了开始和结束值之外，您还可以指定一个步长值。tuple(start:end:step)返回元组的切片，从start到end-1，步长为step。

在这里，我们将步长值设置为2。因此，切片包含每个第二个元素。

#4.多个数据类型的集合

在我们考虑的示例中，列表和元组中的所有项都是相同的数据类型。

但是，您可以在单个列表或元组中存储不同数据类型的值。

下面的代码片段student_list包含了一个学生的姓名作为字符串，年龄作为整数和所获得的分数作为浮点数。

我们可以为元组提供一个类似的示例。

#5.支持成员测试

列表和元组都允许您对特定项的存在进行成员测试。如果要检查列表或元组中是否存在特定项，可以使用in运算符。

item in iterable的表达式在iterable包含item时评估为True；否则，为False。

到目前为止，您已经了解了列表和元组之间的相似之处。接下来，让我们了解这两种数据结构之间的关键差异。

Python元组vs列表:有哪些不同?

1. Python中列表的可变性和元组的不可变性之间的最重要的区别是，元组是不可变的。这意味着您无法原地修改元组。

这是一个例子。

元组是可变数据结构，因此我们可以通过更改特定索引处的项来修改列表，如下面的代码单元格中所示。

2.可变长度列表vs固定长度元组

列表是可变长度的数据结构。

您可以做以下操作：

在列表的末尾添加一个项目
从另一个列表添加项目到当前列表的末尾
从列表中的特定索引处移除项目

元组是固定长度的数据结构。因此，您不能从现有元组中添加或删除元素。但是，您可以重新定义元组以包含不同的元素。

3.内存中的大小

现在我们将在前一节学到的基础上进行扩展：列表是一种可变长度的数据结构。

当您最初定义列表时，在内存中为其分配了特定的大小。现在，当您使用append()或extend()方法修改列表时，需要分配额外的内存来存储添加的元素。该分配通常超过您添加的项目数。

因此，有必要跟踪列表中的项目数量和分配的空间。另外，由于列表是可变长度的，因此有一个指针指向列表项的地址。因此，长度为k的列表占用的内存比具有相同k元素的元组多。

这是一个简单的说明。

您可以使用内置的sys模块的getsizeof()方法在Python对象上获取对象在内存中的大小。

import sys

list1 = [4,5,9,14]
list_size = sys.getsizeof(list1)
print(f"列表的大小：{list_size}")

tuple1 = (4,5,9,14)
tuple_size = sys.getsizeof(tuple1)
print(f"元组的大小：{tuple_size}")

对于相同数量和值的元素，列表占用的内存比元组多，如下面的输出所验证。

# 输出
列表的大小：104
元组的大小：88

何时应该使用Python元组？

通过Python列表和元组之间的区别和相似之处，您知道如果您需要一个可变的集合，应该使用一个列表。

但是何时应该使用元组呢？

我们将在本节中讨论这个问题。

#1. 只读集合

每当您希望集合是不可变的时候，应将其定义为元组。假设color = (243,55,103)是一个包含RGB值的元组，对应于一种颜色。将颜色定义为元组可以确保其不可修改。

本质上，当您需要一个只读的集合：值在程序中不应被修改时，应考虑使用元组。这将防止对值进行意外修改。

#2. 字典键

例如，您可以使用列表项key_list作为键创建一个字典。您可以使用dict.fromkeys()方法从列表创建字典。

key_list = list("ABCD")
dict.fromkeys(key_list)

{'A': None, 'B': None, 'C': None, 'D': None}

假设您在创建字典之前修改了列表以将‘D’作为第一个元素（索引为0）。

现在，字典键‘A’会发生什么变化？

如果您尝试从key_list创建字典并访问与键‘A’对应的值，您将遇到KeyError。

key_list[0] = 'D'

dict.fromkeys(key_list)['A']

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
 in ()
----> 1 dict.fromkeys(key_list)['A']

KeyError: 'A'

字典的键应该是唯一的。因此，您不能有第二个‘D’作为键。

dict.fromkeys(key_list)
{'B': None, 'C': None, 'D': None} # A不再是键。

如果您使用元组，这种修改是不可能的，您更不容易遇到错误。因此，您应该优先使用元组的项作为键创建字典。

key_tuple = tuple(“ABCD”)
dict.fromkeys(key_tuple)
{‘A': None, ‘B': None, ‘C': None, ‘D': None}

key_tuple[0] = ‘D'
—————————————————————————
TypeError Traceback (most recent call last)
in ()
—-> 1 key_tuple[0] = ‘D'

TypeError: ‘tuple' object does not support item assignment

#3. 函数参数
元组的不可变性也使其适合作为函数参数传递。

考虑以下函数find_volume()，它根据给定的长、宽和高返回一个长方体的体积。

def find_volume(dimensions):
l,b,h = dimensions
return l*b*h

假设这些尺寸在一个名为dimensions的列表中可用。使用dimensions作为参数调用find_volume()函数将返回体积。

dimensions = [2,8,5] find_volume(dimensions)
80

您可以随时更改存储在列表中的尺寸。

dimensions = [20,8,5] find_volume(dimensions)
800

然而，有时您需要将值保持不变并抵制修改。这时，您应该考虑将参数存储为元组并在函数调用中使用它们。

#4. 函数的返回值
在Python中，您会遇到从函数返回的元组。当您从函数返回多个值时，Python会隐式地将它们作为元组返回。

考虑以下函数return_even()：

def return_even(num):
even = [i for i in range(num) if (i%2==0)] return even,len(even)

它以数字num作为参数。

它返回区间[0,num)中的偶数列表以及该列表的长度。

让我们将num的值设置为20并调用函数。

num = 20

调用return_even()将以元组的形式返回两个值。您可以使用函数调用作为验证参数来调用type()函数。

type(return_even(num)) #

您可以打印返回值以验证它是一个包含偶数列表作为第一个项目和列表长度作为第二个项目的元组。

print(return_even(num))
([0, 2, 4, 6, 8, 10, 12, 14, 16, 18], 10)

由于元组中有两个项目，您可以将它们解包到两个变量中，如下所示。

even_nums, count = return_even(num)

print(even_nums)
print(count)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18] 10

结论
希望本教程对比Python元组和列表提供了全面的比较。

让我们用一个简短的总结来结束本教程：

列表和元组是Python中的内置数据结构。

相似之处：可迭代性，支持索引，切片，不同的数据类型以及成员测试运算符。

关键区别：列表是可变的，元组是不可变的。

其他区别：元组是固定长度的，列表是变长的，元组在内存中占用的空间较小。

何时使用元组？用于不可变集合，字典键和函数参数。

接下来，查看链接以进行练习和学习。或者学习有关的方法。愉快学习！然后，愉快编码！👩🏽‍💻