Dostęp do zagnieżdżonych pozycji słownika za pomocą listy kluczy?

1. przyjęte rozwiązanie nie będzie działać bezpośrednio dla python3-będzie wymagało from functools import reduce.
2. wydaje się również bardziej pythoniczne użycie pętli for. Zobacz cytat z Co nowego w Pythonie 3.0.

   Usunięto reduce(). Użyj functools.reduce(), jeśli naprawdę tego potrzebujesz; jednak w 99% przypadków wyraźna pętla for jest bardziej czytelna.

3. następnie zaakceptowane rozwiązanie nie ustawia nieistniejących zagnieżdżonych kluczy ( zwraca KeyError) - Zobacz odpowiedź @eafit rozwiązanie

Więc dlaczego nie użyć sugerowanej metody z pytania kolergy ' ego do uzyskania wartości:

def getFromDict(dataDict, mapList):    
    for k in mapList: dataDict = dataDict[k]
    return dataDict

I kod z odpowiedzi @eafit do ustawiania wartości:

def nested_set(dic, keys, value):
    for key in keys[:-1]:
        dic = dic.setdefault(key, {})
    dic[keys[-1]] = value

Oba działają prosto w Pythonie 2 i 3

Użycie reduce jest sprytne, ale metoda set op może mieć problemy, jeśli klucze nadrzędne nie istnieją wcześniej w zagnieżdżonym słowniku. Ponieważ jest to pierwszy tak post widziałem na ten temat w mojej wyszukiwarce google, chciałbym, aby to nieco lepiej.

Metoda set in ( Ustawianie wartości w zagnieżdżonym słowniku Pythona z listą indeksów i wartością) wydaje się bardziej odporna na brak kluczy rodzicielskich. Do skopiowania:

def nested_set(dic, keys, value):
    for key in keys[:-1]:
        dic = dic.setdefault(key, {})
    dic[keys[-1]] = value

Również, może być wygodne, aby mieć metodę to przemierza drzewo kluczy i uzyskuje wszystkie bezwzględne ścieżki kluczowe, dla których utworzyłem:

def keysInDict(dataDict, parent=[]):
    if not isinstance(dataDict, dict):
        return [tuple(parent)]
    else:
        return reduce(list.__add__, 
            [keysInDict(v,parent+[k]) for k,v in dataDict.items()], [])

Jednym z jego zastosowań jest konwersja zagnieżdżonego drzewa na ramkę danych pandy, używając następującego kodu (zakładając, że wszystkie liście w zagnieżdżonym słowniku mają tę samą głębokość).

def dict_to_df(dataDict):
    ret = []
    for k in keysInDict(dataDict):
        v = np.array( getFromDict(dataDict, k), )
        v = pd.DataFrame(v)
        v.columns = pd.MultiIndex.from_product(list(k) + [v.columns])
        ret.append(v)
    return reduce(pd.DataFrame.join, ret)

Ta biblioteka może być pomocna: https://github.com/akesterson/dpath-python

Biblioteka Pythona umożliwiająca dostęp i wyszukiwanie słowników poprzez / slashed / paths ala xpath

Zasadniczo pozwala przeglądać słownik tak, jakby był system plików.

Zamiast wykonywać hit za każdym razem, gdy chcesz wyszukać wartość, co powiesz na spłaszczenie słownika raz, a następnie po prostu poszukaj klucza jak b:v:y

def flatten(mydict):
  new_dict = {}
  for key,value in mydict.items():
    if type(value) == dict:
      _dict = {':'.join([key, _key]):_value for _key, _value in flatten(value).items()}
      new_dict.update(_dict)
    else:
      new_dict[key]=value
  return new_dict

dataDict = {
"a":{
    "r": 1,
    "s": 2,
    "t": 3
    },
"b":{
    "u": 1,
    "v": {
        "x": 1,
        "y": 2,
        "z": 3
    },
    "w": 3
    }
}    

flat_dict = flatten(dataDict)
print flat_dict
{'b:w': 3, 'b:u': 1, 'b:v:y': 2, 'b:v:x': 1, 'b:v:z': 3, 'a:r': 1, 'a:s': 2, 'a:t': 3}

W ten sposób możesz po prostu wyszukać przedmioty za pomocą flat_dict['b:v:y'], co da ci 1.

I zamiast przemierzać słownik przy każdym wyszukiwaniu, możesz być w stanie przyspieszyć to, spłaszczając słownik i zapisując wyjście, aby wyszukiwanie od zimnego startu oznaczało załadowanie spłaszczonego słownika i po prostu wykonując wyszukiwanie klucza / wartości bez przechodzenia.

A może użyjesz funkcji rekurencyjnych?

Aby uzyskać wartość:

def getFromDict(dataDict, maplist):
    first, rest = maplist[0], maplist[1:]

    if rest: 
        # if `rest` is not empty, run the function recursively
        return getFromDict(dataDict[first], rest)
    else:
        return dataDict[first]

