如何使用dot在dict中通過字串創建dict

我有一個字典串列。

dict_list = [
    {"nameClient": "client.name"},
    {"emailClient": "client.email"},
    {"Document.typeDocument": "client.type_document"},
    {"Document.numberDocument": "client.number_document"},
    {"Document.docOne.number": "client.docone_number"},
    {"Document.docOne.type": "client.docone_type"},
    {"Document.docTwo.number": "client.doctwo_number"},
    {"Document.docOne.extra.number": "client.docone_extra_number"},
]

我想根據這個字典的鍵創建一個字典，并根據這個字典的值從我的類中獲取值。

客戶端類和值初始化：

class Client:
    def __init__(self, data):
        self.name = data['name']
        self.email = data['email']
        self.type_document = data['type_document']
        self.number_document = data['number_document']
        self.docone_number = data['docone_number']
        self.docone_type = data['docone_type']
        self.doctwo_number = data['doctwo_number']
        self.docone_extra_number = data['docone_extra_number']
        
# this will be passed on build_final_dict(FINAL_DICT, i, k, v, client)
client1 = Client({
    "name": "Stack",
    "email": "[email protected]",
    "type_document": "TPS",
    "number_document": "22222222",
    "docone_number": "11111111",
    "docone_type": "docone type",
    "doctwo_number": "doc two number",
    "docone_extra_number": "doc extra number",
})

所以我開始將鍵/值傳遞給函式

FINAL_DICT = {}

for i in dict_list:
    for k, v in i.items():
        build_final_dict(FINAL_DICT, i, k, v, client)

我的build_final_dict()

def build_final_dict(FINAL_DICT, i, k, v, client):
    if '.' not in k:
        FINAL_DICT[k] = getattr(client, v.replace('client.', ''))
    else:
        subdict = k.split('.')[0] # ex documento
        subdict_key = i.items()[0][0]
        subdict_key = subdict_key.replace('%s.' % subdict, '')
        subdict_value = i.items()[0][1]
        subdict_value = subdict_value.replace('client.', '')
        
        if subdict not in FINAL_DICT:
            FINAL_DICT[subdict] = dict()
        
        result_value = getattr(client, subdict_value)
        
        if '.' not in subdict_key:
            FINAL_DICT[subdict][subdict_key] = result_value
        else:
            new_subkey = subdict_key.split('.')[0]
            new_subvalue = subdict_key.split('.')[1]
            if new_subkey not in FINAL_DICT[subdict]:
                FINAL_DICT[subdict][new_subkey] = dict()
            build_final_dict(FINAL_DICT[subdict][new_subkey], i, new_subvalue, v, client)

實際結果：

{
   "emailClient":"[email protected]",
   "nameClient":"Stack",
   "Document":{
      "typeDocument":"TPS",
      "numberDocument":"22222222",
      "docTwo":{
         "number":"doc two number"
      },
      "docOne":{
         "type":"docone type",
         "extra":"doc extra number", // should continue creating dict within dict...
         "number":"11111111"
      }
   }
}

大部分字典都是對的。但是我放在字典（第三個子級別）中的“額外”字典并沒有創建新字典并輸入最終值。

有可能有無限的子詞典，我需要為此準備我的腳本。

我預期的結果（基于客戶端類資料）：

{
   "emailClient":"[email protected]",
   "nameClient":"Stack",
   "Document":{
      "typeDocument":"TPS",
      "numberDocument":"22222222",
      "docTwo":{
         "number":"doc two number"
      },
      "docOne":{
         "type":"docone type",
         "extra": { "number": "doc extra number" }, // dict, not string
         "number":"11111111"
      }
   }
}

uj5u.com熱心網友回復：

我認為，這將幫助您將初始 JSON 轉換為您需要的結構。這是根據您原來的要求

我想根據這個字典的鍵創建一個字典，并根據這個字典的值從我的類中獲取值。

我會嘗試使用拆分方法，為串列中的每個字典創建嵌套字典（如果它們嵌套在鍵中），然后將它們合并為單個單元。在此處查看示例方法：

from collections.abc import MutableMapping
from functools import reduce


def merge(d1, d2):
    # Merge 2 dictionaries -deep.
    for k, v in d1.items():
        if k in d2:
            if all(isinstance(e, MutableMapping) for e in (v, d2[k])):
                d2[k] = merge(v, d2[k])
    md = d1.copy()
    md.update(d2)
    return md


def explode_to_dict(key, value):
    # Create nested dicts based on the key structure
    if "." in key:
        p, c = key.rsplit(".", 1)
        return explode_to_dict(p, {c: value})
    else:
        return {key: value}


if __name__ == '__main__':
    dict_list = [
        {"nameClient": "client.name"},
        {"emailClient": "client.email"},
        {"Document.typeDocument": "client.type_document"},
        {"Document.numberDocument": "client.number_document"},
        {"Document.docOne.number": "client.docone_number"},
        {"Document.docOne.type": "client.docone_type"},
        {"Document.docTwo.number": "client.doctwo_number"},
        {"Document.docOne.extra.number": "client.docone_extra_number"},
    ]
    result_dict = {}
    result_dict = reduce(merge, [explode_to_dict(*d.popitem()) for d in dict_list])
    print(json.dumps(result_dict))

這提供了如下結構（預期）：

{
    "nameClient": "client.name",
    "emailClient": "client.email",
    "Document": {
        "typeDocument": "client.type_document",
        "numberDocument": "client.number_document",
        "docOne": {
            "number": "client.docone_number",
            "type": "client.docone_type",
            "extra": {
                "number": "client.docone_extra_number"
            }
        },
        "docTwo": {
            "number": "client.doctwo_number"
        }
    }
}

我想，你可以從這里繼續你的班級操作！

標籤：Python 字典

上一篇：MapwithDefault不是作業kotlin？

下一篇：是否可以在某個數字下查找字典值的鍵？