二、Python 列表、元组、字典、集合区别

一、列表（List）

1.1 定义与创建

• 本质：基于动态数组实现的有序、可变序列，元素可重复，支持任意数据类型（包括嵌套结构）。
• 创建方式：

  # 常规创建
  list1 = [1, "apple", True, [3.14, None]]  # 混合类型
  list2 = list(range(5))  # 通过 range() 创建 [0, 1, 2, 3, 4]
  
  # 列表推导式（高效创建方式）
  squares = [x**2 for x in range(10)]  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  even_numbers = [x for x in range(20) if x % 2 == 0]  # 筛选偶数
  

1.2 核心操作与特性

• 索引与切片：

  fruits = ["apple", "banana", "cherry", "date"]
  print(fruits[1])       # 输出：banana（正向索引）
  print(fruits[-1])      # 输出：date（反向索引）
  print(fruits[1:3])     # 输出：["banana", "cherry"]（左闭右开）
  print(fruits[::2])     # 输出：["apple", "cherry"]（步长为 2）
  

• 增删改查：

  # 新增元素
  fruits.append("elderberry")   # 末尾添加
  fruits.insert(1, "blueberry") # 指定位置插入
  
  # 删除元素
  fruits.remove("banana")       # 按值删除
  popped = fruits.pop(2)        # 按索引删除并返回值
  del fruits[0]                 # 删除指定索引元素
  
  # 修改元素
  fruits[1] = "grape"           # 直接赋值修改
  
  # 查找元素
  index = fruits.index("cherry") # 返回元素索引（若不存在报错）
  count = fruits.count("apple")  # 统计元素出现次数
  

• 排序与反转：

  nums = [3, 1, 4, 1, 5, 9]
  nums.sort()          # 原地排序，结果：[1, 1, 3, 4, 5, 9]
  sorted_nums = sorted(nums, reverse=True)  # 非原地排序，降序：[9, 5, 4, 3, 1, 1]
  nums.reverse()       # 原地反转，结果：[9, 5, 4, 3, 1, 1]
  

1.3 进阶特性

• 解包操作：

  a, b, *rest = [1, 2, 3, 4, 5]  # a=1, b=2, rest=[3,4,5]（适用于任意长度列表）
  

• 列表拼接与重复：

  list_a = [1, 2] + [3, 4]  # 拼接：[1,2,3,4]
  list_b = [0] * 5          # 重复：[0,0,0,0,0]
  

• 内存优化：列表是动态扩容的，初始容量不足时会重新分配更大内存并复制元素（可通过 sys.getsizeof() 观察内存变化）。

二、元组（Tuple）

2.1 定义与创建

• 本质：基于不可变数组实现的有序序列，元素不可修改，适合存储固定数据（如坐标、配置信息）。
• 创建方式：

  # 常规创建（括号可省略）
  point = (3, 4)          # 坐标元组
  person = "Alice", 30, "Female"  # 无括号形式
  
  # 单元素元组（需加逗号）
  single = (5,)           # 避免与数学运算括号混淆
  

2.2 核心操作与特性

• 不可变性的意义：
  • 保证数据安全（防止意外修改）。
  • 可作为字典键或集合元素（需元素本身可哈希，如元组内元素均为不可变类型）。
• 操作限制：

  t = (1, 2, 3)
  # t[0] = 4  # 报错！元组元素不可修改
  

• 支持的操作：

  t = (1, 2, 2, 3)
  print(t[1])       # 输出：2（索引访问）
  print(t.count(2)) # 输出：2（统计元素出现次数）
  print(t.index(3)) # 输出：3（查找元素索引）
  

2.3 进阶特性

• 解包与交换值：

  x, y = (2, 3)       # 解包赋值：x=2, y=3
  a, b = b, a         # 快速交换变量值（无需临时变量）
  

• 性能优势：元组比列表创建更快、内存占用更小（适用于大量不可变数据存储）。

三、字典（Dictionary）

3.1 定义与创建

• 本质：基于哈希表实现的无序键值对集合，键必须唯一且不可变（如字符串、数字、元组），值可任意类型。
• 创建方式：

  # 常规创建
  info = {"name": "Bob", "age": 25, "is_student": True}
  
  # 字典推导式
  square_dict = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, 3:9, 4:16}
  
  # 从键值对序列创建
  items = [("a", 1), ("b", 2)]
  dict_from_items = dict(items)  # {"a":1, "b":2}
  

