Xpath comme requête pour les dictionnaires de python imbriqués

Question

est-il un moyen de définir une requête de type XPath pour les dictionnaires de python imbriqués.

Quelque chose comme ceci:

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

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

>> {'bacon' : 'foobar'} 

J'ai aussi besoin de sélectionner des listes imbriquées;)

Cela peut se faire facilement avec la solution de @ 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] Cette question et la réponse acceptée sont anciennes. Les nouvelles réponses peuvent faire le travail mieux que la réponse originale. Cependant, je ne les ai pas testés, donc je ne changerai pas la réponse acceptée.

Answer 1

Pas exactement belle, mais vous pouvez utiliser STH comme

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

    return elem 

Cela ne supporte pas les choses XPath comme indices, bien sûr ... sans oublier le piège clé / unutbu indiqué.

Answer 2

Plus de travail devrait être mis sur la façon dont le sélecteur comme XPath fonctionnerait. '/' est une clé de dictionnaire valide, alors comment serait

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

être traitées?

foo.select("///") 

est ambigu.

Answer 3

Y at-il une raison quelconque pour vous à la requête, il la manière comme le modèle XPath? En tant que commentateur à votre question suggère, juste un dictionnaire, vous pouvez accéder aux éléments de manière nid. En outre, étant donné que les données sont sous forme de JSON, vous pouvez utiliser le module simplejson pour le charger et accéder aux éléments aussi.

Il ya ce projet JSONPATH, qui essaie d'aider les gens à faire l'inverse de ce que vous avez l'intention de faire (donné un XPATH, comment le rendre facilement accessible via des objets python), ce qui semble plus utile.

Answer 4

Une autre alternative (en plus de celle proposée par jellybean) est la suivante:

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

Il y a un moyen plus facile de le faire maintenant.

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

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

... fait. Ou si vous ne l'aimez pas obtenir vos résultats en arrière dans une vue (dictionnaire fusionné qui conserve les chemins), les céder à la place:

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

... et fait. « Valeur » tiendra { « lard »: « foobar »} dans ce cas.

Answer 6

Il est la plus récente jsonpath-rw bibliothèque supportant une syntaxe JSONPATH mais pour python dictionnaires et tableaux, comme vous le souhaitiez.

Ainsi, votre 1er exemple devient:

from jsonpath_rw import parse 

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

Et le 2ème:

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

---

PS: Une alternative bibliothèque plus simple supportant également des dictionnaires est python-json-pointer avec un plus semblable à XPath syntaxe.

Answer 7

L'une des meilleures bibliothèques que j'ai pu identifier, qui, de plus, est très activement développée, est un projet extrait de boto: JMESPath. Il a une syntaxe très puissante de faire des choses qui prendraient normalement des pages de code à exprimer.

Voici quelques exemples:

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

Si laconisme est votre fantaisie:

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) 

Bien sûr, si vous que ont dicts, il est plus simple:

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

Bonne chance pour trouver les erreurs dans votre chemin spec tho ;-)