迭代Python字典并在其上构建新字典的正确方法

Question

我正试图找到一种有说服力的方法来检查字典中是否存在某些键，并使用这些键来构建一个新的字典

下面是我的json示例：

 "dmarc": {
    "record": "v=DMARC1; p=none; rua=mailto:dmarc.spc@test.domain; adkim=s; aspf=s",
    "valid": true,
    "location": "test.domain",
    "warnings": [
                "DMARC record at root of test.domain has no effect"
                ],
     "tags": {
            "v": {
                   "value": "DMARC1",
                   "explicit": true
                 },
            "p": {
                   "value": "none",
                   "explicit": true
                 },
            "rua": {
                   "value": [
                          {
                           "scheme": "mailto",
                           "address": "ssc.dmarc.spc@canada.ca",
                           "size_limit": null
                          }
                         ],
                   "explicit": true
                   },
            "adkim": {
                   "value": "s",
                   "explicit": true
                     },
            "aspf": {
                   "value": "s",
                   "explicit": true
                   },
            "fo": {
                   "value": [
                             "0"
                            ],
                   "explicit": false
                  },
           "pct": {
                   "value": 100,
                   "explicit": false
                  },
           "rf": {
                  "value": [
                            "afrf"
                           ],
                  "explicit": false
                 },
           "ri": {
                  "value": 86400,
                  "explicit": false
                 },
           "sp": {
                  "value": "none",
                  "explicit": false
                 }
             }
       }
 }

我特别想做的是，以编程的方式拉取record、valid、location、tags-p、tags-sp和tags-pct，而不是做一堆try/excepts。例如，要获得valid，我需要：

try:
    res_dict['valid'] = jsonData['valid']
except KeyError:
    res_dict['valid'] = None

现在，对于顶级的键/值，循环/重复这个操作已经足够容易了，但是对于嵌套的键/值，我该如何完成这个操作呢

Answer 1

简单：使用

• dict.get('key', {})对于不是叶的所有节点，以及
• dict.get('key', DEFAULT)对于叶子，DEFAULT就是你所需要的

如果省略DEFAULT并且'key'不存在，则得到None。见^{}

例如：

jsonData.get('record', "")    # empty string if no 'record' key
jsonData.get('valid', False)  # False if no 'valid' key
jsonData.get('location')      # None if no 'location'
jsonData.get('tags', {}).get('p')  # None if no 'tags' and/or no 'p'
jsonData.get('tags', {}).get('p', {})  # {} if no 'tags' and/or no 'p'
jsonData.get('tags', {}).get('p', {}).get('explicit', False)  # and so on

上面假设您不遍历列表（JSON数组）。如果你这样做了，你仍然可以使用

• dict.get('key', [])

但是，如果你必须从那里深入，你可能需要循环列表项

Answer 2

一种处理方法是利用dict.keys的结果可以被视为set的事实。请参见以下代码

my_keys = {'record', 'valid', 'location'} # you can add more here
new_dict = {}
available_keys = my_keys & jsonData.keys()
for key in available_keys:
    new_dict[key] = jsonData[key]

上面，我们在my_keys集合中定义我们感兴趣的键。然后，我们通过获取字典中的键和我们感兴趣的键的交集来获得可用的键。实际上，它只获取我们感兴趣的、在字典中定义的键。最后，我们只需遍历available_keys并构建新字典

但是，如果输入字典中不存在键，则不会将它们设置为None。为此，最好使用其他答案中提到的get方法，例如：

my_keys = ['record', 'valid', 'location'] # you can add more here
new_dict = {}
for key in my_keys:
    new_dict[key] = jsonData.get(key)

get方法允许我们尝试获取字典中键的值。如果未定义该键，则返回None。还可以通过向get方法添加额外的参数来更改返回的默认值，如so new_dict[key] = jsonData.get(key, "some other default value")

Answer 3

不，不需要try-except块。您可以使用以下方法检查密钥是否存在：

if jsonData.get("valid"):
    res_dict["valid"] = jsonData.get("valid")

.get("key")方法返回给定的key的值（如果存在于字典中）。如果不是，那么它将返回None（如果get（）只与一个参数一起使用）

如果您想让它在找不到key的情况下返回其他内容，那么假设：

jsonData.get("valid", "invalid_something_else")