Python 链式 get() 方法与 JSON 中的列表元素

Question

[Python 2.7]

我有一个 JSON 源，它并不总是返回预期键的完整列表。我正在使用链式gets() 来解决这个问题。

d = {'a': {'b': 1}}

print(d.get('a', {}).get('b', 'NA'))
print(d.get('a', {}).get('c', 'NA'))

>>> 1
>>> NA

但是，有些字典在列表中：

d = {'a': {'b': [{'c': 2}]}}

print(d['a']['b'][0]['c'])

>>> 2

我不能使用 get() 方法来解决这个问题，因为列表不支持 get() 属性：

d.get('a', {}).get('b', []).get('c', 'NA')

>>> AttributeError: 'list' object has no attribute 'get'

除了捕获数百个潜在的 KeyErrors 之外，是否有更好的方法来解释潜在的缺失 ['c']（与上面的链式 get() 构造类似）？

Answer 1

我同意@stovfl 的观点，即编写自己的查找函数是可行的方法。虽然，我不认为递归实现是必要的。以下应该足够好：

def nested_lookup(obj, keys, default='NA'):
    current = obj
    for key in keys:
        current = current if isinstance(current, list) else [current]
        try:
            current = next(sub[key] for sub in current if key in sub)
        except StopIteration:
            return default
    return current


d = {'a': {'b': [{'c': 2}, {'d': 3}]}}

print nested_lookup(d, ('a', 'b', 'c'))  # 2
print nested_lookup(d, ('a', 'b', 'd'))  # 3
print nested_lookup(d, ('a', 'c'))       # NA

类方法似乎不太好，因为您将创建许多不必要的对象，并且如果您曾经尝试查找不是叶子的节点，那么您将结束使用自定义对象而不是实际的节点对象。

Answer 2

问题：我不能使用 get() ... 因为列表不支持 get()。

1. 您可以实现自己的list.get()，例如：

   class myGET(object):
       def __init__(self, data):
           if isinstance(data, dict):
               self.__dict__.update(data)
           if isinstance(data, list):
               for d in data:
                   self.__dict__.update(d)
   
       def get(self, key, default=None):
           if hasattr(self, key):
               _attr = object.__getattribute__(self, key)
               if isinstance(_attr, (list, dict)):
                   return myGET(_attr)
               else:
                   return _attr
           else:
               return default
   
   d = {'a': {'b': [{'c': 2}]}}
   myGET(d).get('a', {}).get('b', []).get('c', 'NA')
   >>> 2
   
   myGET(d).get('a', {}).get('b', []).get('d', 'NA')
   >>> NA
   

2. 一个递归的解决方案，不需要链接，例如：

   def get(_dict, subkey, default):
       def _get(_dict, key, deep):
           if key == subkey[deep]:
               if deep == len(subkey) - 1:
                   return _dict
               else:
                   return _get(_dict, None, deep + 1)
   
           elif isinstance(_dict, dict):
               for k in _dict:
                   match = _get(_dict[k], k, deep)
                   if match: return match
   
           elif isinstance(_dict, list):
               for e in _dict:
                   match = _get(e, None, deep)
                   if match: return match
   
       if not isinstance(subkey, (tuple, list)):
           subkey = (subkey)
   
       _r = _get(_dict, None, 0)
       if not _r: return default
       else:      return _r
   
   get(d, 'c', 'NA')
   >>> 2
   
   get(d, 'd', 'NA')
   >>> NA
   
   # get a inside b
   d = {'a': {'b': [{'a': 3}, {'c': 2}]}}
   get(d, ('b', 'a'), 'NA')
   >>> 3
   

使用 Python 测试：3.4.2 和 2.7.9