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

心已赠人 2024-03-23 19:14 24阅读 0赞

## 数据容器：字典、映射 ##

### 1.1 字典的定义 ###

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

1.  使用`dict()`构造函数：
    
        empty_dict = dict()

*  定义非空字典
    
        # 定义一个字典
        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中，通过键来获取字典中对应的值。使用字典中的键来访问值被称为字典的索引操作。
 *  假设有一个字典如下：
    
        student_info = {
              
            "name": "Alice",
            "age": 20,
            "major": "Computer Science",
            "gpa": 3.8
        }
 *  可以按照以下方式获取字典中的数据：
    
        # 通过键获取值
        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()` 方法，该方法在获取不存在的键时会返回一个默认值：
    
        # 使用 get() 方法获取值
        phone = student_info.get("phone", "Not available")
        print("Phone:", phone)
 *  还可以使用 `in` 关键字来检查字典中是否存在特定的键：
    
        # 检查键是否存在
        if "name" in student_info:
            print("Name exists in student_info")
 *  总之，要从字典中获取数据，你需要使用键来访问对应的值，可以直接使用索引操作或者使用 `get()` 方法，同时要注意处理键不存在的情况。

### 1.3 字典的嵌套 ###

*  在Python中，可以在字典中嵌套其他字典，从而创建一个多层级的数据结构。这种嵌套字典的方式允许你创建更复杂的数据模型，以便更好地组织和管理数据。**每个嵌套层级都是一个字典，其中的值可以是其他字典、列表、字符串等等。**
 *  演示
    
        # 嵌套字典示例
        employee_data = {
              
            "employee1": {
              
                "name": "John",
                "age": 30,
                "position": "Manager"
            },
            "employee2": {
              
                "name": "Alice",
                "age": 25,
                "position": "Developer"
            }
        }
    
     *  `employee_data` 字典包含了两个嵌套的字典，分别代表两个员工的信息。每个嵌套的字典都有自己的键值对，用于存储员工的姓名、年龄和职位。
 *  访问嵌套字典中的数据：
    
        # 访问嵌套字典中的数据
        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 字典的常用操作 ###

*  字典常用操作总结

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

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

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

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()` 方法来删除字典中的键值对。

# 使用 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. 检查键是否存在：**

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

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

# 获取所有键
    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. 循环遍历字典：**

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

**6. 获取键值对数量：**

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

**7. 清空字典：**

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

**8. 复制字典：**

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. 合并字典：**

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. 获取默认值：**

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

**11. 遍历键值对：**

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

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

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}`。

1.  **基本语法：**
    
     *  字典解析的语法由花括号 `{}` 构成，其中包含了键值对的表达式。表达式的形式为 `key_expr: value_expr`，它们分别代表字典中的键和对应的值。
     *  循环语句用于迭代一个可迭代对象（例如列表、集合等），从中提取数据并生成键值对。
    
        new_dict = {
              key_expr: value_expr for item in iterable}
2.  **创建字典：**
    
     *  在字典解析中，通过循环迭代来创建新的字典。循环语句可以是任何可迭代对象，例如列表、集合、字符串等。
    
        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}
3.  **带条件的字典解析：**
    
     *  字典解析也可以包含条件语句，用于根据特定条件筛选数据并生成键值对。
    
        numbers = [1, 2, 3, 4, 5]
        even_squared_dict = {
              num: num ** 2 for num in numbers if num % 2 == 0}
        # 输出: {2: 4, 4: 16}
4.  **嵌套字典解析：**
    
     *  可以在字典解析中嵌套其他循环，从而生成嵌套字典。
    
        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}}
5.  **字典解析与循环的对比：**
    
     *  字典解析通常比传统循环更简洁，可读性更好。例如，将列表转换为字典：
    
        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
6.  **注意事项：**
    
     *  字典解析适用于较简单的情况，如果解析过于复杂，可能会降低代码的可读性。
     *  在大多数情况下，字典解析比使用传统的循环和 `append()` 方法来创建字典更加高效。