Python 字典

Python 字典

字典的基本定义

Python 字典（Dictionary）是一个无序的、可变的数据结构，它用于存储键值对（key-value pairs）。在字典中，每个键都是唯一的，并且与一个值相关联。你可以通过键来访问、修改或删除与之关联的值。

以下是字典的一些基本特点：

• 无序性：字典中的元素（键值对）没有特定的顺序。这意味着每次遍历字典时，元素的顺序可能会有所不同。
• 可变性：字典是可变的，这意味着你可以在创建字典后添加、修改或删除键值对。
• 键的唯一性：字典中的键必须是唯一的，而值则不必。如果尝试使用已存在的键来添加新的键值对，该键对应的值将被新值替换。
• 键的不可变性：字典的键必须是不可变类型（如整数、浮点数、字符串、元组等），而值则可以是任何类型（包括列表、字典等可变类型）。

创建字典

使用花括号 {} 创建字典

创建空字典：

empty_dict = {}
print(empty_dict)  # 输出: {}

创建包含元素的字典：

my_dict = {
    "key1": "value1",
    "key2": "value2",
    "key3": 3,  # 值可以是任何类型，包括整数
    "key4": [1, 2, 3],  # 值甚至可以是列表或其他字典
    "key5": {"nested_key": "nested_value"}  # 嵌套字典
}
print(my_dict)
# 输出: {'key1': 'value1', 'key2': 'value2', 'key3': 3, 'key4': [1, 2, 3], 'key5': {'nested_key': 'nested_value'}}

使用 dict() 函数创建字典

创建空字典（这种方式和直接使用 {} 是等效的）：

empty_dict_using_function = dict()
print(empty_dict_using_function)  # 输出: {}

创建包含元素的字典：

# 使用关键字参数
another_dict = dict(key1="value1", key2="value2")
print(another_dict)  # 输出: {'key1': 'value1', 'key2': 'value2'}

# 使用包含键值对的列表（每个键值对都是包含两个元素的元组）
list_of_tuples = [("key3", 3), ("key4", [1, 2, 3])]
dict_from_list = dict(list_of_tuples)
print(dict_from_list)  # 输出: {'key3': 3, 'key4': [1, 2, 3]}

# 使用zip函数从两个列表创建字典（确保两个列表长度相同）
keys = ["key5", "key6"]
values = ["value5", "value6"]
dict_from_zip = dict(zip(keys, values))
print(dict_from_zip)  # 输出: {'key5': 'value5', 'key6': 'value6'}

访问字典元素

使用键来访问字典中的值

在Python中，你可以使用键来访问字典中的值。字典是一个键值对的集合，你可以通过键来获取对应的值。

示例：

# 创建一个字典
my_dict = {
    "apple": "red",
    "banana": "yellow",
    "grape": "purple"
}

# 使用键来访问字典中的值
print(my_dict["apple"])  # 输出: red

处理键不存在的情况

如果你尝试访问一个不存在的键，Python会抛出一个KeyError异常。为了避免这种情况，你可以使用get()方法或in关键字来检查键是否存在。

使用get()方法

get()方法允许你提供一个默认值，如果键不存在，则返回这个默认值。如果键存在，则返回该键对应的值。

# 使用get()方法并指定默认值
print(my_dict.get("orange", "Not found"))  # 输出: Not found

在这个例子中，"orange"这个键在字典中不存在，所以get()方法返回了我们指定的默认值"Not found"。

使用in关键字

你也可以使用in关键字来检查一个键是否存在于字典中。

# 使用in关键字检查键是否存在
if "apple" in my_dict:
    print(my_dict["apple"])  # 输出: red
else:
    print("Key not found.")

if "orange" not in my_dict:
    print("Key not found.")  # 输出: Key not found.

在这个例子中，我们首先检查"apple"这个键是否存在，如果存在，则打印出它的值。然后，我们检查"orange"这个键是否不存在，如果不存在，则打印出"Key not found."。

修改字典元素

在Python中，你可以通过直接指定键来修改字典中已存在的键对应的值。如果键不存在，则会添加一个新的键-值对到字典中。

示例：

# 创建一个字典
my_dict = {
    "apple": "red",
    "banana": "yellow"
}

# 修改已存在的键对应的值
my_dict["apple"] = "green"  # 将"apple"的值从"red"修改为"green"
print(my_dict)  # 输出: {'apple': 'green', 'banana': 'yellow'}

# 添加新的键-值对到字典中
my_dict["grape"] = "purple"
print(my_dict)  # 输出: {'apple': 'green', 'banana': 'yellow', 'grape': 'purple'}

在上面的示例中，我们首先创建了一个包含两个键-值对的字典my_dict。然后，我们使用已存在的键"apple"来修改其对应的值，将其从"red"修改为"green"。接着，我们使用一个不存在的键"grape"来添加一个新的键-值对到字典中。最后，我们打印出修改和添加后的字典内容。

删除字典元素

在Python中，你可以使用del关键字、pop()方法、popitem()方法或clear()方法来删除字典中的元素。

使用del关键字

del关键字可以用来删除字典中的特定键及其对应的值，或者删除整个字典。

# 创建一个字典
my_dict = {
    "apple": "red",
    "banana": "yellow",
    "grape": "purple"
}

# 使用del关键字删除特定键及其对应的值
del my_dict["banana"]
print(my_dict)  # 输出: {'apple': 'red', 'grape': 'purple'}

使用pop()方法

