数据容器：字典、映射

1.1 字典的定义

在Python中，字典（Dictionary）是一种无序的数据集合，用于存储键（Key）和对应的值（Value）之间的映射关系。
字典使用花括号 {} 来表示，其中的每个元素是由一个键和一个值组成，键和值之间使用冒号 : 分隔。字典的键必须是唯一的，而值则可以重复。
Key和Value可以是任意类型的数据（key不可为字典）
Key不可重复，重复会对原有数据覆盖
定义空字典：
1. 使用花括号 {}：
python 复制代码
```
empty_dict = {}
```

使用dict()构造函数：
python 复制代码
```
empty_dict = dict()
```

定义非空字典
python 复制代码
```
# 定义一个字典
student_info = {
    "name": "Alice",
    "age": 20,
    "major": "Computer Science",
    "gpa": 3.8
}
```
- student_info 是一个字典，它包含了学生的姓名、年龄、专业和 GPA 信息。键和值之间的映射关系如下：
  - 键 "name" 对应值 "Alice"
  - 键 "age" 对应值 20
  - 键 "major" 对应值 "Computer Science"
  - 键 "gpa" 对应值 3.8
需要注意的是，字典是无序的，这意味着键值对的顺序不会被保留。如果你需要有序的字典，可以使用 Python 3.7+ 中引入的 collections.OrderedDict 类。
字典在Python中是一种常用的数据结构，用于存储和管理具有键值关系的数据。

1.2 字典数据的获取

在Python中，通过键来获取字典中对应的值。使用字典中的键来访问值被称为字典的索引操作。

假设有一个字典如下：

python 复制代码

student_info = {
    "name": "Alice",
    "age": 20,
    "major": "Computer Science",
    "gpa": 3.8
}

可以按照以下方式获取字典中的数据：

python 复制代码

# 通过键获取值
name = student_info["name"]
age = student_info["age"]
major = student_info["major"]
gpa = student_info["gpa"]

print("Name:", name)
print("Age:", age)
print("Major:", major)
print("GPA:", gpa)

如果尝试获取一个不存在的键，将会引发 KeyError 错误。为了避免这种情况，可以使用字典的 get() 方法，该方法在获取不存在的键时会返回一个默认值：
python 复制代码
```
# 使用 get() 方法获取值
phone = student_info.get("phone", "Not available")
print("Phone:", phone)
```

还可以使用 in 关键字来检查字典中是否存在特定的键：

python 复制代码

# 检查键是否存在
if "name" in student_info:
    print("Name exists in student_info")

总之，要从字典中获取数据，你需要使用键来访问对应的值，可以直接使用索引操作或者使用 get() 方法，同时要注意处理键不存在的情况。

1.3 字典的嵌套

在Python中，可以在字典中嵌套其他字典，从而创建一个多层级的数据结构。这种嵌套字典的方式允许你创建更复杂的数据模型，以便更好地组织和管理数据。每个嵌套层级都是一个字典，其中的值可以是其他字典、列表、字符串等等。

演示

python 复制代码

# 嵌套字典示例
employee_data = {
    "employee1": {
        "name": "John",
        "age": 30,
        "position": "Manager"
    },
    "employee2": {
        "name": "Alice",
        "age": 25,
        "position": "Developer"
    }
}

employee_data 字典包含了两个嵌套的字典，分别代表两个员工的信息。每个嵌套的字典都有自己的键值对，用于存储员工的姓名、年龄和职位。

访问嵌套字典中的数据：

python 复制代码

# 访问嵌套字典中的数据
employee1_name = employee_data["employee1"]["name"]
employee2_position = employee_data["employee2"]["position"]

print("Employee 1 name:", employee1_name)
print("Employee 2 position:", employee2_position)

通过多层索引操作，你可以深入嵌套字典层级来获取所需的数据。

1.4 字典的常用操作

字典常用操作总结

操作	描述	示例
访问和修改值	使用键访问值，也可以修改或新增键值对。	`my_dict[key] = value` `value = my_dict[key]`
删除键值对	使用 `del` 关键字或 `pop()` 方法删除键值对。	`del my_dict[key]` `value = my_dict.pop(key)`
检查键是否存在	使用 `in` 关键字检查键是否存在。	`if key in my_dict:`
获取所有键、值和键值对	使用 `keys()`, `values()`, `items()` 方法获取键、值和键值对。	`keys = my_dict.keys()` `values = my_dict.values()` `items = my_dict.items()`
循环遍历字典	使用 `for` 循环遍历字典中的键。	`for key in my_dict:` `value = my_dict[key]`
获取键值对数量	使用 `len()` 函数获取键值对的数量。	`length = len(my_dict)`
清空字典	使用 `clear()` 方法清空字典。	`my_dict.clear()`
复制字典	使用 `copy()` 方法或 `dict()` 构造函数复制字典。	`new_dict = my_dict.copy()` `new_dict = dict(my_dict)`
合并字典	使用 `update()` 方法合并字典，或使用字典解析。	`dict1.update(dict2)` `merged_dict = {dict1, dict2}`
获取默认值	使用 `get()` 方法获取键对应的值，提供默认值。	`value = my_dict.get(key, default_value)`
遍历键值对	使用 `items()` 方法遍历字典的键值对。	`for key, value in my_dict.items():` `# 执行操作`
默认字典（`defaultdict`）	创建带默认值的字典，使用 `defaultdict` 类。	`from collections import defaultdict` `default_dict = defaultdict(int)`

1.5 字典的常用操作详细演示

1. 访问和修改值： 通过键来访问字典中的值，也可以修改现有的键对应的值，或新增键值对。

python 复制代码

student_info = {
    "name": "Alice",
    "age": 20,
    "major": "Computer Science"
}

