Python 中的列表（List）和元组（Tuple）

1.定义与语法差异

1. 列表的定义

列表使用方括号`[]`定义，元素之间用逗号分隔。列表的元素可以是不同数据类型，甚至嵌套其他列表或元组。

my_list = [1, "hello", True, [2, 3]]

2. 元组的定义

元组使用圆括号`()`定义，同样支持混合数据类型。需要注意的是，定义单元素元组时必须在元素后加逗号，以区别于数学表达式中的括号。

my_tuple = (1, "world", False, (4, 5))
single_element_tuple = (1,)  # 必须加逗号

2.核心区别：可变性

1. 列表的可变性

列表是可变对象，可以动态修改、添加或删除元素。以下代码展示了列表的各种操作：

my_list = [1, 2, 3]
print(f"初始列表: {my_list}")  # 输出: [1, 2, 3]

my_list[0] = 10  # 修改第一个元素
print(f"修改后: {my_list}")    # 输出: [10, 2, 3]

my_list.append(4)  # 添加元素
print(f"添加后: {my_list}")    # 输出: [10, 2, 3, 4]

my_list.pop()      # 删除最后一个元素
print(f"删除后: {my_list}")    # 输出: [10, 2, 3]

2. 元组的不可变性

元组一旦创建就不能修改，任何试图修改元组元素的操作都会引发`TypeError`：

my_tuple = (1, 2, 3)
try:
    my_tuple[0] = 10  # 尝试修改元组元素
except TypeError as e:
    print(f"错误: {e}")  # 输出: 'tuple' object does not support item assignment

3.操作方法对比

1. 列表的丰富方法

列表提供了大量内置方法用于操作，如排序、反转等：

my_list = [3, 1, 2]
print(f"初始列表: {my_list}")  # 输出: [3, 1, 2]

my_list.sort()  # 排序
print(f"排序后: {my_list}")    # 输出: [1, 2, 3]

my_list.reverse()  # 反转
print(f"反转后: {my_list}")    # 输出: [3, 2, 1]

2. 元组的有限方法

由于不可变性，元组的方法较少，主要有`count()`和`index()`：

my_tuple = (1, 2, 2, 3)
print(f"元组: {my_tuple}")           # 输出: (1, 2, 2, 3)
print(f"元素2的数量: {my_tuple.count(2)}")  # 输出: 2
print(f"元素3的索引: {my_tuple.index(3)}")  # 输出: 3

4.内存占用与性能差异

元组在内存占用和性能上通常优于列表，特别是在创建速度方面。以下测试代码展示了两者的性能差异：

import timeit

# 测试创建100万次的时间
list_creation = timeit.timeit(stmt="[1, 2, 3, 4, 5]", number=1000000)
tuple_creation = timeit.timeit(stmt="(1, 2, 3, 4, 5)", number=1000000)

print(f"列表创建时间: {list_creation:.6f} 秒")
print(f"元组创建时间: {tuple_creation:.6f} 秒")
print(f"元组创建速度是列表的 {list_creation/tuple_creation:.2f} 倍")

在我的测试环境中，元组的创建速度大约是列表的3倍，这是因为元组的不可变性使其内存分配更高效。

5.使用场景建议

1. 列表的适用场景

• 数据需要动态修改（增删改）
• 存储同类型数据的集合
• 需要使用丰富内置方法（如排序）

2. 元组的适用场景

• 存储不可变数据（如配置参数）
• 保证数据完整性（防止意外修改）
• 作为字典键（列表不可哈希，元组可哈希）
• 函数返回多个值

6.总结对比表

特性	列表（List）	元组（Tuple）
定义符号	方括号[]	圆括号()
可变性	可变（Mutable）	不可变（Immutable）
常用方法	append (), pop (), sort () 等	count(), index()
内存占用	较高（动态分配）	较低（静态分配）
创建速度	较慢	较快
哈希性	不可哈希	可哈希（可作字典键）
使用场景	动态数据操作	固定数据、函数返回值

理解列表和元组的这些区别，有助于你在编程时做出更合适的数据结构选择，从而编写出更高效、更健壮的代码。

list_vs_tuple.py

# 演示Python中列表和元组的区别
# 1. 定义与语法
my_list = [1, "hello", True, [2, 3]]
my_tuple = (1, "world", False, (4, 5))
single_element_tuple = (1,)  # 单元素元组需要逗号

print(f"列表: {my_list}")
print(f"元组: {my_tuple}")
print(f"单元素元组: {single_element_tuple}")

# 2. 可变性 - 列表可变
my_list = [1, 2, 3]
print("\n列表可变性演示:")
print(f"初始列表: {my_list}")

my_list[0] = 10  # 修改元素
print(f"修改后: {my_list}")

my_list.append(4)  # 添加元素
print(f"添加后: {my_list}")

my_list.pop()  # 删除元素
print(f"删除后: {my_list}")

# 元组不可变
my_tuple = (1, 2, 3)
print("\n元组不可变性演示:")
try:
    my_tuple[0] = 10  # 尝试修改元组元素
except TypeError as e:
    print(f"错误: {e}")

# 3. 常用方法
# 列表方法
my_list = [3, 1, 2]
print("\n列表方法演示:")
print(f"初始列表: {my_list}")

my_list.sort()  # 排序
print(f"排序后: {my_list}")

my_list.reverse()  # 反转
print(f"反转后: {my_list}")

# 元组方法
my_tuple = (1, 2, 2, 3)
print("\n元组方法演示:")
print(f"元组: {my_tuple}")
print(f"元素2的数量: {my_tuple.count(2)}")
print(f"元素3的索引: {my_tuple.index(3)}")

# 4. 性能对比 - 创建时间测试
import timeit

list_creation = timeit.timeit(stmt="[1, 2, 3, 4, 5]", number=1000000)
tuple_creation = timeit.timeit(stmt="(1, 2, 3, 4, 5)", number=1000000)

print("\n性能对比:")
print(f"列表创建时间: {list_creation:.6f} 秒")
print(f"元组创建时间: {tuple_creation:.6f} 秒")
print(f"元组创建速度是列表的 {list_creation/tuple_creation:.2f} 倍")