使用多个API调用填充可变嵌套的字典

Question

我正在使用www.gpcontract.co.uk上的公共API来填充代表英国卫生组织层次结构的大型可变嵌套字典。

一些背景资料

层次结构的最高层是英国的四个国家（英格兰，苏格兰，威尔士和北爱尔兰），然后是区域组织，一直到各个诊所。 每个国家/地区的层次结构深度都不同，并且会根据年份而变化。 每个组织都有一个名称，组织代码和字典，列出其子组织。

不幸的是，API无法提供完整的嵌套层次结构，但是对http://www.gpcontract.co.uk/api/children/[organisation code]/[year]调用将返回其他任何直接的子组织。

为了可以在我的应用程序中轻松浏览层次结构，我想生成一个完整层次结构的离线词典（每年），将使用pickle保存并与应用程序捆绑在一起。

得到这个意味着很多API调用，而且我在将返回的JSON转换成我需要的字典对象方面遇到麻烦。

这是层次结构中很小一部分的示例（我仅以单个子组织为例）。

JSON层次结构示例

{
  "eng": {
    "name": "England",
    "orgcode": "eng",
    "children": {}
  },
  "sco": {
    "name": "Scotland",
    "orgcode": "sco",
    "children": {}
  },
  "wal": {
    "name": "Wales",
    "orgcode": "wal",
    "children": {}
  },
  "nir": {
    "name": "Northern Ireland",
    "orgcode": "nir",
    "children": {
      "blcg": {
        "name": "Belfast Local Commissioning Group",
        "orgcode": "blcg",
        "children": {
          "abc": {
            "name": "Random Clinic",
            "orgcode": "abc",
            "children": {}
          }
        }
      }
    }
  }
}

这是我用来进行API调用并填充字典的脚本：

我的剧本

import json, pickle, urllib.request, urllib.error, urllib.parse

# Organisation hierarchy may vary between years. Set the year here.
year = 2017

# This function returns a list containing a dictionary for each child organisation with keys for name and orgcode
def get_child_orgs(orgcode, year):
    orgcode = str(orgcode)
    year = str(year)

    # Correct 4-digit year to 2-digit
    if len(year) > 2:
        year = year[2:]

    try:
        child_data = json.loads(urllib.request.urlopen('http://www.gpcontract.co.uk/api/children/' + str(orgcode) + '/' + year).read())

        output = []

        if child_data != []:
            for item in child_data['children']:
                output.append({'name' : item['name'], 'orgcode' : str(item['orgcode']).lower(), 'children' : {}})
        return output
    except urllib.error.HTTPError:
        print('HTTP error!')
    except:
        print('Other error!')

# I start with a template of the top level of the hierarchy and then populate it
hierarchy = {'eng' : {'name' : 'England', 'orgcode' : 'eng', 'children' : {}}, 'nir' : {'name' : 'Northern Ireland', 'orgcode' : 'nir', 'children' : {}}, 'sco' : {'name' : 'Scotland', 'orgcode' : 'sco', 'children' : {}}, 'wal' : {'name' : 'Wales', 'orgcode' : 'wal', 'children' : {}}}

print('Loading data...\n')

# Here I use nested for loops to make API calls and populate the dictionary down the levels of the hierarchy. The bottom level contains the most items.
for country in ('eng', 'nir', 'sco', 'wal'): 

    for item1 in get_child_orgs(country, year):
        hierarchy[country]['children'][item1['orgcode']] = item1

        for item2 in get_child_orgs(item1['orgcode'], year):
            hierarchy[country]['children'][item1['orgcode']]['children'][item2['orgcode']] = item2

            # Only England and Wales hierarchies go deeper than this
            if country in ('eng', 'wal'):

                level3 = get_child_orgs(item2['orgcode'], year)
                # Check not empty array
                if level3 != []:
                    for item3 in level3:
                        hierarchy[country]['children'][item1['orgcode']]['children'][item2['orgcode']]['children'][item3['orgcode']] = item3

                        level4 = get_child_orgs(item3['orgcode'], year)
                        # Check not empty array
                        if level4 != []:
                            for item4 in level4:
                                hierarchy[country]['children'][item1['orgcode']]['children'][item2['orgcode']]['children'][item3['orgcode']]['children'][item4['orgcode']] = item4

