Xpath come query per dizionari python nidificati

Question

C'è un modo per definire una query di tipo XPath per i dizionari python nidificati.

Qualcosa di simile a questo:

foo = { 
    'spam':'eggs', 
    'morefoo': { 
       'bar':'soap', 
       'morebar': {'bacon' : 'foobar'} 
       } 
    } 

print(foo.select("/morefoo/morebar")) 

>> {'bacon' : 'foobar'} 

Ho anche bisogno di selezionare liste annidate;)

Questo può essere fatto facilmente con la soluzione @ di Jellybean:

def xpath_get(mydict, path): 
    elem = mydict 
    try: 
     for x in path.strip("/").split("/"): 
      try: 
       x = int(x) 
       elem = elem[x] 
      except ValueError: 
       elem = elem.get(x) 
    except: 
     pass 

    return elem 

foo = { 
    'spam':'eggs', 
    'morefoo': [{ 
       'bar':'soap', 
       'morebar': { 
          'bacon' : { 
             'bla':'balbla' 
            } 
          } 
       }, 
       'bla' 
       ] 
    } 

print xpath_get(foo, "/morefoo/0/morebar/bacon") 

[EDIT 2016] Questo domanda e la risposta accettata sono antiche. Le risposte più recenti possono fare il lavoro meglio della risposta originale. Tuttavia non li ho testati, quindi non cambierò la risposta accettata.

Answer 1

Non esattamente bella, ma è possibile utilizzare STH come

def xpath_get(mydict, path): 
    elem = mydict 
    try: 
     for x in path.strip("/").split("/"): 
      elem = elem.get(x) 
    except: 
     pass 

    return elem 

Questo non supporta roba XPath come indici, naturalmente ... per non parlare del / chiave unutbu trappola indicato.

Answer 2

Più lavoro dovrebbe essere messo in come il selettore tipo XPath avrebbe funzionato. '/' è una chiave di dizionario valida, così come sarebbe

foo={'/':{'/':'eggs'},'//':'ham'} 

essere gestiti?

foo.select("///") 

sarebbe ambiguo.

Answer 3

C'è qualche motivo per voi per interrogarlo come il modello XPath? Come ha suggerito il commentatore alla tua domanda, è solo un dizionario, quindi puoi accedere agli elementi in modo nido. Inoltre, considerando che i dati sono sotto forma di JSON, è possibile utilizzare il modulo simplejson per caricarlo e accedere anche agli elementi.

C'è questo progetto JSONPATH, che sta cercando di aiutare le persone a fare il contrario di ciò che si intende fare (dato un XPATH, come renderlo facilmente accessibile tramite oggetti python), che sembra più utile.

Answer 4

Un'altra alternativa (oltre a quello suggerito da jellybean) è questo:

def querydict(d, q): 
    keys = q.split('/') 
    nd = d 
    for k in keys: 
    if k == '': 
     continue 
    if k in nd: 
     nd = nd[k] 
    else: 
     return None 
    return nd 

foo = { 
    'spam':'eggs', 
    'morefoo': { 
       'bar':'soap', 
       'morebar': {'bacon' : 'foobar'} 
       } 
    } 
print querydict(foo, "/morefoo/morebar") 

Answer 5

C'è un modo più semplice per farlo ora.

http://github.com/akesterson/dpath-python

$ easy_install dpath 
>>> dpath.util.search(YOUR_DICTIONARY, "morefoo/morebar") 

... fatto. O se non vi piace ottenere i risultati di nuovo in una vista (dizionario fusione che mantiene i percorsi), cederli invece:

$ easy_install dpath 
>>> for (path, value) in dpath.util.search(YOUR_DICTIONARY, "morefoo/morebar", yielded=True) 

... e fatto. 'valore' terrà {'bacon': 'foobar'} in quel caso.

Answer 6

V'è la più recente libreria jsonpath-rw sostenere una sintassi JSONPATH ma per Python dizionari e array, come si voleva.

Così il vostro primo esempio diventa:

from jsonpath_rw import parse 

print(parse('$.morefoo.morebar').find(foo)) 

E il secondo:

print(parse("$.morefoo[0].morebar.bacon").find(foo)) 

---

PS: Una libreria semplice alternativa anche sostenendo dizionari è python-json-pointer con una maggiore XPath simile sintassi.

Answer 7

Una delle migliori librerie che sono stato in grado di identificare, che, inoltre, è stata sviluppata molto attivamente, è un progetto estratto da boto: JMESPath. Ha una sintassi molto potente di fare cose che normalmente richiedono pagine di codice da esprimere.

ecco alcuni esempi:

search('foo | bar', {"foo": {"bar": "baz"}}) -> "baz" 
search('foo[*].bar | [0]', { 
    "foo": [{"bar": ["first1", "second1"]}, 
      {"bar": ["first2", "second2"]}]}) -> ["first1", "second1"] 
search('foo | [0]', {"foo": [0, 1, 2]}) -> [0] 

Answer 8

Se concisione è la vostra fantasia:

def xpath(root, path, sch='/'): 
    return reduce(lambda acc, nxt: acc[nxt], 
        [int(x) if x.isdigit() else x for x in path.split(sch)], 
        root) 

Naturalmente, se si solo avere dicts, allora è semplice:

def xpath(root, path, sch='/'): 
    return reduce(lambda acc, nxt: acc[nxt], 
        path.split(sch), 
        root) 

Buona fortuna a trovare eventuali errori nel tuo percorso spec tho ;-)