analizowania JSON i poszukiwania przez niego

Question

Mam ten kod

import json 
from pprint import pprint 
json_data=open('bookmarks.json') 
jdata = json.load(json_data) 
pprint (jdata) 
json_data.close() 

Jak mogę przeglądać go za u'uri': u'http:?

Answer 1

Jak json.loads prostu zwraca dict, możesz użyć operatorów, które odnoszą się do dicts:

>>> jdata = json.load('{"uri": "http:", "foo", "bar"}') 
>>> 'uri' in jdata  # Check if 'uri' is in jdata's keys 
True 
>>> jdata['uri']   # Will return the value belonging to the key 'uri' 
u'http:' 

Edycja: aby dać wyobrażenie o wpływie do pętli poprzez dane, rozważmy następujący przykład:

>>> import json 
>>> jdata = json.loads(open ('bookmarks.json').read()) 
>>> for c in jdata['children'][0]['children']: 
...  print 'Title: {}, URI: {}'.format(c.get('title', 'No title'), 
              c.get('uri', 'No uri')) 
... 
Title: Recently Bookmarked, URI: place:folder=BOOKMARKS_MENU(...) 
Title: Recent Tags, URI: place:sort=14&type=6&maxResults=10&queryType=1 
Title: , URI: No uri 
Title: Mozilla Firefox, URI: No uri 

Sprawdzanie struktury danych w trybie jdata pozwoli na nawigację zgodnie z oczekiwaniami. Wywołanie pprint, które już masz, jest dobrym punktem wyjścia do tego.

Edycja2: Kolejna próba. To dostaje plik, o którym wspomniałeś na liście słowników. W związku z tym uważam, że powinniście być w stanie dostosować go do swoich potrzeb.

>>> def build_structure(data, d=[]): 
...  if 'children' in data: 
...   for c in data['children']: 
...    d.append({'title': c.get('title', 'No title'), 
...          'uri': c.get('uri', None)}) 
...    build_structure(c, d) 
...  return d 
... 
>>> pprint.pprint(build_structure(jdata)) 
[{'title': u'Bookmarks Menu', 'uri': None}, 
{'title': u'Recently Bookmarked', 
    'uri': u'place:folder=BOOKMARKS_MENU&folder=UNFILED_BOOKMARKS&(...)'}, 
{'title': u'Recent Tags', 
    'uri': u'place:sort=14&type=6&maxResults=10&queryType=1'}, 
{'title': u'', 'uri': None}, 
{'title': u'Mozilla Firefox', 'uri': None}, 
{'title': u'Help and Tutorials', 
    'uri': u'http://www.mozilla.com/en-US/firefox/help/'}, 
(...) 
}] 

Aby następnie „poszukiwanie przez nią na u'uri': u'http:'”, zrób coś takiego:

for c in build_structure(jdata): 
    if c['uri'].startswith('http:'): 
     print 'Started with http' 

Answer 2

Można użyć jsonpipe jeśli wystarczy wyjście (i bardziej komfortowo z linii poleceń):

cat bookmarks.json | jsonpipe |grep uri 

Answer 3

ObjectPath jest biblioteka która zapewnia zdolność do zapytań JSON i struktury o zagnieżdżone f dyktanda i listy. Można na przykład wyszukać wszystkie atrybuty o nazwie "foo", niezależnie od tego, jak głębokie są one stosowane, używając $..foo.

Podczas gdy dokumentacja koncentruje się na interfejsie wiersza poleceń, można wykonywać kwerendy programowo za pomocą pakietów wewnętrznych Pythona. Poniższy przykład zakłada, że ​​dane zostały już wczytane do struktur danych Pythona (lista dyktów: &). Jeśli zaczynasz od pliku JSON lub ciągu znaków, musisz najpierw użyć load lub loads z json module.

import objectpath 

data = [ 
    {'foo': 1, 'bar': 'a'}, 
    {'foo': 2, 'bar': 'b'}, 
    {'NoFooHere': 2, 'bar': 'c'}, 
    {'foo': 3, 'bar': 'd'}, 
] 

tree_obj = objectpath.Tree(data) 

