python方法1变量嵌套字典

Question

我发现这个问题很难命名，但它一定很简单，而且我遗漏了一些基本的东西

假设我有以下Python dict（）：

import json

dct = dict()
dct['hits'] = dict()
dct['hits']['hits'] = dict()
dct['hits']['hits']['a'] = 'b'
dct['hits']['hits']['b'] = 'c'
dct['aggregations'] = dict()
dct['aggregations']['a'] = 1
dct['aggregations']['b'] = 2

print(json.dumps(dct, indent=2))

{
  "hits": {
    "hits": {
      "a": "b",
      "b": "c"
    }
  },
  "aggregations": {
    "a": 1,
    "b": 2
  }
}

这看起来很熟悉，因为它是ElasticSearch返回结果的结构

我正在构建一个函数来使用这个结果。但有时我想访问dct['hits']['hits']，有时我想访问dct['aggregations']

很自然，我会使用一个带有变量的函数来表示要访问哪个字段，如下所示：

def foo(field):
    return dct[field]

如果field='aggregations'一切都好。但是当我希望字段是['hits']['hits']时，我该怎么办呢

---

解决这个问题的一种方法（但它很难看），迭代方法：

def foo(fields=('hits','hits')):
    wanted = dct
    for field in fields:
        wanted = wanted[field]
    return wanted

a = foo()
a
Out[47]: {'a': 'b', 'b': 'c'}
a = foo(('aggregations',))
a
Out[51]: {'a': 1, 'b': 2}

---

我试图修改的实际函数：

def execute_scroll_query(es_client, query, indexes):
    try:
        response = es_client.search(index=indexes, scroll='2m', size=1000, body=query)
        scroll_size = len(response['hits']['hits'])
        sid = response['_scroll_id']
        while scroll_size > 0:
            try:
                for hit in response['hits']['hits']:
                    yield hit
                response = es_client.scroll(scroll_id=sid, scroll='2m')
                sid = response['_scroll_id']
                scroll_size = len(response['hits']['hits'])
            except Exception:
                print("Unexpected Exception while scrolling")
    except Exception:
        print("Unexpected Exception while fetching")

Answer 1

此函数将递归查找传递给它的字典中的键d，并返回最后一次成功的查找

def get_nested(d, key):
    result = d.get(key)
    if isinstance(result, dict):
        return result or get_nested(result, key)
    return result

可以这样称呼

get_nested(dct, 'hits')
get_nested(dct, 'aggregations')

Answer 2

尝试执行：

dct = dict()
dct['hits'] = dict()
dct['hits']['hits'] = dict()
dct['hits']['hits']['a'] = 'b'
dct['hits']['hits']['b'] = 'c'
dct['aggregations'] = dict()
dct['aggregations']['a'] = 1
dct['aggregations']['b'] = 2


def foo(dct, *fields):
    n = len(fields)

    for idx in range(n):
        if idx == n - 1:
            return dct[fields[idx]]
        else:
            dct = dct[fields[idx]]


print(foo(dct, 'hits'))    
print(foo(dct, 'hits', 'hits'))
print(foo(dct, 'hits', 'hits', 'a'))
print(foo(dct, 'aggregations'))
print(foo(dct, 'aggregations', 'a'))

Answer 3

您可以使用functools.reduce，但实际上，它使用的是迭代，可能不如显式迭代有效：

from functools import reduce

def foo(d, keys):
    return reduce(lambda x, y: x[y], keys, d)

foo(dct, ['hits', 'hits', 'a'])
#'b'