【基础】字典与集合的基本操作

# 1. 修改和删除

### 2.1.1 字典的创建和初始化

字典可以使用大括号 `{}` 创建，其中键值对以冒号 `:` 分隔，键和值之间使用逗号 `,` 分隔。例如：

my_dict = {"name": "John", "age": 30, "city": "New York"}

也可以使用 `dict()` 函数创建字典，并传入键值对列表或元组列表。例如：

my_dict = dict([("name", "John"), ("age", 30), ("city", "New York")])

# 2. 修改和删除

### 2.1 字典的创建、修改和删除

#### 2.1.1 字典的创建和初始化

字典可以通过两种方式创建：

1. 使用大括号 `{}` 初始化一个空字典：

my_dict = {}

2. 使用 `dict()` 函数初始化一个字典，并指定键值对：

my_dict = dict(key1="value1", key2="value2")

#### 2.1.2 字典元素的添加、修改和删除

**添加元素：**

my_dict["key3"] = "value3"  # 添加新的键值对

**修改元素：**

my_dict["key2"] = "updated_value"  # 修改现有键值对

**删除元素：**

del my_dict["key3"]  # 删除指定的键值对

#### 2.1.3 字典的清空和删除

**清空字典：**

my_dict.clear()  # 清空字典中的所有键值对

**删除字典：**

del my_dict  # 删除整个字典

### 2.2 集合的创建、修改和删除

#### 2.2.1 集合的创建和初始化

集合可以通过以下方式创建：

1. 使用大括号 `{}` 初始化一个空集合：

my_set = set()

2. 使用 `set()` 函数初始化一个集合，并指定元素：

my_set = set([1, 2, 3])

#### 2.2.2 集合元素的添加、修改和删除

**添加元素：**

my_set.add(4)  # 添加一个新元素

**修改元素：**
集合中的元素不可修改，因此无法直接修改元素。

**删除元素：**

my_set.remove(2)  # 删除指定的元素

#### 2.2.3 集合的清空和删除

**清空集合：**

my_set.clear()  # 清空集合中的所有元素

**删除集合：**

del my_set  # 删除整个集合

# 3. 字典与集合的遍历和查找

### 3.1 字典的遍历和查找

#### 3.1.1 字典键的遍历

遍历字典键可以获得字典中所有键的列表。Python 提供了以下方法：

# 使用 keys() 方法获取字典键列表
keys = my_dict.keys()

**代码逻辑分析：**

* `my_dict.keys()` 方法返回一个包含字典所有键的视图对象。
* 视图对象是一个动态更新的列表，这意味着对字典进行任何更改都会反映在视图中。

#### 3.1.2 字典值的遍历

遍历字典值可以获得字典中所有值的列表。Python 提供了以下方法：

# 使用 values() 方法获取字典值列表
values = my_dict.values()

**代码逻辑分析：**

* `my_dict.values()` 方法返回一个包含字典所有值的视图对象。
* 与 `keys()` 方法类似，`values()` 方法返回的视图对象也是动态更新的。

#### 3.1.3 字典中元素的查找

在字典中查找元素可以通过键来进行。Python 提供了以下方法：

# 使用 get() 方法查找键对应的值
value = my_dict.get(key)

# 如果键不存在，则返回默认值
value = my_dict.get(key, default_value)

**代码逻辑分析：**

* `get()` 方法接受一个键作为参数，并返回与该键关联的值。
* 如果键不存在，`get()` 方法返回 `None`。
* 可以通过提供第二个参数 `default_value` 来指定键不存在时的默认值。

### 3.2 集合的遍历和查找

#### 3.2.1 集合元素的遍历

遍历集合可以获得集合中所有元素的列表。Python 提供了以下方法：

# 使用 for 循环遍历集合
for element in my_set:
    # ...

# 使用 list() 方法获取集合元素列表
elements = list(my_set)

**代码逻辑分析：**

* `for` 循环直接遍历集合中的元素。
* `list()` 方法将集合转换为一个列表，然后可以对其进行遍历。

#### 3.2.2 集合中元素的查找

在集合中查找元素可以通过 `in` 运算符来进行。

# 检查元素是否在集合中
if element in my_set:
    # ...

**代码逻辑分析：**

* `in` 运算符返回一个布尔值，表示元素是否在集合中。

# 4. 字典与集合的应用场景

### 4.1 字典的应用场景

#### 4.1.1 存储键值对数据

字典最常见的应用场景是存储键值对数据，即以键作为索引，以值作为数据。例如：

user_info = {
    "name": "John Doe",
    "age": 30,
    "email": "john.doe@example.com"
}

在这个例子中，字典 `user_info` 存储了三个键值对：`name` 对应值 "John Doe"，`age` 对应值 30，`email` 对应值 "john.doe@example.com"。

#### 4.1.2 实现映射关系

字典还可以用于实现映射关系，即根据一个键获取另一个键对应的值。例如：

country_codes = {
    "US": "United States",
    "CA": "Canada",
    "UK": "United Kingdom"
}

在这个例子中，字典 `country_codes` 实现了国家代码到国家名称的映射。我们可以通过 `country_codes["US"]` 获得 "United States"，通过 `country_codes["CA"]` 获得 "Canada"。

#### 4.1.3 构建数据结构

字典还可以用于构建更复杂的数据结构。例如，我们可以使用字典表示一个树形结构：

tree = {
    "root": {
        "left": "left_child",
        "right": "right_child"
    },
    "left_child": {
        "left": None,
        "right": None
    },
    "right_child": {
        "left": None,
        "right": None
    }
}

在这个例子中，字典 `tree` 表示一个二叉树，其中 "root" 是根节点，"left_child" 和 "right_child" 是左子节点和右子节点。

### 4.2 集合的应用场景

