MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python列表和元组差异深度剖析

2023-01-235.6k 阅读

Python 列表和元组基础概念

在 Python 编程领域，列表（List）和元组（Tuple）是两种极为常用的数据结构。它们都能用于存储多个元素，乍看之下有些相似，但在本质特性、使用场景等方面存在诸多差异。深入理解这些差异，对于写出高效、健壮的 Python 代码至关重要。

列表

列表是 Python 中一种可变（mutable）的有序序列。所谓可变，即列表中的元素可以在创建之后进行修改、添加或删除操作。用方括号 [] 来定义列表，其中的元素以逗号分隔。例如：

my_list = [1, 2, 3, 'apple', 4.5]

这里的 my_list 包含了整数、字符串和浮点数等不同类型的元素，Python 的列表允许这种混合类型的存储，展现出高度的灵活性。

元组

元组则是一种不可变（immutable）的有序序列。一旦创建，其元素就不能被修改、添加或删除。使用圆括号 () 来定义元组，元素同样以逗号分隔。例如：

my_tuple = (1, 2, 'banana', 3.14)

尽管元组看起来和列表很像，但不可变性是它们之间的关键区别。

可变性差异

列表的可变性操作

  1. 修改元素：由于列表的可变性，我们可以通过索引直接修改列表中的元素。例如：
my_list = [1, 2, 3]
my_list[1] = 100
print(my_list)

运行结果为 [1, 100, 3]，列表中索引为 1 的元素从 2 变为了 100。 2. 添加元素：列表提供了多种添加元素的方法，如 append() 方法用于在列表末尾添加一个元素，insert() 方法可在指定位置插入元素。

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)
my_list.insert(1, 5)
print(my_list)

上述代码中，首先使用 append() 方法在列表末尾添加了元素 4，接着使用 insert() 方法在索引为 1 的位置插入了元素 5。最终列表变为 [1, 5, 2, 3, 4]。 3. 删除元素：可以使用 del 语句或者列表的 remove() 方法删除元素。del 语句通过索引删除元素，remove() 方法则删除指定值的元素。

my_list = [1, 2, 3, 2]
del my_list[1]
print(my_list)
my_list.remove(2)
print(my_list)

这里先用 del 删除了索引为 1 的元素 2，然后用 remove() 删除了值为 2 的第一个元素，最终列表变为 [1, 3]。

元组的不可变性体现

  1. 禁止修改元素：由于元组不可变，尝试修改元组元素会导致错误。例如：
my_tuple = (1, 2, 3)
try:
    my_tuple[1] = 100
except TypeError as e:
    print(f"Error: {e}")

运行这段代码会抛出 TypeError: 'tuple' object does not support item assignment 的错误，表明元组不支持元素赋值操作。 2. 禁止添加元素：元组没有类似列表 append() 或 insert() 的方法来添加元素。

my_tuple = (1, 2, 3)
try:
    my_tuple.append(4)
except AttributeError as e:
    print(f"Error: {e}")

这里尝试对元组使用 append() 方法，会抛出 AttributeError: 'tuple' object has no attribute 'append' 的错误，因为元组不存在该属性。 3. 禁止删除元素：同样，元组也不能直接删除单个元素，因为其不可变性。

my_tuple = (1, 2, 3)
try:
    del my_tuple[1]
except TypeError as e:
    print(f"Error: {e}")

运行此代码会抛出 TypeError: 'tuple' object doesn't support item deletion 的错误，说明元组不支持删除单个元素操作。不过，我们可以通过重新创建一个新元组来达到类似删除部分元素的效果，例如：

my_tuple = (1, 2, 3)
new_tuple = my_tuple[:1] + my_tuple[2:]
print(new_tuple)

这里通过切片操作，重新创建了一个新元组 new_tuple，它不包含原元组索引为 1 的元素，新元组为 (1, 3)。

内存占用差异

列表的内存占用

列表的可变性决定了它在内存管理上相对复杂。由于列表元素可以动态变化，Python 需要为其分配额外的内存空间来应对可能的增长。列表对象除了存储元素本身，还需要维护一些元数据，如当前元素数量、分配的内存大小等。 当我们创建一个列表时，Python 会根据初始元素的数量分配一定的内存空间。如果后续元素增加导致空间不足，列表会重新分配内存，将原有的元素复制到新的内存位置，并释放旧的内存。这种动态内存分配机制虽然提供了灵活性，但也带来了额外的开销。 例如，我们可以通过 sys.getsizeof() 函数来查看列表的内存占用情况：

import sys
my_list = []
print(sys.getsizeof(my_list))
my_list.append(1)
print(sys.getsizeof(my_list))
my_list.append(2)
print(sys.getsizeof(my_list))

在不同的 Python 版本和系统环境下，具体的数值可能会有所不同，但总体趋势是随着列表元素的增加，内存占用逐步上升，而且每次增加元素时，内存增长并非均匀的，因为涉及到内存重新分配的策略。

元组的内存占用

元组由于其不可变性，在内存管理上相对简单且高效。一旦元组创建，其大小就固定下来，Python 可以为其分配连续的内存空间来存储所有元素，并且不需要额外的空间来应对元素的动态变化。 同样使用 sys.getsizeof() 函数查看元组的内存占用：

import sys
my_tuple = ()
print(sys.getsizeof(my_tuple))
my_tuple = (1,)
print(sys.getsizeof(my_tuple))
my_tuple = (1, 2)
print(sys.getsizeof(my_tuple))

与列表相比，元组的内存占用增长相对稳定，因为不需要为动态变化预留额外空间。在存储大量数据且数据不会发生变化的情况下，使用元组可以显著节省内存。