# 访问值
print(student_info["name"])  # 输出: Alice

# 修改值
student_info["age"] = 21

# 新增键值对
student_info["gpa"] = 3.8
print(student_info)
# 输出: {'name': 'Alice', 'age': 21, 'major': 'Computer Science', 'gpa': 3.8}

2. 删除键值对： 使用 del 关键字或 pop() 方法来删除字典中的键值对。

python 复制代码

# 使用 del 关键字
del student_info["major"]

# 使用 pop() 方法
gpa = student_info.pop("gpa")

print(student_info)
# 输出: {'name': 'Alice', 'age': 21}
print("Removed GPA:", gpa)  # 输出: Removed GPA: 3.8

3. 检查键是否存在：

python 复制代码

if "name" in student_info:
    print("Name exists in student_info")

4. 获取所有键、值和键值对：

python 复制代码

# 获取所有键
keys = student_info.keys()
print("Keys:", keys)  # 输出: Keys: dict_keys(['name', 'age'])

# 获取所有值
values = student_info.values()
print("Values:", values)  # 输出: Values: dict_values(['Alice', 21])

# 获取所有键值对
items = student_info.items()
print("Items:", items)  # 输出: Items: dict_items([('name', 'Alice'), ('age', 21)])

5. 循环遍历字典：

python 复制代码

for key in student_info:
    value = student_info[key]
    print(key, ":", value)
# 输出:
# name : Alice
# age : 21

6. 获取键值对数量：

python 复制代码

num_items = len(student_info)
print("Number of items:", num_items)  # 输出: Number of items: 2

7. 清空字典：

python 复制代码

student_info.clear()
print(student_info)  # 输出: {}

8. 复制字典：

python 复制代码

original_dict = {"a": 1, "b": 2}
new_dict = original_dict.copy()
new_dict["c"] = 3

print(original_dict)  # 输出: {'a': 1, 'b': 2}
print(new_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

9. 合并字典：

python 复制代码

dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}

# 使用 update() 方法
dict1.update(dict2)
print(dict1)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 使用字典解析
merged_dict = {**dict1, **dict2}
print(merged_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

10. 获取默认值：

python 复制代码

phone = student_info.get("phone", "Not available")
print("Phone:", phone)  # 输出: Phone: Not available

11. 遍历键值对：

python 复制代码

for key, value in student_info.items():
    print(key, ":", value)
# 输出:
# name : Alice
# age : 21

12. 默认字典（collections.defaultdict）：

python 复制代码

from collections import defaultdict

# 创建一个带默认值的字典，值的默认类型是 int
default_dict = defaultdict(int)

default_dict["a"] += 1
default_dict["b"] += 2
print(default_dict)  # 输出: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

1.6 字典的特点总结

可以容纳多个数据
可以容纳不同类型的数据
每一份数据是KeyValue键值对
可以通过Key获取到Value，Key不可重复（重复会覆盖）
不支持下标索引
可以修改（增加或删除更新元素等）
支持for循环，不支持while循环

1.7 补充：字典解析

字典解析（Dictionary Comprehension）是一种便捷的语法，允许使用紧凑的方式创建新的字典，同时可以在创建过程中应用条件和转换。
字典解析的基本结构是 {key_expr: value_expr for item in iterable}。

基本语法：
- 字典解析的语法由花括号 {} 构成，其中包含了键值对的表达式。表达式的形式为 key_expr: value_expr，它们分别代表字典中的键和对应的值。
- 循环语句用于迭代一个可迭代对象（例如列表、集合等），从中提取数据并生成键值对。
python 复制代码
```
new_dict = {key_expr: value_expr for item in iterable}
```
创建字典：
- 在字典解析中，通过循环迭代来创建新的字典。循环语句可以是任何可迭代对象，例如列表、集合、字符串等。
python 复制代码
```
numbers = [1, 2, 3, 4, 5]
squared_dict = {num: num ** 2 for num in numbers}
# 输出: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
```
带条件的字典解析：
- 字典解析也可以包含条件语句，用于根据特定条件筛选数据并生成键值对。
python 复制代码
```
numbers = [1, 2, 3, 4, 5]
even_squared_dict = {num: num ** 2 for num in numbers if num % 2 == 0}
# 输出: {2: 4, 4: 16}
```

嵌套字典解析：

可以在字典解析中嵌套其他循环，从而生成嵌套字典。

python 复制代码

outer_keys = ['a', 'b', 'c']
inner_values = [1, 2, 3]

nested_dict = {outer_key: {inner_key: inner_value for inner_key, inner_value in zip(outer_keys, inner_values)} for outer_key in outer_keys}
# 输出: {'a': {'a': 1, 'b': 2, 'c': 3}, 'b': {'a': 1, 'b': 2, 'c': 3}, 'c': {'a': 1, 'b': 2, 'c': 3}}

字典解析与循环的对比：

字典解析通常比传统循环更简洁，可读性更好。例如，将列表转换为字典：

python 复制代码

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 28]

# 使用字典解析
name_age_dict = {name: age for name, age in zip(names, ages)}

# 使用循环
name_age_dict = {}
for name, age in zip(names, ages):
    name_age_dict[name] = age

注意事项：
- 字典解析适用于较简单的情况，如果解析过于复杂，可能会降低代码的可读性。
- 在大多数情况下，字典解析比使用传统的循环和 append() 方法来创建字典更加高效。

数据魔杖：探索Python字典，实现数据变幻的妙技

数据容器：字典、映射

1.1 字典的定义

1.2 字典数据的获取

1.3 字典的嵌套

1.4 字典的常用操作

1.5 字典的常用操作详细演示

1.6 字典的特点总结

1.7 补充：字典解析