Python 使用 Dict 和 Set

1. 基本概念

1.1 什么是 Dict 和 Set？

• Dict（字典）：存储键值对（key-value）的无序、可变数据结构，键必须唯一且可哈希（如数字、字符串、元组），值可以是任意类型。用 {} 或 dict() 定义。
• Set（集合）：存储唯一元素的无序、可变数据结构，元素必须可哈希。支持数学集合操作（如并集、交集、差集）。用 {} 或 set() 定义。

1.2 创建 Dict 和 Set

# 创建字典
my_dict = {"name": "Alice", "age": 25, "city": "New York"}
empty_dict = {}

# 创建集合
my_set = {1, 2, 3, "hello"}
empty_set = set()  # 注意：空集合只能用 set()，{} 表示空字典

注意：

• 字典键必须不可变（如字符串、数字、元组），列表不可作为键。
• 集合元素必须可哈希，列表、字典不可哈希，所以不可作为集合的元素。
• 空集合用 set()，{} 表示空字典。

2. 基本操作：增删改查

2.1 查（访问元素）

字典访问

• 通过键访问值，键不存在抛出 KeyError。
• 使用 get() 方法安全访问，键不存在返回 None 或指定默认值。
• 遍历：通过 keys()、values() 或 items()。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 键访问
print(my_dict["name"])                    # 输出: Alice
print(my_dict.get("age"))                 # 输出: 25
print(my_dict.get("phone", "Not found"))  # 输出: Not found

# 遍历
for key in my_dict.keys():
    print(key, end=" ")                # 输出: name age city
    
for value in my_dict.values():
    print(value, end=" ")              # 输出: Alice 25 New York
    
for key, value in my_dict.items():
    print(f"{key}: {value}", end=" ")  # 输出: name: Alice age: 25 city: New York

集合访问

• 集合无索引，需通过遍历访问。
• 使用 in 检查元素存在。

my_set = {1, 2, 3, "hello"}

# 遍历
for item in my_set:
    print(item, end=" ")  # 输出: 1 2 3 hello

# 检查元素
print(2 in my_set)        # 输出: True
print(4 in my_set)        # 输出: False

2.2 增（添加元素）

字典添加

• 通过键赋值添加键值对。
• 使用 update() 批量添加。

my_dict = {"name": "Alice"}

# 键赋值
my_dict["age"] = 25
print(my_dict)      # 输出: {'name': 'Alice', 'age': 25}

# 批量添加
my_dict.update({"city": "New York", "phone": "12345"})
print(my_dict)      # 输出: {'name': 'Alice', 'age': 25, 'city': 'New York', 'phone': '12345'}

集合添加

• 使用 add() 添加单个元素。
• 使用 update() 添加多个元素。

my_set = {1, 2}

# 添加单个
my_set.add(3)
print(my_set)  # 输出: {1, 2, 3}

# 批量添加
my_set.update([4, 5, "hello"])
print(my_set)  # 输出: {1, 2, 3, 4, 5, 'hello'}

2.3 改（修改元素）

字典修改

• 通过键重新赋值修改值。
• 使用 update() 修改多个键值对。

my_dict = {"name": "Alice", "age": 25}

# 修改单个值
my_dict["age"] = 26
print(my_dict)  # 输出: {'name': 'Alice', 'age': 26}

# 批量修改
my_dict.update({"name": "Bob", "city": "Boston"})
print(my_dict)  # 输出: {'name': 'Bob', 'age': 26, 'city': 'Boston'}

集合修改

• 集合元素不可直接修改，需删除后添加。

my_set = {1, 2, 3}

# 删除后添加模拟修改
my_set.remove(2)
my_set.add(20)
print(my_set)  # 输出: {1, 3, 20}

2.4 删（删除元素）

字典删除

• 使用 pop() 删除指定键并返回值。
• 使用 del 删除键值对。
• 使用 clear() 清空字典。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

# 删除指定键
print(my_dict.pop("age"))  # 输出: 25
print(my_dict)             # 输出: {'name': 'Alice', 'city': 'New York'}

# 使用 del
del my_dict["city"]
print(my_dict)             # 输出: {'name': 'Alice'}

# 清空
my_dict.clear()
print(my_dict)             # 输出: {}

集合删除

• 使用 remove() 删除指定元素，不存在抛出 KeyError。
• 使用 discard() 删除元素，不存在不报错。
• 使用 pop() 随机删除并返回元素。
• 使用 clear() 清空集合。

my_set = {1, 2, 3, 4}

