在Python中使用字典和串列映射鍵-有解無憂

我有一個字典串列，如下所示：

ini_dict = [[
       {'nikhil': 1, 'vashu': 5, 'manjeet': 10, 'akshat': 16}, 
       {'nikhil': 1, 'vashu': 5, 'manjeet': 10, 'akshat': 15}
]]

第 1 步：降低一級

我已經修改并減少了一個級別，如下所示：

mod = []
for i in ini_dict:
    for j in i:
        mod.append({item: values for item, values in j.items()})

這給了我如下輸出：

[
   {'nikhil': 1, 'vashu': 5, 'manjeet': 10, 'akshat': 15}, 
   {'nikhil': 1, 'vashu': 5, 'manjeet': 10, 'akshat': 15}
]

第 2 步：用另一個字典中的值替換鍵

現在，我有另一組鍵字典 result_dict1 ，我使用鍵（此處為小寫）將上述資料中的鍵替換為mod相關值（此處為大寫）。

result_dict1 = {
   "nikhil": "Nikhil",
   "vashu": "Vashu",
   "manjeet": "Manjeet",
   "akshat": "Akshat"
}

我試過的代碼

現在，我已經嘗試了下面的代碼，但它沒有給我我需要的輸出：

final = []
for j, k in result_dict1.items():
    for i in mod:
        for x, y in i.items():
            final  = [{k: y}]

輸出：

[{'Nikhil': 1}, {'Nikhil': 5}, {'Nikhil': 10}, {'Nikhil': 15}, {'Nikhil': 1}, {'Nikhil': 5}, {'Nikhil': 10}, {'Nikhil': 15}, {'Vashu': 1}, {'Vashu': 5}, {'Vashu': 10}, {'Vashu': 15}, {'Vashu': 1}, {'Vashu': 5}, {'Vashu': 10}, {'Vashu': 15}, {'Manjeet': 1}, {'Manjeet': 5}, {'Manjeet': 10}, {'Manjeet': 15}, {'Manjeet': 1}, {'Manjeet': 5}, {'Manjeet': 10}, {'Manjeet': 15}, {'Akshat': 1}, {'Akshat': 5}, {'Akshat': 10}, {'Akshat': 15}, {'Akshat': 1}, {'Akshat': 5}, {'Akshat': 10}, {'Akshat': 15}]

問題

鍵被替換，但組合是1:N。

預期輸出：

[
   {'Nikhil': 1, 'Vashu': 5, 'Manjeet': 10, 'Akshat': 15}, 
   {'Nikhil': 1, 'Vashu': 5, 'Manjeet': 10, 'Akshat': 15}
]

uj5u.com熱心網友回復：

問題

你快到了：

第 1 步：按預期作業
第 2 步：迭代鍵映射result_dict1而不是mod

固定的

我添加了評論

洗掉回圈或將其添加回稍作修改
引入了一個內部集合（dict）來保持源代碼分離

ini_dict = [[
       {'nikhil': 1, 'vashu': 5, 'manjeet': 10, 'akshat': 16}, 
       {'nikhil': 1, 'vashu': 5, 'manjeet': 10, 'akshat': 15}
]]

# step 2:
mod = []
for i in ini_dict:
    for j in i:
        mod.append({item: values for item, values in j.items()}) 

print(f"step 1:\n{mod}")

# step 2:
result_dict1 = {
   "nikhil": "Nikhil",
   "vashu": "Vashu",
   "manjeet": "Manjeet",
   "akshat": "Akshat"
}  

final = []
# for j, k in result_dict1.items():
for i in mod:
    inner = {}  # collect inner separately
    for x, y in i.items():
        k = result_dict1[x]  # lookup in dict, instead for-loop
        # final  = [{k: y}]
        inner[k] = y  # add to inner (not to final outer) !as dict-entry! (not as list)
    final.append(inner)  # keep separation
    
print(f"step 2:\n{final}")

印刷：

step 1:
[{'nikhil': 1, 'vashu': 5, 'manjeet': 10, 'akshat': 16}, {'nikhil': 1, 'vashu': 5, 'manjeet': 10, 'akshat': 15}]
step 2:
[{'Nikhil': 1, 'Vashu': 5, 'Manjeet': 10, 'Akshat': 16}, {'Nikhil': 1, 'Vashu': 5, 'Manjeet': 10, 'Akshat': 15}]

注意： 您原來的外部 for 回圈k for j, k in result_dict1.items()可以重寫為：

keys = [k for j, k in result_dict1.items() if j == x] # for-loop as list-comprehension with added conditional
k = keys[0]  # key expected as first element in resulting list

相當復雜……另外，我們希望找到密鑰，但如果串列keys為空怎么辦？然后keys[0]會提高IndexError: list index out of range。

我們最好從這里的字典中受益并簡化查找： k = result_dict1[x]

建議：命名有幫助

據我所知，變數的命名可以改進。那么也許這個邏輯缺陷會更早被發現。

例如，看到inner比更有意義i。它可以像人類語言一樣被閱讀和理解 - 無需在記憶中保留名稱字典或映射（如“i：內部串列或字典”）作為額外的認知負荷。

固定替代

將步驟 2的當前實作與您在步驟 1 中的實作進行比較：

mod = []
for i in ini_dict:
    for j in i:
        mod.append({item: values for item, values in j.items()}) 

print(f"step 1:\n{mod}")

我們也可以在這里重用稱為dict comprehension的模式：

final = []
for i in mod:
    final.append({result_dict1[x]: values for x, values in i.items()})
    
print(f"step 2:\n{final}")

好處：

視覺相似性可以識別為形狀（即使在大檔案中縮小到 10%）
it looks simpler because familiar (after we already understood step 1)
easier recognize which parts are similar (to step 1) and where they differ (e.g. no nested level for-loop)

This is also called code symmetry. See e.g. Carlos Ble (2014): Code Symmetry

uj5u.com熱心網友回復：

您似乎沒有檢查內部字典中mod的鍵是否與替換字典中的鍵匹配，這是一個問題。

帶有字典推導的串列推導會產生以下結果：

>>> [{result_dict1[key]: value for key, value in inner_dict.items()}
     for inner_dict in mod]

[{'Nikhil': 1, 'Vashu': 5, 'Manjeet': 10, 'Akshat': 15},
 {'Nikhil': 1, 'Vashu': 5, 'Manjeet': 10, 'Akshat': 15}]

因此，字典理解正在改變的內部字典，mod以便將鍵替換為result_dict1. 串列理解有助于為每個內部字典執行此操作。

如果result_dict1不夠全面，這將是錯誤的。

上面的理解可以展開為

# this is the final result; we'll fill in this
end_list = []

# foreach dictionary in `mod`...
for inner_dict in mod:
    # define anew empty dict
    new_inner_dict = {}
    
    # foreach (key, val) pair of the `inner_dict`...
    for key, value in inner_dict.items():
        # get the `new_key` from the replacer mapping
        new_key = result_dict1[key]
        
        # put it into the new dict (but the value is the same)
        new_inner_dict[new_key] = value

    # above for ended, we have a new_inner_dict; save it
    end_list.append(new_inner_dict)

print(end_list)

轉載請註明出處，本文鏈接：https://www.uj5u.com/qukuanlian/400142.html

標籤：Python 字典转型

上一篇：遍歷嵌套的pythondict

下一篇：字典物件沒有屬性拆分