Kemas kini kamus bersarang dalam Python

Dalam Python, kamus ialah struktur data tujuan umum yang membolehkan anda menyimpan dan mendapatkan pasangan nilai kunci dengan cekap. Khususnya, kamus bersarang menyediakan cara yang mudah untuk menyusun dan mewakili data yang kompleks. Walau bagaimanapun, mengemas kini nilai dalam kamus bersarang kadangkala agak sukar.

Akses elemen kamus bersarang

Untuk mengemas kini nilai dalam kamus bersarang, kami perlu mengakses kunci khusus dalam hierarki kamus terlebih dahulu. Python membolehkan anda mengakses elemen bersarang dengan menggunakan kekunci secara berturut-turut. Contohnya -

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
nested_dict['outer_key']['inner_key'] = 'new_value'

Dalam coretan kod di atas, kami mengakses elemen bersarang "inner_key" dengan memautkan kunci secara berturut-turut dan mengemas kini nilainya kepada "new_value".

Kemas kini kamus bersarang satu peringkat

Kadangkala, anda mungkin menemui kamus bersarang di mana kunci pada tahap berbeza tidak mempunyai struktur tetap. Dalam kes ini, pendekatan yang lebih umum diperlukan. Python menyediakan kaedah kemas kini(), yang membolehkan kami menggabungkan satu kamus ke kamus lain, dengan itu mengemas kini nilainya. Berikut adalah contoh −

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
update_dict = {'inner_key': 'new_value'}
nested_dict['outer_key'].update(update_dict)

Dalam coretan kod di atas, kami mencipta kamus berasingan update_dict yang mengandungi pasangan nilai kunci yang ingin kami kemas kini. Dengan menggunakan kaedah kemas kini(), kami menggabungkan update_dict ke dalam kamus bersarang pada tahap kunci yang ditentukan, dengan berkesan mengemas kini nilainya.

Kemas kini kamus bersarang berbilang peringkat

Jika anda perlu mengemas kini nilai dalam berbilang peringkat kamus bersarang, anda boleh menggunakan pendekatan rekursif. Kaedah ini melibatkan melintasi kamus secara rekursif sehingga kunci yang diperlukan ditemui. Berikut adalah contoh −

def update_nested_dict(nested_dict, keys, new_value):
   if len(keys) == 1:
      nested_dict[keys[0]] = new_value
   else:
      key = keys[0]
      if key in nested_dict:
         update_nested_dict(nested_dict[key], keys[1:], new_value)

nested_dict = {'outer_key': {'inner_key': {'deep_key': 'old_value'}}}
keys = ['outer_key', 'inner_key', 'deep_key']
new_value = 'new_value'
update_nested_dict(nested_dict, keys, new_value)

Dalam coretan kod di atas, kami mentakrifkan fungsi rekursif update_nested_dict yang mengambil sebagai argumen kamus bersarang, senarai kunci dan nilai baharu. Fungsi ini menyemak jika terdapat hanya satu kunci yang tinggal dalam senarai, jika ya, ia mengemas kini nilai dalam kamus bersarang. Jika tidak, ia merentasi kamus bersarang lebih dalam sehingga ia menemui kunci yang diperlukan.

Mengendalikan kunci yang hilang dan mencipta yang baharu

Apabila mengemas kini kamus bersarang, adalah penting untuk mempertimbangkan kes di mana kunci yang ditentukan mungkin tidak wujud. Python menyediakan beberapa teknik untuk mengendalikan situasi sedemikian dan mencipta kunci baharu apabila diperlukan.

Gunakan kaedah Setdefault()

Kaedah setdefault() ialah cara mudah untuk mengemas kini nilai dalam kamus bersarang apabila berurusan dengan kunci yang hilang. Ia membolehkan anda menentukan nilai lalai jika kunci tidak wujud. Jika kunci ditemui, nilai sedia ada dikembalikan. Jika tidak, nilai lalai akan dimasukkan ke dalam kamus. Berikut adalah contoh −

nested_dict = {'outer_key': {}}
nested_dict['outer_key'].setdefault('inner_key', 'new_value')

Dalam coretan kod di atas, kami menggunakan kaedah setdefault() untuk mengemas kini nilai "inner_key" dalam "outer_key" kamus bersarang. Jika "inner_key" tidak wujud, buat dengan nilai "new_value".

Gunakan kelas Defaultdict

Kelas lalai dalam modul koleksi menyediakan cara yang berkesan untuk mengendalikan kunci yang hilang dalam kamus bersarang. Apabila kunci yang tidak sedia ada diakses, ia secara automatik diberikan nilai lalai. Berikut adalah contoh −

from collections import defaultdict

nested_dict = defaultdict(dict)
nested_dict['outer_key']['inner_key'] = 'new_value'

