MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Python字典中添加键值对的操作详解

2023-07-091.1k 阅读

直接赋值添加键值对

在Python字典中，最为基础且直观的添加键值对的方式就是通过直接赋值。当我们使用一个字典对象，并以一个新的键作为索引，为其赋予相应的值时，Python会自动在该字典中创建一个新的键值对。

假设我们有一个空字典my_dict，现在要往里面添加一个键为'name'，值为'Alice'的键值对，代码如下：

my_dict = {}
my_dict['name'] = 'Alice'
print(my_dict)

在上述代码中，首先创建了一个空字典my_dict。然后通过my_dict['name'] = 'Alice'这样的语句，以'name'作为键，将'Alice'赋值给这个键，从而在字典中添加了一个新的键值对。最后打印字典，输出结果为{'name': 'Alice'}。

这种方式简洁明了，适用于大多数简单的添加键值对的场景。无论是字符串类型的键，还是数字、元组等不可变类型作为键（Python字典要求键必须是可哈希的，通常不可变类型都是可哈希的），都可以使用这种方式进行添加。

例如，以数字作为键添加键值对：

num_dict = {}
num_dict[1] = 'one'
print(num_dict)

上述代码以数字1作为键，添加了值为'one'的键值对，输出结果为{1: 'one'}。

再比如，以元组作为键添加键值对：

tuple_dict = {}
key_tuple = (1, 2)
tuple_dict[key_tuple] = 'value for (1, 2)'
print(tuple_dict)

这里使用元组(1, 2)作为键，添加了相应的值，输出结果为{(1, 2): 'value for (1, 2)'}。

使用update()方法添加键值对

update()方法是Python字典提供的一个非常实用的方法，它不仅可以用来更新字典中已有的键值对，还能用于添加新的键值对。update()方法接受一个字典或者一个可迭代对象（其中的元素是键值对形式）作为参数。

当传入一个字典作为参数时，update()方法会将该字典中的所有键值对添加到调用它的字典中。如果存在相同的键，那么原字典中对应键的值会被新传入字典中该键的值所覆盖。

例如，有两个字典dict1和dict2，代码如下：

dict1 = {'a': 1}
dict2 = {'b': 2}
dict1.update(dict2)
print(dict1)

在上述代码中，dict1初始有一个键值对'a': 1，dict2有一个键值对'b': 2。通过dict1.update(dict2)，dict2中的键值对被添加到了dict1中，输出结果为{'a': 1, 'b': 2}。

如果dict2中存在与dict1相同的键，比如：

dict1 = {'a': 1}
dict2 = {'a': 2, 'b': 2}
dict1.update(dict2)
print(dict1)

此时dict1中的'a': 1会被更新为'a': 2，输出结果为{'a': 2, 'b': 2}。

update()方法还可以接受一个可迭代对象作为参数，这个可迭代对象中的元素必须是键值对形式，通常可以是一个由元组组成的列表，每个元组包含两个元素，第一个元素为键，第二个元素为值。

例如：

my_dict = {}
key_value_list = [('name', 'Bob'), ('age', 30)]
my_dict.update(key_value_list)
print(my_dict)

在这段代码中，定义了一个包含两个元组的列表key_value_list，每个元组都是一个键值对。通过my_dict.update(key_value_list)，将这些键值对添加到了my_dict中，输出结果为{'name': 'Bob', 'age': 30}。

这种方式在需要批量添加键值对时非常方便，特别是当键值对数据存储在一个列表等可迭代对象中时。

setdefault()方法添加键值对

setdefault()方法为在字典中添加键值对提供了一种略有不同的方式。它的主要作用是获取指定键的值，如果该键不存在，则会在字典中添加这个键，并为其设置一个默认值。

setdefault()方法接受两个参数，第一个参数是要查找或添加的键，第二个参数是如果键不存在时要设置的默认值（第二个参数是可选的，如果不提供，默认值为None）。

例如，有一个字典student_dict，我们想获取'score'键的值，如果不存在则添加该键并设置默认值为0，代码如下：

student_dict = {'name': 'Tom'}
score = student_dict.setdefault('score', 0)
print(student_dict)
print(score)

在上述代码中，student_dict初始只有'name': 'Tom'这个键值对。通过student_dict.setdefault('score', 0)，因为'score'键不存在，所以会在字典中添加'score': 0这个键值对，并且返回值score为0。最终输出字典student_dict为{'name': 'Tom','score': 0}，输出score为0。

