Python 3.x 从textfile在Python中创建嵌套字典

关于Python3中的嵌套字典，我有一个问题。我已经尝试了很多方法，但我仍然被这个计划的意外结果所困扰。文本文件包含以下信息：

SERVER01_X  
--------------------------------------------------
Tue May 07, 01:15 
--------------------------------------------------
MEMORY: ''

Value  Name
876    SWAP_MEMORY
180    BUFFER
1371   TOTAL

--------------------------------------------------
Tue May 07, 01:45 
--------------------------------------------------
MEMORY: ''

Value  Name
871    SWAP_MEMORY
187    BUFFER
1379   TOTAL


SERVER02_Y  
--------------------------------------------------
Tue May 07, 01:15 
--------------------------------------------------
MEMORY: ''

Value  Name
76    SWAP_MEMORY
80    BUFFER
371   TOTAL

--------------------------------------------------
Tue May 07, 01:45 
--------------------------------------------------
MEMORY: ''

Value  Name
71    SWAP_MEMORY
87    BUFFER
379   TOTAL

计划需要产生的预期输出如下：

server_information = {
     SERVER01: {
                 Tue May 07, 01:15 : {MEMORY: {SWAP_MEMORY: 876, BUFFER: 180, TOTAL: 1371}} 
                 Tue May 07, 01:45 : {MEMORY: {SWAP_MEMORY: 871, BUFFER: 180, TOTAL: 1379}}                 
                }      
     SERVER02 : {
                 Tue May 07, 01:15 : {MEMORY: {SWAP_MEMORY: 76, BUFFER: 80, TOTAL: 371}} 
                 Tue May 07, 01:45 : {MEMORY: {SWAP_MEMORY: 71, BUFFER: 87, TOTAL: 379}}                 
                }      
}