Dalam coretan kod di atas, kami mencipta defaultdict dan menggunakan jenis dict sebagai kilang lalai. Ini memastikan bahawa sebarang kunci yang tidak wujud akan membuat kamus bersarang baharu secara automatik. Kami kemudiannya meneruskan untuk mengemas kini "inner_key" di dalam "outer_key" dengan nilai "new_value".

Kemas kini nilai dalam kamus bersarang dalam

Pendekatan rekursif menjadi lebih berguna jika anda mempunyai kamus bersarang dengan berbilang peringkat bersarang dan anda perlu mengemas kini nilai dalam tahap paling dalam. Anda boleh melanjutkan fungsi rekursif untuk mengendalikan kamus bersarang dalam dengan mengubah suai logik traversal dengan sewajarnya.

def update_deep_nested_dict(nested_dict, keys, new_value):
   if len(keys) == 1:
      nested_dict[keys[0]] = new_value
   else:
      key = keys[0]
      if key in nested_dict:
         update_deep_nested_dict(nested_dict[key], keys[1:], new_value)
      else:
         nested_dict[key] = {}
         update_deep_nested_dict(nested_dict[key], keys[1:], new_value)

nested_dict = {'outer_key': {'inner_key': {'deep_key': 'old_value'}}}
keys = ['outer_key', 'inner_key', 'deep_key']
new_value = 'new_value'
update_deep_nested_dict(nested_dict, keys, new_value)

Dalam coretan kod di atas, kami mempertingkatkan fungsi rekursif sebelumnya untuk mengendalikan kamus bersarang dalam. Jika kunci hilang dari mana-mana peringkat, kamus kosong baharu dicipta dan fungsi itu terus merentasi sehingga kekunci paling dalam dicapai.

Kamus Bersarang Tidak Berubah

Perlu diingat bahawa kamus dalam Python ialah objek boleh ubah. Jadi apabila anda mengemas kini kamus bersarang, perubahan akan ditunjukkan dalam semua rujukan kepada kamus. Jika anda perlu mengekalkan keadaan asal kamus bersarang, anda boleh membuat salinan yang mendalam sebelum membuat sebarang kemas kini.

import copy

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
updated_dict = copy.deepcopy(nested_dict)
updated_dict['outer_key']['inner_key'] = 'new_value'

Contoh

import copy

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
updated_dict = copy.deepcopy(nested_dict)
updated_dict['outer_key']['inner_key'] = 'new_value'

print("Original nested_dict:")
print(nested_dict)

print("\nUpdated_dict:")
print(updated_dict)

Output

Berikut ialah output coretan kod yang disebut dalam bahagian −

Original nested_dict:
{'outer_key': {'inner_key': 'old_value'}}

Updated_dict:
{'outer_key': {'inner_key': 'new_value'}}

Dalam coretan kod di atas, fungsi copy.deepcopy() mencipta salinan lengkap kamus bersarang, termasuk semua peringkat bersarang. Ini membolehkan anda mengemas kini kamus yang disalin tanpa menjejaskan kamus asal.

Gunakan pemahaman kamus untuk mengemas kini nilai

Untuk kemas kini ringkas dalam kamus bersarang, anda boleh menggunakan pemahaman kamus Pendekatan ini sesuai apabila anda mempunyai set kunci yang diketahui untuk dikemas kini.

Contoh

.

nested_dict = {'outer_key': {'inner_key': 'old_value'}}
keys_to_update = ['outer_key']
updated_dict = {key: 'new_value' if key in keys_to_update else value for key, value in nested_dict.items()}

Output

Ini ialah output coretan kod di atas −

Original nested_dict:
{'outer_key': {'inner_key': 'old_value'}}

Updated_dict:
{'outer_key': {'inner_key': 'new_value'}}

在代码片段中，我们从包含嵌套结构的nested_dict字典开始。我们使用copy.deepcopy()创建nested_dict的深层副本并将其分配给updated_dict。然后，我们将updated_dict中'outer_key'内的'inner_key'的值更新为'new_value'。

最后，我们打印原始的nested_dict和更新后的updated_dict。从输出中可以看到，原始的nested_dict保持不变，而updated_dict反映了更新后的值。

结论

在 Python 中更新嵌套字典可能涉及访问特定键、合并字典或使用递归技术。通过了解这些不同的方法，您可以根据您的特定要求有效地更新嵌套字典中的值。在选择最合适的方法时，请记住考虑嵌套字典的结构和复杂性。

Python 的灵活性和内置方法（例如 update()、setdefault() 和 defaultdict 类）提供了强大的工具来处理各种情况，包括丢失键和创建新键。

Atas ialah kandungan terperinci Kemas kini kamus bersarang dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!