如果键已经存在，setdefault()方法不会改变字典中该键对应的值，而是直接返回该键对应的值。

例如：

student_dict = {'name': 'Tom','score': 85}
score = student_dict.setdefault('score', 0)
print(student_dict)
print(score)

这里student_dict中已经存在'score'键，所以setdefault()方法不会改变'score'的值，而是直接返回85。输出字典student_dict仍然为{'name': 'Tom','score': 85}，输出score为85。

setdefault()方法在处理一些需要根据键的存在情况进行不同操作的场景时非常有用，比如统计某个元素出现的次数。

例如，统计列表中每个单词出现的次数：

word_list = ['apple', 'banana', 'apple', 'cherry']
word_count_dict = {}
for word in word_list:
    word_count_dict.setdefault(word, 0)
    word_count_dict[word] += 1
print(word_count_dict)

在上述代码中，通过word_count_dict.setdefault(word, 0)确保每个单词作为键在字典中存在且初始值为0，然后再对其值进行递增操作，最终得到每个单词出现的次数，输出结果为{'apple': 2, 'banana': 1, 'cherry': 1}。

字典推导式添加键值对

字典推导式是Python中一种非常强大且简洁的创建字典的方式，它也可以用于在已有字典的基础上添加键值对。字典推导式的基本语法形式为{key_expression: value_expression for item in iterable}，其中key_expression是生成键的表达式，value_expression是生成值的表达式，iterable是一个可迭代对象。

假设我们有一个列表numbers = [1, 2, 3]，现在要创建一个新字典，键为列表中的数字，值为该数字的平方，同时可以将这个新字典与原有的字典合并，实现添加键值对的效果。

例如：

original_dict = {'a': 'apple'}
numbers = [1, 2, 3]
new_dict = {num: num ** 2 for num in numbers}
original_dict.update(new_dict)
print(original_dict)

在上述代码中，首先定义了original_dict和numbers列表。然后通过字典推导式{num: num ** 2 for num in numbers}创建了一个新字典new_dict，其中键为numbers列表中的数字，值为该数字的平方。最后通过original_dict.update(new_dict)将new_dict中的键值对添加到original_dict中，输出结果为{'a': 'apple', 1: 1, 2: 4, 3: 9}。

字典推导式还可以结合条件语句，实现更复杂的键值对生成逻辑。例如，只生成偶数的平方作为键值对添加到字典中：

original_dict = {'a': 'apple'}
numbers = [1, 2, 3, 4]
new_dict = {num: num ** 2 for num in numbers if num % 2 == 0}
original_dict.update(new_dict)
print(original_dict)

这里通过if num % 2 == 0条件语句，只有偶数会参与字典推导式生成键值对，最终输出结果为{'a': 'apple', 2: 4, 4: 16}。

从其他数据结构转换为字典添加键值对

在实际编程中，我们常常会遇到需要将其他数据结构转换为字典，并添加到已有字典中的情况。常见的数据结构如列表、元组等，都可以通过一定的方式转换为字典形式的键值对进行添加。

列表转换为字典添加键值对

如果列表中的元素是成对出现的，我们可以将其转换为字典形式添加到已有字典中。例如，有一个列表key_value_list = [('name', 'Charlie'), ('city', 'New York')]，可以通过以下方式添加到已有字典中：

original_dict = {'country': 'USA'}
key_value_list = [('name', 'Charlie'), ('city', 'New York')]
new_dict = dict(key_value_list)
original_dict.update(new_dict)
print(original_dict)

在上述代码中，首先使用dict(key_value_list)将列表转换为字典new_dict，然后通过original_dict.update(new_dict)将新字典中的键值对添加到original_dict中，输出结果为{'country': 'USA', 'name': 'Charlie', 'city': 'New York'}。

如果列表的结构更为复杂，比如列表中嵌套列表，每个子列表包含两个元素分别作为键和值，也可以通过循环和字典的操作来实现添加。

例如：

original_dict = {'country': 'USA'}
nested_list = [['name', 'David'], ['age', 25]]
for sub_list in nested_list:
    key = sub_list[0]
    value = sub_list[1]
    original_dict[key] = value
print(original_dict)

