1. 列表 (List)

列表是 Python 中最常用的可变序列类型。

特点：

• 可变：创建后可以修改
• 有序：元素按插入顺序存储
• 异构：可以包含不同类型的元素
• 动态大小：自动扩展和收缩

基本操作：

# 创建列表
my_list = [1, 2, 3, 'a', 'b', 'c']
empty_list = []
list_from_range = list(range(5))  # [0, 1, 2, 3, 4]

# 访问元素
print(my_list[0])     # 1 (索引从0开始)
print(my_list[-1])    # 'c' (负索引从末尾开始)

# 修改元素
my_list[0] = 'x'      # ['x', 2, 3, 'a', 'b', 'c']

# 常用方法
my_list.append('d')       # 在末尾添加元素
my_list.insert(1, 'y')    # 在指定位置插入
popped = my_list.pop()    # 移除并返回最后一个元素
my_list.remove('a')       # 移除第一个匹配的元素
my_list.sort()            # 排序(原地修改)
sorted_list = sorted(my_list)  # 返回新排序列表

性能特点：

• 索引访问：O(1)
• 末尾追加/删除：O(1)
• 中间插入/删除：O(n)
• 搜索元素：O(n)

2. 元组 (Tuple)

元组是不可变的序列类型。

特点：

• 不可变：创建后不能修改
• 有序：元素按插入顺序存储
• 异构：可以包含不同类型的元素
• 固定大小：创建后不能改变

基本操作：

# 创建元组
my_tuple = (1, 2, 3, 'a', 'b', 'c')
single_element = (42,)    # 单元素元组必须有逗号
empty_tuple = ()
tuple_from_list = tuple([1, 2, 3])

# 访问元素
print(my_tuple[0])     # 1
print(my_tuple[-1])    # 'c'

# 不可变特性
# my_tuple[0] = 'x'    # 会抛出TypeError

# 常用操作
print(len(my_tuple))           # 获取长度
print(3 in my_tuple)           # 成员检查: True
concatenated = my_tuple + (7, 8, 9)  # 连接元组

使用场景：

• 数据不会被修改时
• 字典的键（因为不可变）
• 函数返回多个值时
• 作为记录使用（如坐标点 point = (x, y)）

3. 双端队列 (Deque)

collections.deque是一个线程安全、内存高效的双端队列。

特点：

• 双端操作：高效地从两端添加或删除
• 线程安全：原子性的 append 和 pop 操作
• 可变大小：可以动态扩展
• 固定长度选项：可以设置为固定大小

基本操作：

from collections import deque

# 创建deque
d = deque([1, 2, 3, 4])
empty_deque = deque()
bounded_deque = deque(maxlen=3)  # 固定长度队列

# 添加元素
d.append(5)         # 右端添加: [1, 2, 3, 4, 5]
d.appendleft(0)     # 左端添加: [0, 1, 2, 3, 4, 5]

# 移除元素
right = d.pop()     # 移除并返回右端元素 (5)
left = d.popleft()  # 移除并返回左端元素 (0)

# 其他操作
d.rotate(1)         # 向右旋转1位: [4, 1, 2, 3]
d.extend([6, 7])    # 右端扩展: [4, 1, 2, 3, 6, 7]
d.extendleft([-1])  # 左端扩展: [-1, 4, 1, 2, 3, 6, 7]

性能特点：

• 两端插入/删除：O(1)
• 中间插入/删除：O(n)
• 索引访问：O(n) (比列表慢)
• 旋转操作：O(k) (k是旋转步数)

4. 三者比较

5. 使用建议

1. 使用 List 当：
2. 需要频繁修改内容
3. 需要随机访问元素
4. 数据量不大且主要在末尾操作
5. 使用 Tuple 当：
6. 数据不应该被修改
7. 需要作为字典键使用
8. 函数返回多个值
9. 使用 Deque 当：
10. 需要频繁在两端添加/删除
11. 实现队列或栈结构
12. 需要线程安全的操作
13. 需要固定大小的滑动窗口

6. 高级技巧

6.1 列表推导式 vs 生成器表达式

# 列表推导式 (立即计算)
squares_list = [x**2 for x in range(10)]

# 生成器表达式 (惰性计算)
squares_gen = (x**2 for x in range(10))

6.2 命名元组

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(p.x, p.y)  # 11 22

6.3 Deque 作为队列

from collections import deque

queue = deque()
queue.append('a')  # 入队
queue.append('b')
item = queue.popleft()  # 出队 ('a')

6.4 切片操作

my_list = [0, 1, 2, 3, 4, 5]
print(my_list[1:4])    # [1, 2, 3]
print(my_list[::2])    # [0, 2, 4] (步长2)
print(my_list[::-1])   # [5, 4, 3, 2, 1, 0] (反转)

选择合适的数据结构可以显著提高代码的性能和可读性。根据具体需求在 List、Tuple 和 Deque 之间做出选择是编写高效 Python 代码的重要技能。