字典(dict)篇（一）

4.1字典创建

在Python中，你可以使用花括号 {} 来创建一个字典。字典是一种无序的数据结构，它存储键值对（key-value pairs），其中每个键都是唯一的，而值可以是任何数据类型。

以下是一些创建字典的例子：

# 创建一个空字典
empty_dict = {}

# 创建一个包含几个键值对的字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 使用字典推导式创建一个字典
dict_from_list = {i: i**2 for i in range(5)}  # 结果为 {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 创建一个嵌套字典
nested_dict = {
    'person': {
        'name': 'Bob',
        'address': {
            'street': '123 Main St',
            'city': 'San Francisco'
        }
    }
}

# 访问字典中的值
print(my_dict['name'])  # 输出 'Alice'

# 添加或修改字典中的值
my_dict['age'] = 31  # 修改现有的键值对
my_dict['occupation'] = 'Engineer'  # 添加新的键值对

# 检查键是否在字典中
if 'name' in my_dict:
    print('The key "name" exists in the dictionary.')

# 删除字典中的键值对
del my_dict['occupation']

# 遍历字典的键和值
for key, value in my_dict.items():
    print(f'{key}: {value}')

# 遍历字典的键
for key in my_dict.keys():
    print(key)

# 遍历字典的值
for value in my_dict.values():
    print(value)

在上面的例子中，我们展示了如何创建一个空字典，如何添加键值对到字典中，如何访问字典中的值，如何修改和删除字典中的值，以及如何遍历字典的键和值。字典是一种非常灵活和强大的数据结构，在Python编程中经常被用来存储和组织数据。

4.2 clear()函数

在Python中，clear() 是一个字典（dictionary）对象的方法，用于移除字典中的所有键值对，将其变为一个空字典。调用 clear() 方法后，原字典中的所有内容都将被删除，字典将不再包含任何键值对。

下面是一个使用 clear() 方法的例子：

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 打印原始字典
print("原始字典:", my_dict)

# 使用clear()方法清除字典中的所有键值对
my_dict.clear()

# 打印清除后的字典
print("清除后的字典:", my_dict)

输出将会是：

原始字典: {'name': 'Alice', 'age': 30, 'city': 'New York'}
清除后的字典: {}

可以看到，调用 my_dict.clear() 之后，my_dict 变成了一个空字典。

需要注意的是，clear() 方法没有返回值（或者说返回 None），并且它会直接修改原字典对象，而不是创建一个新的空字典。因此，调用 clear() 之后，你不需要再为字典分配新的内存空间，原变量现在引用的是一个空的字典对象。

4.3 copy()函数

在Python中，字典（dictionary）的 copy() 方法用于创建字典的一个浅拷贝（shallow copy）。这意味着它会创建一个新的字典，新字典中的键和值是对原字典中相应键和值的引用。如果原字典的值是可变对象（如列表、字典等），则在新字典中对这些值的修改也会反映到原字典中。

以下是如何使用 copy() 方法的一个简单例子：

# 创建一个字典
original_dict = {
    'name': 'Alice',
    'age': 30,
    'hobbies': ['reading', 'traveling']
}

# 使用copy()方法创建原字典的浅拷贝
copied_dict = original_dict.copy()

# 修改原字典的一个值
original_dict['age'] = 31

# 修改原字典中的一个可变值
original_dict['hobbies'].append('cooking')

# 打印原字典和拷贝后的字典
print("Original Dictionary:", original_dict)
print("Copied Dictionary:", copied_dict)

输出将会是：

Original Dictionary: {'name': 'Alice', 'age': 31, 'hobbies': ['reading', 'traveling', 'cooking']}
Copied Dictionary: {'name': 'Alice', 'age': 30, 'hobbies': ['reading', 'traveling', 'cooking']}

可以看到，虽然我们对原字典 original_dict 的 age 键的值进行了修改，但拷贝后的字典 copied_dict 中的 age 键的值没有改变，因为它是在拷贝时创建的 original_dict[‘age’] 的一个副本。然而，当我们修改了原字典中的一个列表（hobbies），拷贝后的字典中的相应列表也发生了变化，因为 copy() 方法创建的是浅拷贝，列表对象本身没有被复制，而是被共享了。