pop()方法用于删除并返回指定键的值。如果键不存在，可以提供一个默认值来防止KeyError异常。

# 使用pop()方法删除特定键并返回其值
removed_value = my_dict.pop("apple")
print(removed_value)  # 输出: red
print(my_dict)  # 输出: {'grape': 'purple'}

# 如果尝试删除不存在的键，pop()会抛出KeyError，除非提供一个默认值
my_dict.pop("orange", None)  # 不会抛出异常，返回None

使用popitem()方法

popitem()方法用于删除并返回字典中的任意键值对。在Python 3.7及以上版本，popitem()默认删除并返回最后一个插入的键值对（LIFO，后进先出）。在之前的版本中，它删除并返回一个随机的键值对。这个方法在处理空字典时会抛出KeyError。

# 使用popitem()方法删除并返回任意键值对
key, value = my_dict.popitem()
print(key, value)  # 输出可能是: grape purple（取决于字典内容）
print(my_dict)  # 如果上一步输出了grape purple，则此步输出: {}

使用clear()方法

clear()方法用于清空字典，移除所有键值对。

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

字典的常用操作

遍历字典的键、值或键-值对。
使用len()函数获取字典的长度（即键的数量）。
字典的复制（浅拷贝和深拷贝）。

遍历字典的键、值或键-值对

在Python中，你可以使用多种方式来遍历字典的键、值或键-值对。

遍历键（keys）

my_dict = {
    "apple": "red",
    "banana": "yellow",
    "grape": "purple"
}

# 遍历键
for key in my_dict.keys():
    print(key)
# 输出:
# apple
# banana
# grape

遍历值（values）

# 遍历值
for value in my_dict.values():
    print(value)
# 输出:
# red
# yellow
# purple

遍历键-值对（items）

# 遍历键-值对
for key, value in my_dict.items():
    print(key, value)
# 输出:
# apple red
# banana yellow
# grape purple

使用len()函数获取字典的长度

len()函数可以用来获取字典的长度，即字典中键的数量。

# 获取字典长度
print(len(my_dict))  # 输出: 3

字典的复制（浅拷贝和深拷贝）

在Python中，你可以使用多种方法来复制字典，但需要注意的是，这些复制方法可能产生浅拷贝（shallow copy）或深拷贝（deep copy）。

浅拷贝（Shallow Copy）

浅拷贝只复制字典顶层的数据结构，如果字典的值是可变类型（如列表、字典等），则这些值不会被复制，而是被引用。

使用字典的拷贝构造函数：

# 浅拷贝
shallow_copy = my_dict.copy()

使用切片操作（虽然这不是字典的标准做法，但它是列表的浅拷贝方法）：

# 注意：字典不支持切片操作，这是为了展示列表的浅拷贝
# shallow_copy = my_dict[:]  # 这会抛出TypeError

使用copy模块的copy()函数：

import copy
shallow_copy = copy.copy(my_dict)

深拷贝（Deep Copy）

深拷贝会递归地复制字典中的所有元素，包括嵌套的可变类型。

使用copy模块的deepcopy()函数：

deep_copy = copy.deepcopy(my_dict)

注意事项

注意：在大多数情况下，如果你只是需要复制字典的顶层结构，并且不关心嵌套的可变类型是否被复制，那么浅拷贝就足够了。但是，如果你需要确保嵌套的可变类型也被复制，那么你应该使用深拷贝。

字典的高级用法

字典推导式

字典推导式是一种简洁的创建字典的方法，它基于其他可迭代对象（如列表、元组或集合）的元素。

# 示例：创建一个字典，其中键是0到4的数字，值是它们的平方
squares = {i: i**2 for i in range(5)}
print(squares)  # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

嵌套字典

嵌套字典是指字典的值也是字典。

# 示例：创建一个表示学生分数的嵌套字典
students = {
    'Alice': {'math': 85, 'science': 92, 'english': 78},
    'Bob': {'math': 90, 'science': 88, 'english': 92},
    'Charlie': {'math': 80, 'science': 85, 'english': 88}
}

# 访问嵌套字典中的值
print(students['Alice']['math'])  # 输出: 85

字典的排序（根据键或值进行排序）

由于字典本身是无序的，但你可以使用sorted()函数对字典的键或值进行排序。

# 示例：根据键排序
my_dict = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
sorted_keys = sorted(my_dict.keys())
print(sorted_keys)  # 输出: ['apple', 'banana', 'orange', 'pear']

# 示例：根据值排序（默认升序）
sorted_items_by_value = sorted(my_dict.items(), key=lambda item: item[1])
print(sorted_items_by_value)  # 输出: [('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)]

# 示例：根据值降序排序
sorted_items_by_value_desc = sorted(my_dict.items(), key=lambda item: item[1], reverse=True)
print(sorted_items_by_value_desc)  # 输出: [('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)]

字典与函数参数的关联（使用字典作为函数的关键字参数）

你可以将字典作为函数的关键字参数传递，这样可以更加灵活地调用函数。

# 示例：定义一个函数，它接受关键字参数
def greet(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} says: {value}")

# 使用字典作为关键字参数调用函数
person_data = {'name': 'Alice', 'greeting': 'Hello!'}
greet(**person_data)
# 输出:
# name says: Alice
# greeting says: Hello!

在这个例子中，greet函数接受任意数量的关键字参数，并通过**kwargs语法捕获它们。然后，你可以使用另一个字典person_data作为关键字参数传递给greet函数，只需在调用函数时使用**前缀即可。