# Save the completed hierarchy with pickle
file_name = 'hierarchy_' + str(year) + '.dat'
with open(file_name, 'wb') as out_file:
    pickle.dump(hierarchy, out_file)

print('Success!')

问题

这似乎在大多数时间都有效，但是当嵌套的for循环返回“ NoneType不可迭代的错误”时，它感觉很hack，有时会崩溃。 我意识到这需要进行大量的API调用，并且要花几分钟的时间才能运行，但是我看不到解决的办法，因为我希望用户可以脱机使用完整的层次结构，以便用户可以快速搜索数据。 然后，我将以略有不同的方式使用API​​，以获取所选组织的实际医疗数据。

我的问题

有没有更清洁，更灵活的方法来适应组织层次结构的可变嵌套？

有没有一种方法可以显着更快地做到这一点？

我对JSON经验不足，因此可以提供任何帮助。

Answer 1

我认为这个问题可能更适合在Code Review Stack Exchange上使用，但是正如您提到的那样，您的代码有时会崩溃并返回NoneType错误，我将为您带来疑问。

查看您的描述，这对我很突出

每个组织都有一个名称，组织代码和字典，列出其子组织。 [API调用]将返回任何其他的直接子组织。

因此，这对我来说（以及它在示例数据中的外观）提示我所有数据都是完全相同的； 层次结构仅由于数据嵌套而存在，并且不受任何特定节点的格式强制执行。

因此，这意味着您应该能够使用一小段代码来处理无限（或者，如果您愿意的话）深树的嵌套。 显然，您是针对API调用本身（ get_child_orgs() ）执行此操作的，因此只需复制该内容即可构造树。

def populate_hierarchy(organization,year):
    """ Recursively Populate the Organization Hierarchy

        organization should be a dict with an "orgcode" key with a string value
        and "children" key with a dict value.

        year should be a 2-4 character string representing a year.
    """
    orgcode = organization['orgcode']

    ## get_child_orgs returns a list of organizations
    children = get_child_orgs(orgcode,year)

    ## get_child_orgs returns None on Errors
    if children:
        for child in children:

            ## Add child to the current organization's children, using
            ## orgcode as its key
            organization['children'][child['orgcode']] = child

            ## Recursively populate the child's sub-hierarchy
            populate_hierarchy(child,year)

    ## Technically, the way this is written, returning organization is
    ## pointless because we're modifying organization in place, but I'm
    ## doing it anyway to explicitly denote the end of the function
    return organization

 for country in hierarchy.values():
     populate_hierarchy(country,year)

值得注意的是（因为您在迭代原始代码之前先检查了空列表），如果y是一个空列表，则y for x in y仍然可以正常工作，因此您无需进行检查。

由于您在get_child_orgs捕获到错误，然后隐式返回None ，因此可能会出现NoneType错误。 因此，例如， level3 = get_child_orgs[etc...]导致level3 = None ; 这将导致if None != []:在下一行为True，然后尝试对None for item3 in None:遍历for item3 in None:这将引发错误。 如上面的代码所述，这就是为什么我检查children的真实性的原因。

至于是否可以更快地完成此操作，可以尝试使用threading/multiprocessing模块。 我只是不知道其中任何一个将有多大盈利，原因有以下三个：

1. 我还没有尝试过API，所以我不知道实现多个线程/进程需要花费多少时间
2. 当您查询得太快/太频繁时，我已经看到API的IP地址超时请求（这会使实现毫无意义）
3. 您说您每年只运行一次此过程，因此从全年来看，运行时似乎显得微不足道（显然，除非当前的API调用花了几天的时间才能完成）

最后，我会简单地问： pickle是否是存储信息的合适方法，或者您是否会仅仅使用json.dump/load更好（记录， json模块不在乎您是否更改扩展名） .dat如果您是该扩展名的一部分）。