tuple(tree_obj.execute('$..foo')) 
# returns: (1, 2, 3) 

Należy zauważyć, że po prostu pominięto elementy pozbawione atrybutu "foo", np. Trzeci element na liście. Możesz także wykonywać znacznie bardziej skomplikowane zapytania, co czyni ObjectPath przydatnym w przypadku struktur głęboko zagnieżdżonych (np. Znajdowanie miejsca, w którym x ma y, który ma: $.x.y.z). Aby uzyskać więcej informacji, odsyłam Cię do documentation i tutorial.

Answer 4

Wydaje się, że jest literówka (brakujący dwukropek) w dykcie JSON dostarczonej przez jro.

Poprawna składnia byłoby: jdata = json.load ('{ "uri": "http:", "foo": "bar"}')

ta straciła gola dla mnie podczas gry z kodem.

Answer 5

Funkcje wyszukiwania i drukowania dictów, takie jak JSON. * wykonany w Pythonie 3

Szukaj:

def pretty_search(dict_or_list, key_to_search, search_for_first_only=False): 
    """ 
    Give it a dict or a list of dicts and a dict key (to get values of), 
    it will search through it and all containing dicts and arrays 
    for all values of dict key you gave, and will return you set of them 
    unless you wont specify search_for_first_only=True 

    :param dict_or_list: 
    :param key_to_search: 
    :param search_for_first_only: 
    :return: 
    """ 
    search_result = set() 
    if isinstance(dict_or_list, dict): 
     for key in dict_or_list: 
      key_value = dict_or_list[key] 
      if key == key_to_search: 
       if search_for_first_only: 
        return key_value 
       else: 
        search_result.add(key_value) 
      if isinstance(key_value, dict) or isinstance(key_value, list) or isinstance(key_value, set): 
       _search_result = pretty_search(key_value, key_to_search, search_for_first_only) 
       if _search_result and search_for_first_only: 
        return _search_result 
       elif _search_result: 
        for result in _search_result: 
         search_result.add(result) 
    elif isinstance(dict_or_list, list) or isinstance(dict_or_list, set): 
     for element in dict_or_list: 
      if isinstance(element, list) or isinstance(element, set) or isinstance(element, dict): 
       _search_result = pretty_search(element, key_to_search, search_result) 
       if _search_result and search_for_first_only: 
        return _search_result 
       elif _search_result: 
        for result in _search_result: 
         search_result.add(result) 
    return search_result if search_result else None 

druku:

def pretty_print(dict_or_list, print_spaces=0): 
    """ 
    Give it a dict key (to get values of), 
    it will return you a pretty for print version 
    of a dict or a list of dicts you gave. 

    :param dict_or_list: 
    :param print_spaces: 
    :return: 
    """ 
    pretty_text = "" 
    if isinstance(dict_or_list, dict): 
     for key in dict_or_list: 
      key_value = dict_or_list[key] 
      if isinstance(key_value, dict): 
       key_value = pretty_print(key_value, print_spaces + 1) 
       pretty_text += "\t" * print_spaces + "{}:\n{}\n".format(key, key_value) 
      elif isinstance(key_value, list) or isinstance(key_value, set): 
       pretty_text += "\t" * print_spaces + "{}:\n".format(key) 
       for element in key_value: 
        if isinstance(element, dict) or isinstance(element, list) or isinstance(element, set): 
         pretty_text += pretty_print(element, print_spaces + 1) 
        else: 
         pretty_text += "\t" * (print_spaces + 1) + "{}\n".format(element) 
      else: 
       pretty_text += "\t" * print_spaces + "{}: {}\n".format(key, key_value) 
    elif isinstance(dict_or_list, list) or isinstance(dict_or_list, set): 
     for element in dict_or_list: 
      if isinstance(element, dict) or isinstance(element, list) or isinstance(element, set): 
       pretty_text += pretty_print(element, print_spaces + 1) 
      else: 
       pretty_text += "\t" * print_spaces + "{}\n".format(element) 
    else: 
     pretty_text += str(dict_or_list) 
    if print_spaces == 0: 
     print(pretty_text) 
    return pretty_text