Python décode JSON

J'ai le json suivants:

{
    "slate" : {
        "id" : {
            "type" : "integer"
        },
        "name" : {
            "type" : "string"
        },
        "code" : {
            "type" : "integer",
            "fk" : "banned.id"
        }
    },
    "banned" : {
        "id" : {
            "type" : "integer"
        },
        "domain" : {
            "type" : "string"
        }
    }
}

J'aimerais comprendre le meilleur décodage de façon à avoir une forme facilement consultable objet python présentation de celui-ci.

J'ai essayé:

import json

jstr = #### my json code above #### 
obj = json.JSONDecoder().decode(jstr)

for o in obj:
  for t in o: 
    print (o)

Mais j'obtiens:

Et je ne comprends pas quel est le problème. L'idéal serait d'avoir un arbre (même une liste organisée dans un arbre que j'ai pu parcourir en quelque sorte comme:

for table in myList:
    for field in table:
         print (field("type"))
         print (field("fk"))

Est le Python intégré dans l'API JSON mesure assez large pour parvenir à cette attente?

OriginalL'auteur CoolStraw | 2011-03-23

10

Vous semblez avoir besoin d'aide itération sur l'objet retourné, ainsi que le décodage JSON.
```
import json

#jstr = "... that thing above ..."
# This line only decodes the JSON into a structure in memory:
obj = json.loads(jstr)
# obj, in this case, is a dictionary, a built-in Python type.

# These lines just iterate over that structure.
for ka, va in obj.iteritems():
    print ka
    for kb, vb in va.iteritems():
        print '  ' + kb
        for key, string in vb.iteritems():
            print '    ' + repr((key, string))
```
Je voudrais orienter clairement de la triple-boucles for imbriquées.
qu'auriez-vous fait à la place de processus par le biais de JSON d'un format connu?
Si vous connaissez les données de structure de référence les clés pour obtenir les valeurs. Dans cet exemple, il utilise un triple imbriqués pour la boucle quand il pourrait simplement dire quelque chose comme : slate_id_type = obj['slate']['id']['type']. Comme nous supposons qu'il utilise ces valeurs pour quelque chose, peut ainsi déclarer leur droit. Beaucoup mieux d'être explicite, de toute façon.
Absolument! Btw, n'oubliez pas de mettre try, except les blocs autour de rattraper tout possible valeur de la clé de ne pas être présent. Découvrez docs.python.org/3.6/library/exceptions.html (changement de 2.7 si vous l'utilisez) pour plus d'options pour les exceptions.

OriginalL'auteur Thanatos
9

Essayer
```
obj = json.loads(jstr)
```
au lieu de
```
obj = json.JSONDecoder(jstr)
```
Ce est la bonne façon de le faire. json.loads() retourne un dictionnaire Python à partir de l'objet JSON.

OriginalL'auteur Sven Marnach
4

L'affaire je suppose que vous vous créez un décodeur, mais ne jamais dire à decode().

Utilisation:
```
o = json.JSONDecoder().decode(jstr)
```
Bon point. Mais: pour o en obj: pour t en o: print(t) s l a t e b a n n e d
Pour votre JSON, Python va retourner un dict (dictionnaire) de l'objet. Par défaut, une itération sur il obtient les clés, qui sont des chaînes de caractères. Une itération sur une chaîne, vous reçoit caractères. Vous pouvez utiliser .iteritems() pour obtenir des tuples de (key, value), ou .itervalues(), pour obtenir des valeurs pour la boucle sur le dictionnaire.
le résultat de decode() est un dictionnaire python. Vous aurez probablement envie de itérateur sur l'o.les éléments(), comme il est vous êtes une itération sur les touches et puis sur les lettres dans les touches

OriginalL'auteur unwind
3

La signature de JSONDecoder est
```
class json.JSONDecoder([encoding[, object_hook[, parse_float[, parse_int[, 
    parse_constant[, strict[, object_pairs_hook]]]]]]])
```
et n'accepte pas la chaîne JSON dans le constructur. Regardez ses decode() la méthode.

http://docs.python.org/library/json.html#json.JSONDecoder

OriginalL'auteur Andreas Jung
2

Cela a bien fonctionné pour moi, et l'impression est plus simple que d'être explicitement en boucle par le biais de l'objet comme dans Thanatos réponse:
```
import json
from pprint import pprint

jstr = #### my json code above #### 
obj = json.loads(jstr)

pprint(obj)
```
Il utilise les "Données Assez d'Imprimante" (pprint) module de, les documents pour lesquels peut être trouvé ici.

OriginalL'auteur Gaffi
1

La Chaîne que vous fournissez dans l'exemple n'est pas valide JSON.

La dernière virgule entre les deux fermeture des accolades est illégal.

De toute façon, vous devez suivre Sven de la suggestion et de l'utilisation des charges à la place.

Je l'ai corrigé. Mais je n'arrive toujours pas à parcourir que j'en attends. Vais mettre à jour ma question

OriginalL'auteur silviot

Vous devez vous connecter pour publier un commentaire.