Python字典中的常用方法

dict() 构造函数

用于创建一个新的字典。

 
# 从键值对创建字典
my_dict = dict(a=1, b=2, c=3)
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}
 
# 从键值对列表创建字典
my_dict = dict([('a', 1), ('b', 2), ('c', 3)])
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

len()

获取字典中键值对的数量。

 
my_dict = {'a': 1, 'b': 2, 'c': 3}
print(len(my_dict))  # 输出: 3

keys()

返回字典中所有键的视图。

 
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys = my_dict.keys()
print(keys)  # 输出: dict_keys(['a', 'b', 'c'])

values()

返回字典中所有值的视图。

 
my_dict = {'a': 1, 'b': 2, 'c': 3}
values = my_dict.values()
print(values)  # 输出: dict_values([1, 2, 3])

items()

返回字典中所有键值对的视图。

 
my_dict = {'a': 1, 'b': 2, 'c': 3}
items = my_dict.items()
print(items)  # 输出: dict_items([('a', 1), ('b', 2), ('c', 3)])

get()

获取指定键的值，如果键不存在，返回默认值。

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(my_dict.get('a'))  # 输出: 1
print(my_dict.get('d', 'Not Found'))  # 输出: Not Found

update()

更新字典，可以添加新的键值对或修改已有键的值。

my_dict = {'a': 1, 'b': 2}
my_dict.update({'b': 3, 'c': 4})
print(my_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

pop()

移除字典中指定键的键值对，并返回对应的值。

my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.pop('b')
print(value)  # 输出: 2
print(my_dict)  # 输出: {'a': 1, 'c': 3}

popitem()

移除并返回字典中最后一个插入的键值对（在 Python 3.7+ 中是插入顺序）。

my_dict = {'a': 1, 'b': 2, 'c': 3}
key, value = my_dict.popitem()
print(key, value)  # 输出: c 3
print(my_dict)  # 输出: {'a': 1, 'b': 2}

clear()

清空字典。

 
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.clear()
print(my_dict)  # 输出: {}

setdefault()

如果键不存在，则插入键值对，并返回默认值；如果键存在，则返回对应的值。

my_dict = {'a': 1, 'b': 2}
print(my_dict.setdefault('c', 3))  # 输出: 3
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}
print(my_dict.setdefault('a', 10))  # 输出: 1
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

copy()

创建字典的浅拷贝。

my_dict = {'a': 1, 'b': 2}
new_dict = my_dict.copy()
print(new_dict)  # 输出: {'a': 1, 'b': 2}

fromkeys()

用于创建一个新字典，其中键来自一个可迭代对象，所有键的值默认为 None 或指定的默认值。

keys = ['a', 'b', 'c']
new_dict = dict.fromkeys(keys)
print(new_dict)  # 输出: {'a': None, 'b': None, 'c': None}
 
new_dict = dict.fromkeys(keys, 10)
print(new_dict)  # 输出: {'a': 10, 'b': 10, 'c': 10}

in 和 not in

用于检查键是否存在于字典中。

my_dict = {'a': 1, 'b': 2, 'c': 3}
print('a' in my_dict)  # 输出: True
print('d' not in my_dict)  # 输出: True

del

用于删除字典中的键值对。

my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['b']
print(my_dict)  # 输出: {'a': 1, 'c': 3}

dict 的推导式

可以使用字典推导式快速生成字典。

# 从列表生成字典
keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = {key: value for key, value in zip(keys, values)}
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}
 
# 对键值进行操作
my_dict = {key: value ** 2 for key, value in zip(keys, values)}
print(my_dict)  # 输出: {'a': 1, 'b': 4, 'c': 9}

str()

将字典转换为字符串形式，通常用于打印或调试。

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(str(my_dict))  # 输出: "{'a': 1, 'b': 2, 'c': 3}"

repr()

返回字典的官方字符串表示，通常用于调试。

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(repr(my_dict))  # 输出: "{'a': 1, 'b': 2, 'c': 3}"

sorted()

对字典的键或值进行排序。

my_dict = {'a': 3, 'b': 1, 'c': 2}
 
# 按键排序
sorted_keys = sorted(my_dict)
print(sorted_keys)  # 输出: ['a', 'b', 'c']
 
# 按值排序
sorted_by_value = sorted(my_dict.items(), key=lambda item: item[1])
print(sorted_by_value)  # 输出: [('b', 1), ('c', 2), ('a', 3)]