如果你想要创建一个深度拷贝（deep copy），可以使用 copy 模块的 deepcopy 函数：

import copy

# 创建一个深度拷贝
deep_copied_dict = copy.deepcopy(original_dict)

# 修改原字典的一个可变值
original_dict['hobbies'].append('swimming')

# 打印原字典和深度拷贝后的字典
print("Original Dictionary:", original_dict)
print("Deep Copied Dictionary:", deep_copied_dict)

输出将会是：

Original Dictionary: {'name': 'Alice', 'age': 31, 'hobbies': ['reading', 'traveling', 'cooking', 'swimming']}
Deep Copied Dictionary: {'name': 'Alice', 'age': 31, 'hobbies': ['reading', 'traveling', 'cooking']}

在这个例子中，deep_copied_dict 是 original_dict 的深度拷贝，所以对 original_dict 中列表的修改并不会影响到 deep_copied_dict 中的列表。

4.4 del

在Python中，del语句也可以用于删除字典中的键值对。与clear()方法不同，del语句允许你删除字典中的单个键值对或者删除整个字典。

下面是一些使用del语句删除字典元素的例子：
删除单个键值对

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 打印原始字典
print("原始字典:", my_dict)

# 使用del语句删除一个键值对
del my_dict['age']

# 打印删除后的字典
print("删除后的字典:", my_dict)

输出将会是：

原始字典: {'name': 'Alice', 'age': 30, 'city': 'New York'}
删除后的字典: {'name': 'Alice', 'city': 'New York'}

在这个例子中，del my_dict[‘age’]删除了键为’age’的键值对。
删除整个字典

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 打印原始字典
print("原始字典:", my_dict)

# 使用del语句删除整个字典
del my_dict

# 尝试打印字典，将会引发错误，因为my_dict不再存在
print("删除后的字典:", my_dict)  # 这将引发NameError

输出将会是：

原始字典: {'name': 'Alice', 'age': 30, 'city': 'New York'}

然后，尝试打印my_dict将会引发NameError，因为my_dict已经被del语句删除了。
使用pop()方法删除键值对

除了del语句，你还可以使用字典的pop()方法来删除键值对。pop()方法删除指定的键值对，并返回被删除的值。如果指定的键不存在，pop()会引发KeyError，除非你提供了第二个参数作为默认值。

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 打印原始字典
print("原始字典:", my_dict)

# 使用pop()方法删除一个键值对，并获取其值
removed_value = my_dict.pop('age')

# 打印删除后的字典和移除的值
print("删除后的字典:", my_dict)
print("移除的值:", removed_value)

输出将会是：

原始字典: {'name': 'Alice', 'age': 30, 'city': 'New York'}
删除后的字典: {'name': 'Alice', 'city': 'New York'}
移除的值: 30

在这个例子中，my_dict.pop(‘age’)删除了键为’age’的键值对，并返回了值30。如果你尝试删除一个不存在的键，你可以提供一个默认值来避免KeyError：

# 尝试删除一个不存在的键，并提供默认值
value_or_default = my_dict.pop('job', 'Unemployed')
print("值或默认值:", value_or_default)  # 输出: 值或默认值: Unemployed

在这个例子中，因为’job’键不存在于字典中，所以pop()方法返回了默认值’Unemployed’。

4.5 dict()

Python中，字典（dict）是一种无序的、可变的数据结构，用于存储键值对（key-value pairs）。字典中的每个键（key）都是唯一的，并且与一个值（value）相关联。键和值可以是任何不可变类型（如整数、浮点数、字符串、元组等），而值可以是任何类型（包括另一个字典）。

字典在Python中是通过大括号 {} 创建的，或者可以使用 dict() 函数来创建。字典中的键值对使用冒号 : 分隔，并且不同的键值对之间使用逗号 , 分隔。

以下是一些使用字典的基本示例：

# 创建一个空字典
empty_dict = {}

# 创建一个包含键值对的字典
person = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 使用dict()函数创建一个字典
another_dict = dict(name='Bob', age=25, city='San Francisco')

# 访问字典中的值
print(person['name'])       # 输出: Alice

# 修改字典中的值
person['age'] = 31

# 添加新的键值对
person['job'] = 'Engineer'