3.2 核心操作与特性

• 键值访问：

  user = {"name": "Alice", "email": "alice@example.com"}
  print(user["name"])       # 输出：Alice（直接访问，键不存在报错）
  print(user.get("age", 30)) # 输出：30（安全访问，默认值处理）
  

• 增删改查：

  # 新增/修改键值对
  user["age"] = 28          # 存在则修改，不存在则新增
  user.setdefault("gender", "Female")  # 仅当键不存在时设置默认值
  
  # 删除键值对
  del user["email"]         # 删除指定键
  popped_value = user.pop("age")  # 删除并返回对应值
  
  # 遍历字典
  for key in user:          # 遍历所有键
      print(key)
  for key, value in user.items():  # 遍历键值对
      print(key, value)
  

3.3 进阶特性

• 嵌套字典：

  students = {
      "s001": {"name": "Tom", "score": 90},
      "s002": {"name": "Lily", "score": 85}
  }
  print(students["s001"]["name"])  # 输出：Tom
  

• 常用方法：

  keys = user.keys()   # 获取所有键（返回视图对象，非列表）
  values = user.values() # 获取所有值
  dict_copy = user.copy() # 浅拷贝字典
  

• 性能注意：字典的查找、插入、删除操作平均时间复杂度为 O(1)，但哈希冲突可能导致性能下降。

四、集合（Set）

4.1 定义与创建

• 本质：基于哈希表实现的无序、不重复元素集合，元素必须可哈希（不可变类型）。
• 创建方式：

  # 常规创建（大括号或 set() 函数）
  fruits = {"apple", "banana", "apple"}  # 自动去重，结果：{"apple", "banana"}
  empty_set = set()  # 注意：{} 创建的是空字典，非空集合需用 set()
  
  # 集合推导式
  even_set = {x for x in range(10) if x % 2 == 0}  # {0, 2, 4, 6, 8}
  

4.2 核心操作与特性

• 集合运算：

  a = {1, 2, 3, 4}
  b = {3, 4, 5, 6}
  
  print(a | b)  # 并集：{1,2,3,4,5,6}
  print(a & b)  # 交集：{3,4}
  print(a - b)  # 差集：{1,2}
  print(a ^ b)  # 对称差集（仅属于其中一个集合的元素）：{1,2,5,6}
  

• 增删操作：

  s = {1, 2, 3}
  s.add(4)       # 添加单个元素
  s.update({5, 6}) # 添加多个元素（参数可为可迭代对象）
  s.remove(2)    # 删除元素（若不存在报错）
  s.discard(7)   # 安全删除（不存在不报错）
  

4.3 进阶特性

• 判断成员与子集：

  print(3 in s)       # 输出：True（判断元素是否存在）
  print({1, 2}.issubset(s))  # 输出：True（判断是否为子集）
  

• 应用场景：
  • 数据去重：list(set(my_list))（注意：会破坏原有顺序）。
  • 快速成员检查（比列表的 in 操作更快，时间复杂度 O(1)）。

五、数据类型对比表格

特性	列表（List）	元组（Tuple）	字典（Dict）	集合（Set）
有序性	是	是	否（Python 3.7+ 保持插入顺序）	否
可变性	可变	不可变	可变	可变
元素重复	允许	允许	键不允许，值允许	不允许
典型用途	动态数据序列	固定数据记录	键值对映射	去重、集合运算
内存占用	较高（动态扩容）	较低（不可变）	较高（哈希表开销）	较高（哈希表开销）
可哈希性	不可哈希（可变）	可哈希（若元素不可变）	键需可哈希	元素需可哈希

六、选择建议

1. 需要有序且可变的数据 → 列表（List）。
2. 需要不可变的固定数据（如配置、坐标） → 元组（Tuple）。
3. 需要通过键快速查找值 → 字典（Dictionary）。
4. 需要去重或集合运算（并、交、差） → 集合（Set）。

通过理解各数据类型的底层实现和特性，可在实际开发中选择最优结构，提升代码效率与可读性。