这里通过循环遍历nested_list中的每个子列表，分别获取键和值，然后通过直接赋值的方式添加到original_dict中，输出结果为{'country': 'USA', 'name': 'David', 'age': 25}。

元组转换为字典添加键值对

元组与列表类似，如果元组的结构合适，也可以转换为字典添加到已有字典中。例如，有一个元组key_value_tuple = (('name', 'Ella'), ('city', 'Los Angeles'))：

original_dict = {'country': 'USA'}
key_value_tuple = (('name', 'Ella'), ('city', 'Los Angeles'))
new_dict = dict(key_value_tuple)
original_dict.update(new_dict)
print(original_dict)

同样，先使用dict(key_value_tuple)将元组转换为字典new_dict，再通过update()方法添加到original_dict中，输出结果为{'country': 'USA', 'name': 'Ella', 'city': 'Los Angeles'}。

如果是单个元组，且元组中的元素可以配对作为键值对，比如single_tuple = ('name', 'Frank', 'city', 'Chicago')，可以通过切片和字典操作来实现添加：

original_dict = {'country': 'USA'}
single_tuple = ('name', 'Frank', 'city', 'Chicago')
new_dict = {single_tuple[i]: single_tuple[i + 1] for i in range(0, len(single_tuple), 2)}
original_dict.update(new_dict)
print(original_dict)

在这段代码中，通过字典推导式和切片操作，将single_tuple中的元素按顺序两两配对作为键值对生成新字典new_dict，再添加到original_dict中，输出结果为{'country': 'USA', 'name': 'Frank', 'city': 'Chicago'}。

处理键冲突的情况

在向字典中添加键值对时，不可避免地会遇到键冲突的问题，即要添加的键已经存在于字典中。不同的添加键值对的方式在处理键冲突时表现有所不同。

直接赋值与键冲突

当使用直接赋值方式添加键值对时，如果键已经存在，那么该键对应的值会被新值直接覆盖。

例如：

my_dict = {'name': 'Alice'}
my_dict['name'] = 'Bob'
print(my_dict)

这里my_dict初始有'name': 'Alice'，通过my_dict['name'] = 'Bob'，由于'name'键已存在，所以'Alice'被'Bob'覆盖，输出结果为{'name': 'Bob'}。

update()方法与键冲突

update()方法在处理键冲突时，同样会用新传入字典（或可迭代对象中的键值对）中的值覆盖原字典中相同键的值。

例如：

dict1 = {'a': 1}
dict2 = {'a': 2}
dict1.update(dict2)
print(dict1)

dict1初始有'a': 1，dict2中有'a': 2，通过update()方法，dict1中'a'的值被更新为2，输出结果为{'a': 2}。

setdefault()方法与键冲突

setdefault()方法在遇到键冲突时，不会改变字典中该键对应的值，而是直接返回该键对应的值。

例如：

student_dict = {'score': 85}
score = student_dict.setdefault('score', 0)
print(student_dict)
print(score)

student_dict中已经存在'score'键，setdefault()方法不会改变其值，而是返回85，输出字典student_dict仍为{'score': 85}，输出score为85。

在实际编程中，我们需要根据具体的需求来选择合适的添加键值对的方式，以正确处理键冲突的情况。如果希望在键存在时更新值，直接赋值或update()方法是合适的选择；如果希望在键存在时保持原有值不变，setdefault()方法更为适用。

性能考量

在选择不同的方式向字典中添加键值对时，性能也是一个需要考虑的因素。不同的添加方式在时间复杂度和空间复杂度上可能会有所差异。

直接赋值的性能

直接赋值方式添加键值对的时间复杂度在平均情况下为O(1)。这是因为字典在内部使用哈希表来存储键值对，通过键的哈希值可以快速定位到对应的存储位置进行赋值操作。当字典中元素数量较少时，这种方式的性能非常高效。

例如，在一个空字典中多次使用直接赋值添加键值对：

import time

start_time = time.time()
my_dict = {}
for i in range(10000):
    my_dict[i] = i * 2
end_time = time.time()
print(f"直接赋值添加10000个键值对耗时: {end_time - start_time} 秒")

上述代码通过time模块测量了使用直接赋值方式向空字典中添加10000个键值对的耗时。在大多数情况下，这个时间是非常短的，体现了其高效性。

update()方法的性能