性能差异

列表的性能特点

  1. 访问性能：列表是有序序列，通过索引访问元素的时间复杂度为 O(1)，这意味着无论列表有多大，访问特定索引位置的元素所花费的时间基本相同。例如：
import timeit
my_list = list(range(1000000))
def access_list():
    return my_list[500000]
print(timeit.timeit(access_list, number = 1000))

这里通过 timeit 模块来测试访问列表中特定元素 1000 次所需的时间，由于时间复杂度为 O(1)，所以即使列表规模很大，访问速度依然较快。 2. 修改性能：由于列表的可变性，在列表中间插入或删除元素时，需要移动后续的元素，时间复杂度为 O(n)，其中 n 是列表的长度。随着列表规模的增大，这种操作的开销会显著增加。例如：

import timeit
my_list = list(range(10000))
def insert_list():
    my_list.insert(5000, 100)
    return my_list
print(timeit.timeit(insert_list, number = 1000))

这里测试在列表中间插入元素 1000 次的时间，随着列表长度的增加，插入操作所需时间会明显增长。

元组的性能特点

  1. 访问性能：元组同样是有序序列，通过索引访问元素的时间复杂度也是 O(1)，与列表在访问速度上基本一致。例如：
import timeit
my_tuple = tuple(range(1000000))
def access_tuple():
    return my_tuple[500000]
print(timeit.timeit(access_tuple, number = 1000))

这里测试访问元组中特定元素 1000 次的时间，和列表类似，访问速度较快。 2. 不可变带来的性能优势：由于元组不可变，在创建和迭代元组时性能会优于列表。创建元组时，不需要额外的空间预留和动态内存分配，因此创建速度更快。在迭代元组时，由于内存布局更紧凑且稳定，迭代效率也更高。例如：

import timeit
my_list = list(range(1000000))
my_tuple = tuple(range(1000000))
def iterate_list():
    for i in my_list:
        pass
def iterate_tuple():
    for i in my_tuple:
        pass
print(timeit.timeit(iterate_list, number = 1000))
print(timeit.timeit(iterate_tuple, number = 1000))

通常情况下，迭代元组的时间会比迭代列表更短，尤其是在数据量较大时这种差异更明显。

数据安全性差异

列表的数据安全风险

列表的可变性虽然提供了灵活性，但也带来了数据安全方面的风险。在多线程或多人协作编程环境中，如果多个部分同时对列表进行修改操作，可能会导致数据不一致的问题。例如：

import threading
my_list = [1, 2, 3]
def modify_list():
    global my_list
    my_list.append(4)
    my_list[1] = 100
threads = []
for _ in range(5):
    t = threading.Thread(target = modify_list)
    threads.append(t)
    t.start()
for t in threads:
    t.join()
print(my_list)

在这段代码中，多个线程同时对列表进行修改操作，由于线程调度的不确定性，最终列表的状态可能并非如预期，出现数据不一致的情况。

元组的数据安全性

元组的不可变性使得它在数据安全方面具有天然的优势。一旦元组创建，其内容就无法被修改，这在多线程或多人协作编程中可以避免数据被意外修改的风险。例如，在多线程环境中传递元组作为参数，不用担心其他线程会修改元组的内容，从而保证了数据的一致性和安全性。

import threading
my_tuple = (1, 2, 3)
def use_tuple():
    print(my_tuple)
threads = []
for _ in range(5):
    t = threading.Thread(target = use_tuple)
    threads.append(t)
    t.start()
for t in threads:
    t.join()

这里多个线程可以安全地使用元组，而不会出现数据被篡改的问题。

应用场景差异

列表的应用场景

  1. 数据处理与分析：在数据处理和分析任务中，经常需要对数据进行筛选、排序、修改等操作，列表的可变性使其非常适合这类场景。例如，从一个数据集中筛选出符合特定条件的元素，并对这些元素进行修改：
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtered_data = [num for num in data if num % 2 == 0]
for i in range(len(filtered_data)):
    filtered_data[i] = filtered_data[i] * 2
print(filtered_data)

这里先通过列表推导式筛选出数据集中的偶数，然后对这些偶数进行翻倍操作，列表的可变性使得这些操作能够顺利进行。 2. 动态数据结构：当需要一个可以动态增长或收缩的数据结构时，列表是理想的选择。比如实现一个简单的栈或队列数据结构，列表可以方便地进行元素的入栈、出栈、入队、出队等操作。

stack = []
stack.append(1)
stack.append(2)
print(stack.pop())

这里用列表实现了一个简单的栈，通过 append() 方法入栈，pop() 方法出栈。

元组的应用场景

  1. 配置参数：在程序中，一些配置参数通常不会在运行过程中发生变化，使用元组来存储这些参数可以保证数据的安全性。例如，数据库连接配置参数：
db_config = ('localhost', 3306, 'username', 'password')

这里的 db_config 元组存储了数据库连接所需的参数，由于其不可变性，避免了在程序运行过程中参数被意外修改的风险。 2. 函数返回多个值：Python 函数可以返回多个值，实际上返回的是一个元组。例如：

def divide(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder
result = divide(10, 3)
print(result)

这里的 divide() 函数返回商和余数，实际上返回的是一个元组 (3, 1)，调用者可以方便地接收这个元组并进行后续处理。

综上所述，列表和元组在 Python 编程中各自有着独特的特点和适用场景。深入理解它们之间的差异，能够帮助开发者根据具体需求选择最合适的数据结构，从而编写出更高效、更安全的 Python 代码。在实际编程中，应根据数据的性质（是否会变化）、性能要求、内存限制以及数据安全等多方面因素来综合考虑选择使用列表还是元组。