all() 和 any()

用于检查字典中的键或值是否满足某些条件。

 
my_dict = {'a': True, 'b': False, 'c': True}
 
# 检查所有值是否为 True
print(all(my_dict.values()))  # 输出: False
 
# 检查是否有任意一个值为 True
print(any(my_dict.values()))  # 输出: True

dict 的嵌套

字典可以嵌套使用，例如创建一个包含字典的字典。

 
nested_dict = {
    'a': {'x': 1, 'y': 2},
    'b': {'x': 3, 'y': 4}
}
 
print(nested_dict['a']['x'])  # 输出: 1

json 模块

字典可以很容易地与 JSON 数据进行转换，json 模块提供了 dumps() 和 loads() 方法。

 
import json
 
# 将字典转换为 JSON 字符串
my_dict = {'a': 1, 'b': 2, 'c': 3}
json_str = json.dumps(my_dict)
print(json_str)  # 输出: '{"a": 1, "b": 2, "c": 3}'
 
# 将 JSON 字符串转换为字典
new_dict = json.loads(json_str)
print(new_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

zip() 函数

zip() 函数可以将两个或多个可迭代对象的元素配对，常用于创建字典。

 
keys = ['a', 'b', 'c']
values = [1, 2, 3]
 
# 使用 zip 创建字典
my_dict = dict(zip(keys, values))
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

enumerate() 函数

enumerate() 函数可以将可迭代对象的元素与索引一起返回，也可以用于创建字典。

items = ['a', 'b', 'c']
 
# 使用 enumerate 创建字典
my_dict = {index: value for index, value in enumerate(items)}
print(my_dict)  # 输出: {0: 'a', 1: 'b', 2: 'c'}

dict 的解包

Python 3.5+ 支持使用 ** 解包字典，可以方便地合并多个字典。

 
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
 
# 合并字典
merged_dict = {**dict1, **dict2}
print(merged_dict)  # 输出: {'a': 1, 'b': 3, 'c': 4}

hash() 函数

字典的键必须是可哈希的（不可变）对象。hash() 函数可以获取对象的哈希值。

Python 的字典（dict）是一种基于哈希表的数据结构。哈希表的核心思想是通过哈希函数将键（Key）映射到一个固定范围的整数（通常是内存中的位置），从而实现快速查找、插入和删除操作。为了实现这一点，键必须满足以下条件：

可哈希（Hashable）：键必须有一个固定的哈希值，即它的哈希值在它的生命周期内不能改变。这意味着键必须是不可变的（Immutable）。
唯一性：不同的键应该有不同的哈希值（虽然理论上可能存在哈希冲突，但概率极低）。

可哈希对象：不可变对象通常是可哈希的，例如：

整数（int）：hash(123) 是固定的。
浮点数（float）：hash(123.45) 是固定的。
字符串（str）：hash("hello") 是固定的。
元组（tuple）：如果元组中的所有元素都是可哈希的，那么元组也是可哈希的。例如，hash((1, 2, 3)) 是固定的。

不可哈希对象：可变对象通常是不可哈希的，例如：

列表（list）：hash([1, 2, 3]) 会报错，因为列表是可变的。
字典（dict）：hash({'a': 1}) 会报错，因为字典是可变的。
集合（set）：hash({1, 2, 3}) 会报错，因为集合是可变的。

虽然哈希函数会尽量将不同的输入映射到不同的哈希值，但理论上仍然可能存在哈希冲突（即不同的输入有相同的哈希值）。

Python 的字典内部会处理这种情况，例如通过链表或开放寻址法来解决冲突，但这种情况的概率非常低，且对用户透明。

 
print(hash('a'))  # 输出: 一个整数
print(hash(1))    # 输出: 一个整数
# print(hash([1, 2]))  # 会报错，因为列表是不可哈希的

type() 函数

可以用来检查对象的类型是否为字典。

 
my_dict = {'a': 1, 'b': 2}
print(type(my_dict) == dict)  # 输出: True

isinstance() 函数

更安全地检查对象是否是字典类型。

 
my_dict = {'a': 1, 'b': 2}
print(isinstance(my_dict, dict))  # 输出: True

reversed() 函数

在 Python 3.8+ 中，reversed() 可以用于字典，返回键的逆序迭代器。

 
my_dict = {'a': 1, 'b': 2, 'c': 3}
for key in reversed(my_dict):
    print(key)  # 输出: c, b, a