在Python中，可以通过直接赋值、使用dict.update()方法、使用字典推导式等多种方式来添加键值。直接赋值是最常见和简单的方法，效率也很高。
直接赋值方式可以用来在字典中添加新的键值对或者更新已有的键值对。例如：
my_dict = {'a': 1, 'b': 2}
my_dict['c'] = 3 # 添加键值对 'c': 3
my_dict['a'] = 4 # 更新已有键值对 'a': 4
这种方式的优点是非常直观，且代码简洁易读。然而，如果需要一次性添加多个键值对，使用dict.update()方法会更为高效。
my_dict.update({'d': 4, 'e': 5}) # 添加多个键值对
接下来我们详细介绍这些方法，并举例说明它们的应用。
一、直接赋值
直接赋值是最简单的添加键值对的方法。它可以用来在字典中添加新的键值对或更新已有的键值对。
添加新的键值对
当字典中不存在某个键时，可以通过直接赋值的方式添加新的键值对：
my_dict = {'a': 1, 'b': 2}
my_dict['c'] = 3 # 添加键值对 'c': 3
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}
更新已有的键值对
如果字典中已经存在某个键，通过直接赋值的方式可以更新该键对应的值：
my_dict = {'a': 1, 'b': 2}
my_dict['a'] = 4 # 更新已有键值对 'a': 4
print(my_dict) # 输出: {'a': 4, 'b': 2}
二、使用dict.update()方法
dict.update()方法可以用来一次性添加或更新多个键值对。它的参数可以是另一个字典或一个包含键值对的可迭代对象。
使用字典作为参数
my_dict = {'a': 1, 'b': 2}
my_dict.update({'c': 3, 'd': 4}) # 添加多个键值对
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
使用可迭代对象作为参数
my_dict = {'a': 1, 'b': 2}
my_dict.update([('c', 3), ('d', 4)]) # 添加多个键值对
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
三、使用字典推导式
字典推导式可以用来创建一个新的字典，并在创建过程中添加键值对。它类似于列表推导式，但用于创建字典。
创建新的字典
my_dict = {x: x2 for x in range(5)} # 创建包含键值对 0:0, 1:1, 2:4, 3:9, 4:16 的字典
print(my_dict) # 输出: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
合并字典
可以使用字典推导式来合并两个字典：
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged_dict = {<strong>dict1, </strong>dict2} # 合并两个字典
print(merged_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
四、使用setdefault()方法
setdefault()方法在字典中不存在指定键时，会添加该键并设置其值为默认值；如果存在，则返回该键对应的值。
添加新的键值对
my_dict = {'a': 1, 'b': 2}
my_dict.setdefault('c', 3) # 当 'c' 不存在时，添加键值对 'c': 3
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}
获取已有键的值
my_dict = {'a': 1, 'b': 2}
value = my_dict.setdefault('a', 4) # 'a' 已存在，返回其值 1
print(value) # 输出: 1
print(my_dict) # 输出: {'a': 1, 'b': 2}
五、使用collections.defaultdict
defaultdict是collections模块中的一个类，它可以为字典中的每个键指定默认值类型。当访问不存在的键时，会自动创建该键并设置默认值。
使用defaultdict添加键值对
from collections import defaultdict
my_dict = defaultdict(int) # 默认值类型为 int，即默认值为 0
my_dict['a'] += 1 # 'a' 不存在，自动创建并设置默认值 0，然后执行 += 1
print(my_dict) # 输出: defaultdict(<class 'int'>, {'a': 1})
设置不同的默认值类型
from collections import defaultdict
my_dict = defaultdict(list) # 默认值类型为 list，即默认值为空列表
my_dict['a'].append(1) # 'a' 不存在，自动创建并设置默认值 []，然后执行 append(1)
print(my_dict) # 输出: defaultdict(<class 'list'>, {'a': [1]})
六、使用zip()函数
zip()函数可以将两个可迭代对象“压缩”成键值对，并直接用来创建字典。
使用zip()函数创建字典
keys = ['a', 'b', 'c']
values = [1, 2, 3]
my_dict = dict(zip(keys, values)) # 创建包含键值对 'a': 1, 'b': 2, 'c': 3 的字典
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}
七、使用字典的字面量创建
可以直接使用字典的字面量创建一个包含键值对的新字典，然后将其添加到已有字典中。
创建新的字典并添加键值对
my_dict = {'a': 1, 'b': 2}
new_entries = {'c': 3, 'd': 4}
my_dict.update(new_entries) # 添加多个键值对
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
八、通过for循环添加键值对
在某些情况下，通过for循环可以更加灵活地添加键值对，尤其是当需要进行复杂的条件判断或处理时。
使用for循环添加键值对
my_dict = {'a': 1, 'b': 2}
keys = ['c', 'd']
values = [3, 4]
for key, value in zip(keys, values):
my_dict[key] = value # 添加键值对
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
九、通过字典合并运算符
从Python 3.9开始，字典支持使用合并运算符|来合并多个字典。这种方式既可以添加新的键值对，也可以更新已有的键值对。
使用合并运算符添加键值对
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'd': 4}
merged_dict = dict1 | dict2 # 使用合并运算符合并字典
print(merged_dict) # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
十、使用pandas库添加键值对
对于处理大量数据的情况，可以使用pandas库中的DataFrame来处理键值对。pandas提供了强大的数据操作功能，非常适合处理复杂的数据结构。
使用pandas添加键值对
import pandas as pd
data = {'a': [1, 2], 'b': [3, 4]}
df = pd.DataFrame(data)
df['c'] = [5, 6] # 添加新的键值对列
print(df)
输出:
a b c
0 1 3 5
1 2 4 6
十一、通过嵌套字典添加键值对
在处理复杂数据结构时，可能需要使用嵌套字典。在嵌套字典中，可以通过多层次的键值对来组织数据。
添加嵌套字典的键值对
my_dict = {'a': {'x': 1}, 'b': {'y': 2}}
my_dict['a']['z'] = 3 # 在嵌套字典 'a' 中添加键值对 'z': 3
print(my_dict) # 输出: {'a': {'x': 1, 'z': 3}, 'b': {'y': 2}}
更新嵌套字典的键值对
my_dict = {'a': {'x': 1}, 'b': {'y': 2}}
my_dict['a']['x'] = 4 # 更新嵌套字典 'a' 中的键值对 'x': 4
print(my_dict) # 输出: {'a': {'x': 4}, 'b': {'y': 2}}
十二、使用json模块添加键值对
当处理JSON数据时，可以使用json模块将JSON字符串解析为字典，然后添加键值对。json模块非常适合处理嵌套数据结构。
使用json模块添加键值对
import json
json_str = '{"a": 1, "b": 2}'
my_dict = json.loads(json_str) # 将JSON字符串解析为字典
my_dict['c'] = 3 # 添加键值对 'c': 3
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}
十三、使用defaultdict的高级应用
defaultdict不仅可以用来设置默认值类型，还可以通过自定义函数来实现更复杂的默认值设置。
使用自定义函数设置默认值
from collections import defaultdict
def default_factory():
return {'count': 0, 'sum': 0}
my_dict = defaultdict(default_factory)
my_dict['a']['count'] += 1 # 'a' 不存在，自动创建并设置默认值 {'count': 0, 'sum': 0}，然后执行 += 1
print(my_dict) # 输出: defaultdict(<function default_factory at 0x...>, {'a': {'count': 1, 'sum': 0}})
十四、通过字典嵌套添加复杂结构
在一些应用场景中，可能需要通过字典嵌套来添加复杂的数据结构。例如，构建一个多层次的配置文件。
添加多层次字典结构
config = {
'database': {
'host': 'localhost',
'port': 3306,
},
'api': {
'endpoint': '/v1/resource',
'timeout': 30,
}
}
config['database']['user'] = 'admin' # 在嵌套字典 'database' 中添加键值对 'user': 'admin'
print(config)
输出:
{
'database': {'host': 'localhost', 'port': 3306, 'user': 'admin'},
'api': {'endpoint': '/v1/resource', 'timeout': 30}
}
十五、结合其他数据结构添加键值对
在某些情况下，可能需要结合其他数据结构（如列表、元组）来添加键值对。例如，处理多维数据时，可以使用列表或元组来组织数据。
使用列表和字典结合
data = [
{'id': 1, 'value': 10},
{'id': 2, 'value': 20},
]
data_dict = {item['id']: item['value'] for item in data} # 将列表转换为字典
print(data_dict) # 输出: {1: 10, 2: 20}
十六、通过函数动态添加键值对
在某些应用场景中，可能需要通过函数来动态添加键值对。可以编写一个函数，根据输入参数来生成键值对并添加到字典中。
编写函数添加键值对
def add_key_value(dictionary, key, value):
dictionary[key] = value
my_dict = {'a': 1, 'b': 2}
add_key_value(my_dict, 'c', 3) # 调用函数添加键值对 'c': 3
print(my_dict) # 输出: {'a': 1, 'b': 2, 'c': 3}
十七、通过递归添加嵌套键值对
在处理多层嵌套的字典时，可以使用递归函数来添加键值对。这种方法可以处理任意深度的嵌套结构。
编写递归函数添加嵌套键值对
def add_nested_key_value(dictionary, keys, value):
if len(keys) == 1:
dictionary[keys[0]] = value
else:
if keys[0] not in dictionary:
dictionary[keys[0]] = {}
add_nested_key_value(dictionary[keys[0]], keys[1:], value)
my_dict = {}
add_nested_key_value(my_dict, ['a', 'b', 'c'], 3) # 添加嵌套键值对 'a': {'b': {'c': 3}}
print(my_dict) # 输出: {'a': {'b': {'c': 3}}}
十八、通过类封装字典操作
在面向对象编程中，可以通过类来封装字典的操作。这样可以提高代码的可读性和可维护性。
封装字典操作的类
class DictionaryManager:
def __init__(self, initial_dict=None):
self.dictionary = initial_dict if initial_dict is not None else {}
def add_key_value(self, key, value):
self.dictionary[key] = value
def get_dictionary(self):
return self.dictionary
manager = DictionaryManager({'a': 1})
manager.add_key_value('b', 2) # 使用类方法添加键值对
print(manager.get_dictionary()) # 输出: {'a': 1, 'b': 2}
十九、结合数据库操作添加键值对
在处理持久化数据时，可以结合数据库操作来添加键值对。使用Python的数据库接口库（如sqlite3、SQLAlchemy）可以方便地操作数据库。
使用sqlite3添加键值对
import sqlite3
创建数据库连接
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()
创建表
cursor.execute('CREATE TABLE data (key TEXT, value INTEGER)')
添加键值对
cursor.execute('INSERT INTO data (key, value) VALUES (?, ?)', ('a', 1))
cursor.execute('INSERT INTO data (key, value) VALUES (?, ?)', ('b', 2))
查询数据并转换为字典
cursor.execute('SELECT * FROM data')
rows = cursor.fetchall()
data_dict = {row[0]: row[1] for row in rows}
print(data_dict) # 输出: {'a': 1, 'b': 2}
关闭数据库连接
conn.close()
二十、使用第三方库处理键值对
在某些情况下，使用第三方库（如pydantic、marshmallow）可以更方便地处理复杂的键值对结构。这些库提供了丰富的数据验证和序列化功能。
使用pydantic处理键值对
相关问答FAQs：
在Python中，如何向字典添加新的键值对？
在Python中，向字典添加新的键值对非常简单。你可以直接通过赋值的方式来添加。例如，如果你有一个字典 my_dict，想要添加一个键为'new_key'，值为'new_value'，可以使用如下代码：
my_dict['new_key'] = 'new_value'
这样就会在字典中创建一个新的键值对。
可以在字典中添加重复的键吗？
在Python字典中，键是唯一的。如果你尝试添加一个已存在的键，其值将会被更新。例如，若字典中已经有键'existing_key'，通过 my_dict['existing_key'] = 'new_value' 更新后，原有的值将被替换为'new_value'。
如何通过update()方法添加多个键值对？
如果你需要一次性添加多个键值对，可以使用update()方法。这个方法允许你将另一个字典或键值对的集合合并到现有字典中。示例代码如下：
my_dict.update({'key1': 'value1', 'key2': 'value2'})
这样，my_dict将包含'key1'和'key2'的新键值对。如果这些键已经存在，原有的值将被更新。
