本文深入探讨在python中构建嵌套字典时，循环内更新字典值可能导致的引用问题。通过分析共享引用而非独立副本的机制，文章提供了两种有效的解决方案：使用 `dict.copy()` 创建副本，或在每次迭代时重新初始化内部字典，确保每个外部键对应一个独立的内部字典实例，从而避免数据覆盖，实现预期的数据结构。
在Python中处理复杂数据结构，特别是嵌套字典时，一个常见的陷阱是对象引用。当我们将一个可变对象（如字典或列表）赋值给另一个变量时，实际上是创建了一个对该对象的引用，而不是一个新的独立副本。这意味着，如果多个变量引用同一个对象，并通过任何一个引用修改该对象，所有引用都将反映这些修改。
在构建类似 {'key1': {'inner_key1': 'value1'}, 'key2': {'inner_key2': 'value2'}} 这样的嵌套字典时，如果内部字典 new_dict 在循环外部初始化，并在每次迭代中被修改后，又被赋值给外部字典 newest_dict 的不同键，那么 newest_dict 中的所有值最终将指向同一个 new_dict 对象。结果是，所有外部键都将拥有 new_dict 在最后一次迭代时的状态。
考虑以下场景，我们有一个初始字典 initial_dict，其值是带有占位符的内部字典。我们的目标是根据外部键 k 从外部数据源（例如Excel文件）中读取对应的数据，填充这些占位符，并构建一个新的 newest_dict。
import datetime
# 模拟初始字典结构
initial_dict = {
'LG_G7_Blue_64GB_R07': {'Name': 'A', 'Code': 'B', 'Sale Effective Date': 'C', 'Sale Expiration Date': 'D'},
'Asus_ROG_Phone_Nero_128GB_R07': {'Name': 'A', 'Code': 'B', 'Sale Effective Date': 'C', 'Sale Expiration Date': 'D'}
}
# 模拟一个工作表 'ws' 来模拟 openpyxl 数据检索
class MockWorksheet:
def __init__(self):
self.data = {
'A2': 'LG G7 Blue 64GB', 'B2': 'LG_G7_Blue_64GB_R07',
'C2': datetime.datetime(2005, 9, 25, 0, 0), 'D2': datetime.datetime(2022, 10, 27, 23, 59, 59),
'A3': 'Asus ROG Phone Nero 128GB', 'B3': 'Asus_ROG_Phone_Nero_128GB_R07',
'C3': datetime.datetime(2005, 9, 25, 0, 0), 'D3': datetime.datetime(2022, 10, 27, 23, 59, 59)
}
def __getitem__(self, key):
class Cell:
def __init__(self, value):
self.value = value
def __repr__(self):
return f"Cell(value={self.value})"
return Cell(self.data.get(key, None))
ws = MockWorksheet()
new_dict = {}
newest_dict = {}
row = 2
for k, v in initial_dict.items():
for i, j in v.items():
# 假设 j 是 Excel 列名，row 是行号
j_value = ws[j + str(row)].value
new_dict[i] = j_value
print(f"当前外部键: {k}")
print(f"当前new_dict状态: {new_dict}")
print("------")
# 问题所在：这里是将 new_dict 的引用赋值给 newest_dict[k]
newest_dict[k] = new_dict
print(f"当前newest_dict状态: {newest_dict}")
row += 1
print("\n最终 newest_dict:")
print(newest_dict)运行上述代码，你会发现 newest_dict 中的所有内部字典都拥有最后一次迭代时 new_dict 的值，而不是每个外部键对应其迭代时的独立值。这是因为 newest_dict[k] = new_dict 语句在每次迭代中都将同一个 new_dict 对象的引用存储起来。当 new_dict 在后续迭代中被修改时，所有指向它的引用都会看到这些修改。
立即学习“Python免费学习笔记（深入）”；
最直接的解决方案是在将内部字典赋值给外部字典时，创建一个内部字典的副本。Python字典的 copy() 方法会创建一个字典的浅拷贝，这意味着它会复制字典的键值对，但如果值本身是可变对象，它们仍然是引用。对于本例中的字符串、日期时间等不可变或浅层可变对象，浅拷贝已经足够。
import datetime
# 模拟初始字典结构和工作表
# ... (同上，省略重复代码)
initial_dict = {
'LG_G7_Blue_64GB_R07': {'Name': 'A', 'Code': 'B', 'Sale Effective Date': 'C', 'Sale Expiration Date': 'D'},
'Asus_ROG_Phone_Nero_128GB_R07': {'Name': 'A', 'Code': 'B', 'Sale Effective Date': 'C', 'Sale Expiration Date': 'D'}
}
class MockWorksheet: # ... (同上)
def __init__(self):
self.data = {
'A2': 'LG G7 Blue 64GB', 'B2': 'LG_G7_Blue_64GB_R07',
'C2': datetime.datetime(2005, 9, 25, 0, 0), 'D2': datetime.datetime(2022, 10, 27, 23, 59, 59),
'A3': 'Asus ROG Phone Nero 128GB', 'B3': 'Asus_ROG_Phone_Nero_128GB_R07',
'C3': datetime.datetime(2005, 9, 25, 0, 0), 'D3': datetime.datetime(2022, 10, 27, 23, 59, 59)
}
def __getitem__(self, key):
class Cell:
def __init__(self, value):
self.value = value
def __repr__(self):
return f"Cell(value={self.value})"
return Cell(self.data.get(key, None))
ws = MockWorksheet()
new_dict = {}
newest_dict = {}
row = 2
for k, v in initial_dict.items():
for i, j in v.items():
j_value = ws[j + str(row)].value
new_dict[i] = j_value
print(f"当前外部键: {k}")
print(f"当前new_dict状态: {new_dict}")
print("------")
# 解决方案：使用 .copy() 创建 new_dict 的一个独立副本
newest_dict[k] = new_dict.copy()
print(f"当前newest_dict状态: {newest_dict}")
row += 1
print("\n最终 newest_dict (使用 .copy()):")
print(newest_dict)通过 newest_dict[k] = new_dict.copy()，每次迭代都会为 newest_dict[k] 创建一个 new_dict 的独立副本，从而确保每个内部字典都是独立的，不会受到后续 new_dict 修改的影响。
另一种同样有效且在某些情况下更清晰的解决方案是，在每次外部循环迭代开始时，重新初始化内部字典 new_dict。这样可以确保每次迭代都从一个全新的、空的字典开始填充，避免了引用同一个旧字典的问题。
import datetime
# 模拟初始字典结构和工作表
# ... (同上，省略重复代码)
initial_dict = {
'LG_G7_Blue_64GB_R07': {'Name': 'A', 'Code': 'B', 'Sale Effective Date': 'C', 'Sale Expiration Date': 'D'},
'Asus_ROG_Phone_Nero_128GB_R07': {'Name': 'A', 'Code': 'B', 'Sale Effective Date': 'C', 'Sale Expiration Date': 'D'}
}
class MockWorksheet: # ... (同上)
def __init__(self):
self.data = {
'A2': 'LG G7 Blue 64GB', 'B2': 'LG_G7_Blue_64GB_R07',
'C2': datetime.datetime(2005, 9, 25, 0, 0), 'D2': datetime.datetime(2022, 10, 27, 23, 59, 59),
'A3': 'Asus ROG Phone Nero 128GB', 'B3': 'Asus_ROG_Phone_Nero_128GB_R07',
'C3': datetime.datetime(2005, 9, 25, 0, 0), 'D3': datetime.datetime(2022, 10, 27, 23, 59, 59)
}
def __getitem__(self, key):
class Cell:
def __init__(self, value):
self.value = value
def __repr__(self):
return f"Cell(value={self.value})"
return Cell(self.data.get(key, None))
ws = MockWorksheet()
newest_dict = {}
row = 2
for k, v in initial_dict.items():
# 解决方案：在每次外部循环迭代开始时重新初始化 new_dict
new_dict = {}
for i, j in v.items():
j_value = ws[j + str(row)].value
new_dict[i] = j_value
print(f"当前外部键: {k}")
print(f"当前new_dict状态: {new_dict}")
print("------")
newest_dict[k] = new_dict
print(f"当前newest_dict状态: {newest_dict}")
row += 1
print("\n最终 newest_dict (循环内重新初始化):")
print(newest_dict)将 new_dict = {} 移动到外部 for 循环内部，确保了在每次处理一个新的外部键 k 时，都会创建一个全新的空字典 new_dict。这样，即使 new_dict 在当前迭代中被修改，也不会影响到之前已经存储在 newest_dict 中的内部字典实例。
通过上述两种方法，开发者可以有效地避免在Python中构建嵌套数据结构时因引用问题导致的数据覆盖，确保每个数据项都独立存储其预期值。理解并正确应用这些技术对于编写健壮和可预测的Python代码至关重要。
以上就是Python字典嵌套更新中的引用陷阱与解决方案的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
597
