什么是递归检索 id 值的最佳数据结构？

Question

我想要做的是创建一个mapped id-table ，理论上看起来像下面的嵌套字典。

Ids = {
    "League_id": {
        "League_name":"NAME",
        "League_abbre": "ABBREVIATION"
        "seasons_id": {         
            "label":"LABEL",
            "teams":{
                "team_id": {
                "Player_id":"PLAYER"
                            }
                    }
                }
    "League_id": {                           
        "League_name":"NAME",
        "League_abbre": "ABBREVIATION"
        "seasons_id": {         
            "label":"LABEL",
            "teams":{
                "team_id": {
                "Player_id":”PLAYER"
                            }
                    }

                }
        }

问题是每个“层”都必须递归合并，这意味着我必须先获得第一层 Id，然后才能检索第二层 Id，然后合并这两层。 合并两层后，我必须从合并的字典中检索第一层和第二层 Id 以获得第三层 Id，然后再次合并，依此类推。 不同的层如下。

1 layer: League_id (All are unique)
2 layer: Season_id (All are unique, seasons_ids has to be mapped to the right league_id)
3 layer:  teams_id (All are unique, teams_id has to be mapped to the right league_id, can be part of multiple seasons)
4 layel: player_id (All are unique, players_id has to be mapped to the right team_id, can be part of different team_id for different season_id)

因此，对于每一层，检索不同的 Id 变得越来越困难，因为在第二层和第三层中无法轻松查询它们，因为我需要进行嵌套循环。 我的问题是，可以使用什么数据结构来轻松查询所有 Id？

下面是我为从我使用的数据库中检索它们自己的 id 所做的查询：

  League_id: /competitions
  Season_id: /competitions/{{League_id}}
  teams_id: /teams/comps{{League_id}}/compSeasons{{Season_id}}
  player_id: /teams/{{teams_id}}/compseasons/{{Season_id}}/staff

当从数据库中检索到所有 id 并将其映射到它们的层时，应该可以轻松地检索和 id 执行以下操作，例如：

League_id = 1
Season_id = 274
Ids[League_id][Season_id] 

并获取该 season_id 中的所有 team_id。

#Small script and different urls to view the different layers of Ids:

import json
import requests

layer1 = 'https://footballapi.pulselive.com/football/competitions' #League Ids
layer2 = 'https://footballapi.pulselive.com/football/competitions/1/compseasons'#Season Ids for League_id: 1
layer3 = 'https://footballapi.pulselive.com/football/teams?comps=1&pageSize=100&compSeasons=274'#Teams_Ids for League_id: 1, Season_id:274
layer4 = 'https://footballapi.pulselive.com/football/teams/1/compseasons/274/staff' #Players_Ids for team_id: 1, Season_id:274
def view_raw_input(url):
    """View the input data that I use to retrieve the different Ids"""
    headers = {'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                        'Origin': 'https://www.premierleague.com',
                        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36'
              }
    params = (('pageSize', '100'),)
    response = requests.get(url, headers=headers, params=params).json()
    if url == 'https://footballapi.pulselive.com/football/teams/1/compseasons/274/staff':
        data = response
    else:
        data = response['content']
    print(data)

感谢所有输入，非常感谢您阅读所有这些内容。

Answer 1

一种可能的方法是创建处理函数来为每个级别返回正确的字典结构。 您可以简单地将这些处理程序链接在一起以构建结构：

import requests
def get_data(url):
   headers = {'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                    'Origin': 'https://www.premierleague.com',
                    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36'
          }
   params = (('pageSize', '100'),)
   return requests.get(url, headers=headers, params=params).json()

links = ['https://footballapi.pulselive.com/football/competitions', 'https://footballapi.pulselive.com/football/competitions/{}/compseasons', 'https://footballapi.pulselive.com/football/teams?comps={}&pageSize=100&compSeasons={}', 'https://footballapi.pulselive.com/football/teams/{}/compseasons/{}/staff']

def l4(link, *args):
   print(link.format(*args))
   try:
      return {i['playerId']:i for i in get_data(link.format(*args))['players'] if i}
   except:
      return {}

def l3(link, *args):
   return {int(i['club']['id']):l4(links[3], int(i['club']['id']), int(args[-1])) for i in get_data(link.format(*args))['content'] if i}

def l2(link, *args):
   return {int(i['id']):{'label':i['label'], 'teams':l3(links[2], *args, int(i['id']))} for i in get_data(link.format(*args))['content'] if i}

def l1(link, *args):
   return {int(i['id']):{"League_name":i['description'], "League_abbre":i['abbreviation'], **l2(links[1], int(i['id']))} for i in get_data(link.format(*args))['content'] if i}


result = l1(links[0])

Answer 2

我更喜欢或多或少的面向对象的方法，但使用 dicts 你仍然可以做得很好，考虑这样的事情：

import json
import requests

layer1 = 'https://footballapi.pulselive.com/football/competitions' #League Ids
layer2 = 'https://footballapi.pulselive.com/football/competitions/1/compseasons'#Season Ids for League_id: 1
layer3 = 'https://footballapi.pulselive.com/football/teams?comps=1&pageSize=100&compSeasons=274'#Teams_Ids for League_id: 1, Season_id:274
layer4 = 'https://footballapi.pulselive.com/football/teams/1/compseasons/274/staff' #Players_Ids for team_id: 1, Season_id:274


def load_raw_data(url):
    """View the input data that I use to retrieve the different Ids"""
    headers = {'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                        'Origin': 'https://www.premierleague.com',
                        'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36'
              }
    params = (('pageSize', '100'),)
    try:
        response = requests.get(url, headers=headers, params=params).json()
    except:
        return {}

    if url.endswith('staff'):
        data = response['players']
    else:
        data = response['content']
        # note: bit of a hack, for some reason 'id' is a float, but everywhere it's referenced, it's an int
        for d in data:
            d['id'] = int(d['id'])

    return data


class TeamPlayers(dict):
    _players = {}

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def load_players_for_team(self, team, comp):
        ds = load_raw_data(
            f'https://footballapi.pulselive.com/football/teams/{team}/compseasons/{comp}/staff')
        self.clear()
        for d in ds:
            self._players[d['id']] = d
            self[d['id']] = self._players[d['id']]


class SeasonTeams(dict):
    _teams = {}

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    class Team(dict):
        def __init__(self, competition, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self['competition'] = competition
            self.players = TeamPlayers()

        def load_players(self):
            self.players.load_players_for_team(self['id'], self['competition'])

    def load_teams_for_season(self, season, comp):
        ds = load_raw_data(
            f'https://footballapi.pulselive.com/football/teams?comps={comp}&pageSize=100&compSeasons={season}')
        self.clear()
        for d in ds:
            d['competition'] = comp
            self._teams[d['id']] = self.Team(comp, d)
            self[d['shortName']] = self._teams[d['id']]


class Season(dict):
    all_teams = SeasonTeams()

    def __init__(self, competition, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self['competition'] = competition
        self.teams = SeasonTeams()

    def load_teams(self):
        self.teams.load_teams_for_season(self['id'], self['competition'])


class League(dict):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.seasons = {}

    def load_seasons(self):
        ds = load_raw_data(f'https://footballapi.pulselive.com/football/competitions/{self["id"]}/compseasons')
        self.seasons = {d['label']: Season(self['id'], d) for d in ds}


class Football:
    def __init__(self):
        self.leagues = {}

    def load_leagues(self):
        ds = load_raw_data('https://footballapi.pulselive.com/football/competitions')
        self.leagues = {d['abbreviation']: League(d) for d in ds}


fb = Football()
fb.load_leagues()
fb.leagues['EN_PR'].load_seasons()
fb.leagues['EN_PR'].seasons['2019/20'].load_teams()

# load the players for a specific team
fb.leagues['EN_PR'].seasons['2019/20'].teams['Arsenal'].load_players()

# or perhaps for all
for team in fb.leagues['EN_PR'].seasons['2019/20'].teams.values():
    team.load_players()

print(fb.leagues)
print(fb.leagues['EN_PR'].seasons)
print(fb.leagues['EN_PR'].seasons['2019/20'].teams)
print(fb.leagues['EN_PR'].seasons['2019/20'].teams['Arsenal'].players)

print('goalies:',
      [player['name']['display']
       for team in fb.leagues['EN_PR'].seasons['2019/20'].teams.values()
       for player in team.players.values() if 'position' in player['info'] and player['info']['position'] == 'G'])

它避免了两次加载团队或玩家，只加载您需要的内容。 但是，当然，决定您需要什么可能仍然很棘手。 您可以通过让各种类按需加载它们的内容来使这个更有趣。

我也想分享输出，但大小超过了 StackOverflow 允许我发布的大小，所以请自己运行。 如果它看起来有点慢，那主要是因为它在英超联赛的一个赛季中为所有球队装载了所有球员 - 你可能会更加节俭，这取决于你想要做什么。 我认为列出那个赛季的所有守门员会很有趣。