I ustawić wartość:

def setInDict(dataDict, maplist, value):
    first, rest = maplist[0], maplist[1:]

    if rest:
        try:
            if not isinstance(dataDict[first], dict):
                # if the key is not a dict, then make it a dict
                dataDict[first] = {}
        except KeyError:
            # if key doesn't exist, create one
            dataDict[first] = {}

        setInDict(dataDict[first], rest, value)
    else:
        dataDict[first] = value

Alternatywny sposób, jeśli nie chcesz zgłaszać błędów, jeśli jeden z kluczy jest nieobecny (aby twój główny kod mógł działać bez przerwy):

def get_value(self,your_dict,*keys):
    curr_dict_ = your_dict
    for k in keys:
        v = curr_dict.get(k,None)
        if v is None:
            break
        if isinstance(v,dict):
            curr_dict = v
    return v

W tym przypadku, jeśli którykolwiek z klawiszy wejściowych nie jest obecny, nie jest zwracany, co może być użyte jako sprawdzenie w kodzie głównym do wykonania alternatywnego zadania.

Może sprawdzić, a następnie ustawić element dict bez dwukrotnego przetwarzania wszystkich indeksów?

Rozwiązanie:

def nested_yield(nested, keys_list):
    """
    Get current nested data by send(None) method. Allows change it to Value by calling send(Value) next time
    :param nested: list or dict of lists or dicts
    :param keys_list: list of indexes/keys
    """
    if not len(keys_list):  # assign to 1st level list
        if isinstance(nested, list):
            while True:
                nested[:] = yield nested
        else:
            raise IndexError('Only lists can take element without key')


    last_key = keys_list.pop()
    for key in keys_list:
        nested = nested[key]

    while True:
        try:
            nested[last_key] = yield nested[last_key]
        except IndexError as e:
            print('no index {} in {}'.format(last_key, nested))
            yield None

Przykładowy przepływ pracy:

ny = nested_yield(nested_dict, nested_address)
data_element = ny.send(None)
if data_element:
    # process element
    ...
else:
    # extend/update nested data
    ny.send(new_data_element)
    ...
ny.close()

Test

>>> cfg= {'Options': [[1,[0]],[2,[4,[8,16]]],[3,[9]]]}
    ny = nested_yield(cfg, ['Options',1,1,1])
    ny.send(None)
[8, 16]
>>> ny.send('Hello!')
'Hello!'
>>> cfg
{'Options': [[1, [0]], [2, [4, 'Hello!']], [3, [9]]]}
>>> ny.close()

Czysty styl Pythona, bez żadnego importu:

def nested_set(element, value, *keys):
    if type(element) is not dict:
        raise AttributeError('nested_set() expects dict as first argument.')
    if len(keys) < 2:
        raise AttributeError('nested_set() expects at least three arguments, not enough given.')

    _keys = keys[:-1]
    _element = element
    for key in _keys:
        _element = _element[key]
    _element[keys[-1]] = value

example = {"foo": { "bar": { "baz": "ok" } } }
keys = ['foo', 'bar']
nested_set(example, "yay", *keys)
print(example)

Wyjście

{'foo': {'bar': 'yay'}}

Rozwiązałem to rekurencją:

def get(d,l):
    if len(l)==1: return d[l[0]]
    return get(d[l[0]],l[1:])

Używając Twojego przykładu:

dataDict = {
    "a":{
        "r": 1,
        "s": 2,
        "t": 3
        },
    "b":{
        "u": 1,
        "v": {
            "x": 1,
            "y": 2,
            "z": 3
        },
        "w": 3
        }
}
maplist1 = ["a", "r"]
maplist2 = ["b", "v", "y"]
print(get(dataDict, maplist1)) # 1
print(get(dataDict, maplist2)) # 2

Jeśli chcesz również pracować z dowolnymi json, w tym zagnieżdżonymi listami i dictami, i ładnie obsługiwać nieprawidłowe ścieżki wyszukiwania, oto moje rozwiązanie:

from functools import reduce


def get_furthest(s, path):
    '''
    Gets the furthest value along a given key path in a subscriptable structure.

    subscriptable, list -> any
    :param s: the subscriptable structure to examine
    :param path: the lookup path to follow
    :return: a tuple of the value at the furthest valid key, and whether the full path is valid
    '''

    def step_key(acc, key):
        s = acc[0]
        if isinstance(s, str):
            return (s, False)
        try:
            return (s[key], acc[1])
        except LookupError:
            return (s, False)

    return reduce(step_key, path, (s, True))


def get_val(s, path):
    val, successful = get_furthest(s, path)
    if successful:
        return val
    else:
        raise LookupError('Invalid lookup path: {}'.format(path))


def set_val(s, path, value):
    get_val(s, path[:-1])[path[-1]] = value