update()方法的时间复杂度取决于传入的参数。如果传入一个字典，其时间复杂度为O(k)，其中k是传入字典中的键值对数量。因为它需要遍历传入字典的所有键值对并添加到目标字典中。

例如：

import time

start_time = time.time()
dict1 = {}
dict2 = {i: i * 2 for i in range(10000)}
dict1.update(dict2)
end_time = time.time()
print(f"使用update()方法添加10000个键值对耗时: {end_time - start_time} 秒")

上述代码测量了使用update()方法从另一个包含10000个键值对的字典中添加键值对的耗时。由于update()方法需要遍历dict2中的所有键值对，所以耗时会随着dict2中键值对数量的增加而增加。

如果update()方法传入的是一个可迭代对象（如列表），其时间复杂度也是O(n)，其中n是可迭代对象中的元素数量。因为它同样需要遍历可迭代对象中的每个元素并添加到字典中。

setdefault()方法的性能

setdefault()方法的平均时间复杂度也是O(1)，与直接赋值类似。因为它也是基于字典的哈希表结构进行操作，在查找键是否存在以及添加新键值对时，平均情况下能够快速定位到相应位置。

例如：

import time

start_time = time.time()
my_dict = {}
for i in range(10000):
    my_dict.setdefault(i, i * 2)
end_time = time.time()
print(f"使用setdefault()方法添加10000个键值对耗时: {end_time - start_time} 秒")

上述代码测量了使用setdefault()方法向空字典中添加10000个键值对的耗时，在平均情况下，其性能与直接赋值接近。

字典推导式的性能

字典推导式本身创建字典的时间复杂度取决于推导式中的可迭代对象的大小。例如，对于{num: num ** 2 for num in range(n)}这样的字典推导式，其时间复杂度为O(n)，因为它需要遍历range(n)中的每个元素。

当使用字典推导式创建新字典并通过update()方法添加到已有字典中时，整体的时间复杂度是字典推导式创建字典的时间复杂度加上update()方法添加键值对的时间复杂度。

例如：

import time

start_time = time.time()
original_dict = {}
new_dict = {num: num ** 2 for num in range(10000)}
original_dict.update(new_dict)
end_time = time.time()
print(f"使用字典推导式结合update()方法添加10000个键值对耗时: {end_time - start_time} 秒")

上述代码测量了先使用字典推导式创建字典，再通过update()方法添加到已有字典中的总耗时。由于字典推导式和update()方法的时间复杂度都与元素数量相关，所以总耗时会随着元素数量的增加而增加。

在实际应用中，如果对性能要求较高，并且添加的键值对数量较少，直接赋值和setdefault()方法通常是较好的选择；如果需要批量添加大量键值对，且性能较为关键，需要根据具体的数据结构和操作场景进行更细致的性能测试和选择。

在类中操作字典添加键值对

在Python面向对象编程中，经常会在类的内部使用字典，并需要对其进行添加键值对的操作。这涉及到对类属性和实例属性的理解与运用。

类属性字典添加键值对

类属性是属于类本身的属性，所有类的实例都共享这些属性。当类属性是一个字典时，在类的方法中添加键值对会影响到所有实例。

例如：

class MyClass:
    class_dict = {}

    @classmethod
    def add_to_class_dict(cls, key, value):
        cls.class_dict[key] = value


obj1 = MyClass()
obj2 = MyClass()

obj1.add_to_class_dict('name', 'Alice')
print(obj1.class_dict)
print(obj2.class_dict)

在上述代码中，MyClass类有一个类属性class_dict，是一个字典。通过add_to_class_dict类方法可以向这个字典中添加键值对。由于class_dict是类属性，obj1调用add_to_class_dict方法添加键值对后，obj2访问class_dict时也能看到这个新添加的键值对。输出结果为{'name': 'Alice'}，两个实例的class_dict都相同。

实例属性字典添加键值对

实例属性是每个实例独有的属性。当实例属性是一个字典时，在实例方法中添加键值对只会影响当前实例的字典。

例如：

class MyClass:
    def __init__(self):
        self.instance_dict = {}

    def add_to_instance_dict(self, key, value):
        self.instance_dict[key] = value


obj1 = MyClass()
obj2 = MyClass()

obj1.add_to_instance_dict('name', 'Alice')
print(obj1.instance_dict)
print(obj2.instance_dict)