#### 4.2.1 存储无序且不重复的数据

集合最常见的应用场景是存储无序且不重复的数据。例如：

unique_numbers = set([1, 2, 3, 4, 5])

在这个例子中，集合 `unique_numbers` 存储了五个不重复的数字。集合中的元素没有特定的顺序，并且不能重复。

#### 4.2.2 实现集合运算

集合可以用于实现集合运算，如并集、交集和差集。例如：

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

# 并集
set_union = set1.union(set2)  # {1, 2, 3, 4, 5}

# 交集
set_intersection = set1.intersection(set2)  # {3}

# 差集
set_difference = set1.difference(set2)  # {1, 2}

#### 4.2.3 构建数据结构

集合还可以用于构建更复杂的数据结构。例如，我们可以使用集合表示一个图：

graph = {
    "A": {"B", "C"},
    "B": {"A", "D"},
    "C": {"A", "E"},
    "D": {"B", "E"},
    "E": {"C", "D"}
}

在这个例子中，字典 `graph` 表示一个无向图，其中键是节点，值是与该节点相连的节点集合。

# 5. 字典与集合的性能比较

### 5.1 字典的性能特点

#### 5.1.1 字典的查找和插入效率

字典使用哈希表来存储键值对，哈希表是一种基于键的快速查找数据结构。当查找或插入一个键值对时，字典会根据键计算一个哈希值，然后使用该哈希值来确定键值对在哈希表中的位置。这种机制使得字典的查找和插入操作具有较高的效率，通常为 O(1)。

#### 5.1.2 字典的内存占用

字典的内存占用主要取决于键值对的数量和键值对的平均长度。每个键值对都需要存储键和值，因此字典的内存占用与键值对的数量成正比。此外，键和值的大小也会影响字典的内存占用。

### 5.2 集合的性能特点

#### 5.2.1 集合的查找和插入效率

集合使用哈希表来存储元素，与字典类似，集合的查找和插入操作也具有 O(1) 的效率。集合中的元素是无序的，因此集合不支持基于索引的查找。

#### 5.2.2 集合的内存占用

集合的内存占用主要取决于元素的数量和元素的平均长度。与字典类似，集合的内存占用与元素的数量成正比。

### 5.3 字典与集合的性能比较总结

| 特征 | 字典 | 集合 |
|---|---|---|
| 查找和插入效率 | O(1) | O(1) |
| 内存占用 | 与键值对数量和平均长度成正比 | 与元素数量和平均长度成正比 |
| 查找方式 | 基于键 | 基于哈希值 |
| 元素顺序 | 有序 | 无序 |
| 支持重复元素 | 不支持 | 不支持 |

### 5.4 性能优化建议

根据字典和集合的性能特点，可以采取以下措施来优化性能：

- **选择合适的键类型：**对于字典，选择哈希值分布均匀的键类型可以提高查找和插入效率。
- **避免使用可变对象作为键或元素：**可变对象可能会导致哈希值发生变化，从而影响字典或集合的性能。
- **合理使用内置方法：**字典和集合提供了一系列内置方法，例如 `get()`、`add()`、`remove()` 等，合理使用这些方法可以提高代码效率。
- **考虑使用其他数据结构：**如果性能要求非常高，可以考虑使用其他数据结构，例如 B 树或红黑树。

# 6. 字典与集合的最佳实践

### 6.1 字典的最佳实践

#### 6.1.1 选择合适的键类型

选择合适的键类型对于字典的性能至关重要。理想的键类型应具有以下特征：

- **哈希性能良好：**键类型应支持高效的哈希函数，以便快速查找和插入。
- **不可变：**键类型应不可变，以避免字典的意外修改。
- **轻量级：**键类型应尽可能轻量级，以减少内存占用。

常见且合适的键类型包括：

- 整数
- 字符串
- 元组

#### 6.1.2 避免使用可变对象作为键

避免使用可变对象（如列表、字典）作为键。可变对象可能会在字典创建后发生改变，导致字典的键发生改变，从而影响查找和插入的效率。

#### 6.1.3 合理使用字典的内置方法

字典提供了一系列内置方法，用于常见操作，如查找、插入和删除。合理使用这些方法可以提高代码的可读性和效率。

以下是一些常用的字典内置方法：

- `get(key, default=None)`：获取指定键的值，如果键不存在，返回默认值。
- `setdefault(key, default)`：如果指定键不存在，则将其添加到字典中并返回默认值。
- `pop(key, default=None)`：删除指定键并返回其值，如果键不存在，返回默认值。
- `update(other_dict)`：将另一个字典中的键值对添加到当前字典中。

### 6.2 集合的最佳实践

#### 6.2.1 选择合适的集合类型

根据集合的特定用途选择合适的集合类型。Python 提供了多种集合类型，包括：

- `set`：无序、不重复元素的集合。
- `frozenset`：不可变的 `set`。
- `list`：有序、可重复元素的列表。
- `tuple`：有序、不可变元素的元组。

#### 6.2.2 避免使用可变对象作为元素

与字典类似，避免使用可变对象（如列表、字典）作为集合元素。可变对象可能会在集合创建后发生改变，导致集合元素发生改变，从而影响查找和插入的效率。

#### 6.2.3 合理使用集合的内置方法

集合也提供了一系列内置方法，用于常见操作，如查找、插入和删除。合理使用这些方法可以提高代码的可读性和效率。

以下是一些常用的集合内置方法：

- `add(element)`：将元素添加到集合中。
- `remove(element)`：从集合中删除指定元素。
- `discard(element)`：尝试从集合中删除指定元素，如果元素不存在，不会引发异常。
- `union(other_set)`：返回当前集合与另一个集合的并集。
- `intersection(other_set)`：返回当前集合与另一个集合的交集。