# 检查键是否在字典中
if 'city' in person:
    print("City is in the dictionary.")

# 删除键值对
del person['job']

# 遍历字典的键
for key in person:
    print(key)

# 遍历字典的值
for value in person.values():
    print(value)

# 遍历字典的键和值
for key, value in person.items():
    print(key, value)

# 获取字典的长度（即键值对的数量）
print(len(person))  # 输出: 2，因为person字典现在只包含'name'和'age'两个键值对

字典在Python编程中非常有用，因为它们提供了一种快速查找、插入和删除键值对的方法。字典的查找操作（即根据键获取值）的平均时间复杂度是O(1)，这意味着无论字典中有多少键值对，查找操作的速度都是几乎恒定的。这使得字典在需要快速查找的数据处理任务中非常高效。

4.6 fromkeys()

在Python中，dict.fromkeys()是一个类方法，用于创建一个新的字典，其中键是提供的可迭代对象中的元素，而值则是指定的默认值。这个方法在需要快速创建具有相同默认值的多个键时非常有用。

下面是dict.fromkeys()方法的语法：

dict.fromkeys(iterable, value=None)

• iterable：一个可迭代对象，如列表、元组或字符串，其中的元素将作为新字典的键。
• value：一个可选参数，指定所有键的默认值。如果省略此参数，则默认值将为None。

这里是一个使用dict.fromkeys()方法的例子：

# 创建一个包含相同默认值的字典
keys = ['a', 'b', 'c']
default_value = 0
new_dict = dict.fromkeys(keys, default_value)

print(new_dict)  # 输出: {'a': 0, 'b': 0, 'c': 0}

# 创建一个默认值为None的字典
new_dict_none = dict.fromkeys(['x', 'y', 'z'])

print(new_dict_none)  # 输出: {'x': None, 'y': None, 'z': None}

在这个例子中，我们首先使用dict.fromkeys()方法创建了一个新字典new_dict，其中键是列表keys中的元素，而所有键的值都是default_value（即0）。接着，我们又创建了一个新字典new_dict_none，其中键是列表[‘x’, ‘y’, ‘z’]中的元素，而所有键的值都是None（因为我们没有指定默认值）。

需要注意的是，dict.fromkeys()创建的字典中所有的键都共享同一个值对象。如果默认值是一个可变对象（如列表或字典），并且你在后续操作中修改了这个对象，那么所有使用该对象作为值的键都会受到影响。因此，在使用dict.fromkeys()时，如果你打算使用可变对象作为默认值，请确保你了解这种行为，并避免后续对默认值进行不必要的修改。

4.7 get()

在Python中，字典（dict）的get()方法用于获取与给定键（key）相关联的值（value）。如果键存在于字典中，get()方法将返回对应的值；如果键不存在，则get()方法将返回None，或者你可以指定一个默认值作为get()方法的第二个参数，当键不存在时返回这个默认值。

下面是get()方法的基本用法：

# 创建一个字典
my_dict = {
    'name': 'Alice',
    'age': 30,
    'city': 'New York'
}

# 使用get()方法获取字典中的值
value_name = my_dict.get('name')
value_job = my_dict.get('job')
value_job_default = my_dict.get('job', 'Unemployed')

# 打印获取的值
print("Name:", value_name)        # 输出: Name: Alice
print("Job:", value_job)          # 输出: Job: None
print("Job with default:", value_job_default)  # 输出: Job with default: Unemployed

在这个例子中，my_dict.get(‘name’)返回了与键’name’相关联的值’Alice’。因为字典中没有键’job’，所以my_dict.get(‘job’)返回了None。但是，当我们使用my_dict.get(‘job’, ‘Unemployed’)时，由于键’job’不存在，get()方法返回了我们指定的默认值’Unemployed’。

get()方法的语法如下：

dictionary.get(key, default_value)

• key：要查找的键。
• default_value（可选）：当键不存在时返回的默认值。如果省略此参数，并且键不存在，get()将返回None。

使用get()方法的好处是，当尝试获取不存在的键时，它不会引发KeyError异常，而是可以优雅地处理这种情况，返回None或指定的默认值。如果你希望在键不存在时引发异常，可以直接使用字典的键访问方式，如dictionary[key]，但这将在键不存在时抛出KeyError