这里MyClass类在__init__方法中为每个实例创建了一个实例属性instance_dict。obj1调用add_to_instance_dict方法添加键值对，不会影响到obj2的instance_dict。输出结果为obj1.instance_dict为{'name': 'Alice'}，而obj2.instance_dict为空{}。

在类中操作字典添加键值对时，需要明确是操作类属性字典还是实例属性字典，以确保程序的行为符合预期。

多线程环境下字典添加键值对

在多线程编程中，同时对字典进行添加键值对的操作可能会引发一些问题，因为字典本身不是线程安全的。如果多个线程同时尝试向字典中添加键值对，可能会导致数据竞争和不一致的结果。

例如：

import threading

my_dict = {}


def add_to_dict(key, value):
    my_dict[key] = value


threads = []
for i in range(10):
    thread = threading.Thread(target=add_to_dict, args=(i, i * 2))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print(my_dict)

在上述代码中，创建了10个线程，每个线程都尝试向my_dict中添加一个键值对。在实际运行中，由于多个线程同时操作my_dict，可能会出现数据竞争问题，导致最终的my_dict中的键值对数量不准确或者出现其他异常情况。

为了解决多线程环境下字典添加键值对的线程安全问题，可以使用锁机制。Python的threading模块提供了Lock类来实现锁的功能。

例如：

import threading

my_dict = {}
lock = threading.Lock()


def add_to_dict(key, value):
    with lock:
        my_dict[key] = value


threads = []
for i in range(10):
    thread = threading.Thread(target=add_to_dict, args=(i, i * 2))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print(my_dict)

在这段代码中，定义了一个Lock对象lock。在add_to_dict函数中，使用with lock语句，确保在任何时刻只有一个线程能够进入临界区（即向字典添加键值对的代码块），从而避免了数据竞争问题，保证了多线程环境下字典添加键值对的安全性。

除了锁机制，Python还提供了一些线程安全的数据结构，如collections.deque等，但原生字典在多线程环境下仍需要通过锁等方式来保证操作的安全性。

总结不同添加方式的适用场景

  1. 直接赋值：适用于简单的、单个键值对的添加场景，代码简洁明了。当明确知道要添加的键值对且不需要考虑键是否存在的复杂逻辑时，直接赋值是首选。例如，在初始化一个配置字典时，逐个添加简单的配置项。

  2. update()方法：当需要批量添加键值对时非常方便，尤其是从另一个字典或可迭代对象中获取键值对进行添加。如果存在相同键需要更新值，update()方法也能很好地满足需求。比如，从数据库查询结果（以字典形式返回）中批量更新到内存中的配置字典。

  3. setdefault()方法：在需要根据键的存在情况进行不同操作时特别有用，尤其是在统计计数等场景。当希望在键不存在时添加默认值，同时又不改变已存在键的值时，setdefault()方法是最佳选择。例如，统计文本中每个单词出现的次数。

  4. 字典推导式：适用于根据已有数据结构通过一定的逻辑生成新的字典，并可结合update()方法添加到已有字典中。当需要对数据进行转换并添加到字典时，字典推导式可以使代码简洁高效。比如，从一个列表中生成键值对，其中键是列表元素，值是元素的某种计算结果。

  5. 从其他数据结构转换添加：在数据处理过程中，当数据最初以列表、元组等其他数据结构存在，且需要转换为字典形式添加到已有字典时适用。这种方式可以充分利用已有的数据结构，避免重复的数据构建过程。例如，从文件读取的数据以列表形式存储，需要转换为字典添加到配置字典中。

  6. 在类中操作：如果希望所有实例共享字典数据，使用类属性字典并通过类方法添加键值对；如果每个实例需要独立的字典数据，则在实例方法中对实例属性字典进行添加操作。例如，在一个游戏类中，类属性字典可以存储全局游戏配置，而实例属性字典可以存储每个玩家的个性化设置。

  7. 多线程环境：在多线程环境下，由于字典本身不是线程安全的，需要使用锁机制来保证多个线程同时添加键值对的安全性。当多个线程需要并发操作字典时，必须考虑线程安全问题，确保数据的一致性和正确性。例如，在一个多线程的网络服务器中，多个线程可能需要同时更新一个存储客户端信息的字典。

通过深入理解不同添加键值对方式的特点和适用场景，我们能够在实际编程中更加灵活、高效地使用Python字典，编写出健壮、高性能的代码。