{'SERVER01': {'May 07 01:15': {'MEMORY': {'SWAP_MEMORY': {'876'}}}}}
{'SERVER01': {'May 07 01:15': {'MEMORY': {'BUFFER': {'180'}}}}}
{'SERVER01': {'May 07 01:15': {'MEMORY': {'TOTAL': {'1371'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'SWAP_MEMORY': {'871'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'BUFFER': {'187'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:15': {'MEMORY': {'SWAP_MEMORY': {'76'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:15': {'MEMORY': {'BUFFER': {'80'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:15': {'MEMORY': {'TOTAL': {'371'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:45': {'MEMORY': {'SWAP_MEMORY': {'71'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:45': {'MEMORY': {'BUFFER': {'87'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:45': {'MEMORY': {'TOTAL': {'379'}}}}}

以下是我尝试过的程序：

#/usr/bin/python3
进口稀土
def convert_元组（元组）：
string=''.join（元组）
返回字符串
以open（'file3.txt'）作为填充：
答案={}#字典初始化
对于填充中的线：
服务器名称=''.join（关于findall（r'^（\w+）\\uw{1}'，行））
#5月7日星期二，01:15
dates=re.findall（r'^\w{3}\s+（\w{3}）\s+（\d{2}）\，\s+（\d{2}\：\d{2}）。*'，行）
对象类型=re.findall（r'（^\w+）\：*，行）
对象类型值=re.findall（r'^（\d+）\s+（\w+），行）
如果服务器名称：
key=服务器名称
对于日期中的日期：
转换日期=（转换元组（日期））
对于对象类型中的对象类型：
对象类型=对象类型
对于对象类型值，对象类型值中的对象类型名称：
答案[键]={转换日期：{对象类型：{对象类型}名称：{对象类型}}}
打印（答案）

我的程序输出如下：

server_information = {
     SERVER01: {
                 Tue May 07, 01:15 : {MEMORY: {SWAP_MEMORY: 876, BUFFER: 180, TOTAL: 1371}} 
                 Tue May 07, 01:45 : {MEMORY: {SWAP_MEMORY: 871, BUFFER: 180, TOTAL: 1379}}                 
                }      
     SERVER02 : {
                 Tue May 07, 01:15 : {MEMORY: {SWAP_MEMORY: 76, BUFFER: 80, TOTAL: 371}} 
                 Tue May 07, 01:45 : {MEMORY: {SWAP_MEMORY: 71, BUFFER: 87, TOTAL: 379}}                 
                }      
}

{'SERVER01': {'May 07 01:15': {'MEMORY': {'SWAP_MEMORY': {'876'}}}}}
{'SERVER01': {'May 07 01:15': {'MEMORY': {'BUFFER': {'180'}}}}}
{'SERVER01': {'May 07 01:15': {'MEMORY': {'TOTAL': {'1371'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'SWAP_MEMORY': {'871'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'BUFFER': {'187'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:15': {'MEMORY': {'SWAP_MEMORY': {'76'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:15': {'MEMORY': {'BUFFER': {'80'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:15': {'MEMORY': {'TOTAL': {'371'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:45': {'MEMORY': {'SWAP_MEMORY': {'71'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:45': {'MEMORY': {'BUFFER': {'87'}}}}}
{'SERVER01': {'May 07 01:45': {'MEMORY': {'TOTAL': {'1379'}}}}, 'SERVER02': {'May 07 01:45': {'MEMORY': {'TOTAL': {'379'}}}}}

---

我知道这不是最漂亮的答案，但确实有效

我没有涉及任何正则表达式，但我添加了一个部分，检查字典中是否已经有值。根据是否有值和键，我可以添加相关的值

重新导入
def convert_元组（元组）：
string=''.join（元组）
返回字符串
以open（'file3.txt'）作为填充：
答案={}#字典初始化
对于填充中的线：
服务器名称=''.join（关于findall（r'^（\w+）\\uw{1}'，行））
#5月7日星期二，01:15
dates=re.findall（r'^\w{3}\s+（\w{3}）\s+（\d{2}）\，\s+（\d{2}\：\d{2}）。*'，行）
对象类型=re.findall（r'（^\w+）\：*，行）
对象类型值=re.findall（r'^（\d+）\s+（\w+），行）
如果服务器名称：
key=服务器名称
对于日期中的日期：
转换日期=（转换元组（日期））
对于对象类型中的对象类型：
对象类型=对象类型
对于对象类型值，对象类型值中的对象类型名称：
如果回答。获取（键）：
如果回答[key].get（转换日期）：
如果回答[键][日期].get（对象类型）：
如果未回答[key][date\u converted][obj\u type].get（object\u type\u name）：
回答[键][日期转换][对象类型][对象类型名称]=对象类型值
其他：
回答[键][日期转换][对象类型]={object\u类型\u名称：object\u类型\u值}
其他：
答案[key][date_converted]={obj_type:{object_type_name:object_type_value}
其他：
答案[键]={转换日期：{对象类型：{对象类型{名称：对象类型}}
导入json
parsed=json.load（str（answer.replace（“，”））
打印（json.dumps（已解析，缩进=4））

这将产生：

{
    "SERVER01": {
        "May 07 01:15": {
            "MEMORY": {
                "SWAP_MEMORY": "876",
                "BUFFER": "180",
                "TOTAL": "1371"
            }
        },
        "May 07 01:45": {
            "MEMORY": {
                "SWAP_MEMORY": "871",
                "BUFFER": "187",
                "TOTAL": "1379"
            }
        }
    },
    "SERVER02": {
        "May 07 01:15": {
            "MEMORY": {
                "SWAP_MEMORY": "76",
                "BUFFER": "80",
                "TOTAL": "371"
            }
        },
        "May 07 01:45": {
            "MEMORY": {
                "SWAP_MEMORY": "71",
                "BUFFER": "87",
                "TOTAL": "379"
            }
        }
    }
}

---

如果你想让这里更整洁，我相信那边的人不会介意帮你的。

我知道这不是最漂亮的答案，但它确实管用

我没有涉及任何正则表达式，但我添加了一个部分，用于检查字典中是否已经存在值。根据是否存在值和键，我可以添加相关的值

重新导入
def convert_元组（元组）：
string=''.join（元组）
返回字符串
以open（'file3.txt'）作为填充：
答案={}#字典初始化
对于填充中的线：
服务器名称=''.join（关于findall（r'^（\w+）\\uw{1}'，行））
#5月7日星期二，01:15
dates=re.findall（r'^\w{3}\s+（\w{3}）\s+（\d{2}）\，\s+（\d{2}\：\d{2}）。*'，行）
对象类型=re.findall（r'（^\w+）\：*，行）
对象类型值=re.findall（r'^（\d+）\s+（\w+），行）
如果服务器名称：
key=服务器名称
对于日期中的日期：
转换日期=（转换元组（日期））
对于对象类型中的对象类型：
对象类型=对象类型
对于对象类型值，对象类型值中的对象类型名称：
如果回答。获取（键）：
如果回答[key].get（转换日期）：
如果回答[键][日期].get（对象类型）：
如果未回答[key][date\u converted][obj\u type].get（object\u type\u name）：
回答[键][日期转换][对象类型][对象类型名称]=对象类型值
其他：
回答[键][日期转换][对象类型]={object\u类型\u名称：object\u类型\u值}
其他：
答案[key][date_converted]={obj_type:{object_type_name:object_type_value}
其他：
答案[键]={转换日期：{对象类型：{对象类型{名称：对象类型}}
导入json
parsed=json.load（str（answer.replace（“，”））
打印（json.dumps（已解析，缩进=4））

这将产生：

{
    "SERVER01": {
        "May 07 01:15": {
            "MEMORY": {
                "SWAP_MEMORY": "876",
                "BUFFER": "180",
                "TOTAL": "1371"
            }
        },
        "May 07 01:45": {
            "MEMORY": {
                "SWAP_MEMORY": "871",
                "BUFFER": "187",
                "TOTAL": "1379"
            }
        }
    },
    "SERVER02": {
        "May 07 01:15": {
            "MEMORY": {
                "SWAP_MEMORY": "76",
                "BUFFER": "80",
                "TOTAL": "371"
            }
        },
        "May 07 01:45": {
            "MEMORY": {
                "SWAP_MEMORY": "71",
                "BUFFER": "87",
                "TOTAL": "379"
            }
        }
    }
}

---

如果你想让它更整洁，我相信那边的人不会介意帮你。

非常感谢，奥利弗，它工作正常。您能否帮助详细说明检查值部分？例如，在基本层：如果根目录中没有与

server\u name

变量相同的值，则它将为密钥server\u name分配一个新的分支（字典）。这由.get（key）函数处理，该函数返回True或None，具体取决于该键是否已经存在。在已经分配密钥的情况下，它将向上移动字典并执行相同的检查。这避免了数据被覆盖的问题。这就是你所面临的问题，正如你在回溯中所看到的