# 删除指定元素
my_set.remove(2)
print(my_set)         # 输出: {1, 3, 4}

# 删除不存在的元素（无报错）
my_set.discard(5)
print(my_set)         # 输出: {1, 3, 4}

# 随机删除
print(my_set.pop())   # 输出: 随机元素（如1）
print(my_set)         # 输出: 剩余元素（如{3, 4}）

# 清空
my_set.clear()
print(my_set)         # 输出: set()

3. 常用方法和操作

3.1 字典常用方法

• keys()：返回键序列。
• values()：返回值序列。
• items()：返回键值对元组。
• get(key, default)：安全获取值，没有指定key返回默认值。
• pop(key, default)：删除并返回，没有指定key返回默认值。
• popitem()：删除并返回最后一个键值对。在 Python 3.7 及更高版本中，字典是 有序 的，popitem() 方法会按照插入顺序删除并返回一个键值对。在早期的Python 版本中，字典是无序的，popitem() 可能会删除任何一个键值对。
• update()：批量更新。
• clear()：清空。

my_dict = {"a": 1, "b": 2, "c": 3}
print(list(my_dict.keys()))  # 输出: ['a', 'b', 'c']
print(my_dict.popitem())     # 输出: ('c', 3)
print(my_dict)               # 输出: {'a': 1, 'b': 2}

3.2 集合常用方法

• add()：添加元素。
• update()：批量添加。
• remove()、discard()、pop()：删除元素。
• clear()：清空。
• 集合操作：union()（并集）、intersection()（交集）、difference()（差集）、symmetric_difference()（对称差集）。

set1 = {1, 2, 3}
set2 = {2, 3, 4}

print(set1.union(set2))                 # 输出: {1, 2, 3, 4}
print(set1.intersection(set2))          # 输出: {2, 3}
print(set1.difference(set2))            # 输出: {1}
print(set1.symmetric_difference(set2))  # 输出: {1, 4}

3.3 其他操作

• 成员测试：使用 in。
• 长度：使用 len()。

my_dict = {"a": 1}
my_set = {1, 2}
print("a" in my_dict)  # 输出: True
print(1 in my_set)     # 输出: True
print(len(my_dict))    # 输出: 1
print(len(my_set))     # 输出: 2

4. Dict 和 Set 的实现与区别

4.1 实现原理

• Dict：基于哈希表实现，键通过哈希函数映射到存储位置，平均时间复杂度为 O(1)（查询、插入、删除）。但哈希冲突可能降低性能。
• Set：也是哈希表实现，存储唯一元素，无键值对，仅存储键，操作复杂度与字典类似。

4.2 主要区别

• 结构：字典存储键值对，集合只存储元素。
• 用途：字典适合映射关系（如查找值），集合适合去重或集合运算。
• 可变性：两者均可变，但集合元素和字典键必须可哈希。
• 方法：字典有键值对操作（如 items()），集合有数学运算（如 union()）。

5. 特性

• Dict：
  • 键唯一，覆盖重复键的值。
  • 无序（Python 3.7+ 插入顺序保留，但不依赖顺序）。
  • 支持快速查找、更新。
• Set：
  • 元素唯一，自动去重。
  • 无序，适合集合运算。
  • 高效检查元素存在性。

6. 注意事项

1. 键/元素限制：
   • 字典键和集合元素必须可哈希（如数字、字符串、元组），列表、字典不可哈希。
2. 错误处理：
   • 字典访问不存在的键抛出 KeyError，建议用 get()。
   • 集合 remove() 不存在元素抛出 KeyError，用 discard() 避免。
3. 内存开销：
   • 字典因存储键值对占用更多内存。
   • 集合较轻量，适合去重。
4. 性能：
   • 哈希表操作通常 O(1)，但大量哈希冲突可能退化到 O(n)。
5. 空集合：
   • 用 set() 创建空集合，{} 是空字典。
6. 嵌套：
   • 字典值可嵌套任意类型，键需可哈希。
   • 集合元素不可嵌套集合（可用 frozenset）。

my_dict = {"list": [1, 2], "tuple": (3, 4)}
print(my_dict)  # 输出: {'list': [1, 2], 'tuple': (3, 4)}

my_set = {1, frozenset({2, 3})}
print(my_set)   # 输出: {1, frozenset({2, 3})}

7. 总结

• Dict：适合键值映射，快速查找和更新，支持丰富方法。
• Set：适合去重和集合运算，元素唯一，高效成员测试。
• 两者基于哈希表，操作高效，但需注意键/元素的可哈希性和错误处理。