Jolie impression JSON dumps

J'utilise ce code pour la jolie imprimer un dict en JSON:

import json
d = {'a': 'blah', 'b': 'foo', 'c': [1,2,3]}
print json.dumps(d, indent = 2, separators=(',', ': '))

De sortie:

{
  "a": "blah",
  "c": [
    1,
    2,
    3
  ],
  "b": "foo"
}

C'est un peu trop (retour à la ligne pour chaque élément de la liste!).

Qui la syntaxe dois-je utiliser pour avoir ceci:

{
  "a": "blah",
  "c": [1, 2, 3],
  "b": "foo"
}

à la place?

Ce n'est pas exactement la réponse à votre question, mais si vous êtes simplement à la recherche d'un format de données qui est facile sur les yeux, vous pouvez essayer de YAML. Il existe deux syntaxes pour les collections, tout comme les listes et les dictionnaires, "block" (où l'indentation montre l'imbrication) et de "flux" (où les crochets de faire ce travail). Par défaut, la sortie de PyYAML utilise des "flux" de la syntaxe pour les listes et les dictionnaires qui ne contiennent pas d'autres conteneurs, ce qui sonne comme exactement ce que vous voulez pour votre jolie impression.
Merci @Blckknght. Est YAML mature/stable/portable et devraient être disponibles dans les années à venir/les futures versions de python? Est-ce que ça va être une norme? (désolé pour toutes ces questions 😉 )
Une autre remarque: je voulais éviter de conversion en chaîne de caractères, parce que quand je load mon fichier JSON dans un dict, si c'est une chaîne, je n'ai pas accès à la list (ou j'en aurais besoin pour analyser la chaîne dans la liste, mais c'est une honte d'avoir à le faire ...)
Il doit bien y avoir un moyen de le faire en sous-classement json.JSONEncoder, mais je n'ai pas pensé à elle.
Je ne suis pas vraiment un YAML expert, mais ma compréhension est qu'il est assez stable et mature, bien que pas aussi largement utilisé comme JSON. Vous pouvez trouver ses normes dans le le site officiel YAML, si le Wikipédia, semble tout à fait un peu mieux à donner un aperçu. JSON est un sous-ensemble de la dernière version de YAML (et les incompatibilités avec les anciennes YAML versions étaient apparemment rarement rencontré).
C'est l'affichage des lists la seule mise en forme que vous souhaitez personnaliser (par rapport à la table dans la documentation montrant l'defualt Python les types intégrés dans json.JSONEncoder classe poignées)?
oui list est la seule mise en forme je veux personnaliser
Ce qui doit arriver, l'indentation-sage, si la liste contient un dictionnaire ou d'une autre liste, etc?
les deux solutions serait bien pour moi (c'est à dire de nouvelles lignes pour chaque sous-liste de la liste, ou pas de nouvelle ligne à tous)
AFAICT il n'y a pas un moyen raisonnable de faire cela avec le haut- JSONEncoder classe directement ou sous-classement, ou même d'un singe, il correctifs qui réponde à vos besoins. Ainsi, vous aurez probablement besoin d'écrire votre propre, comme @Shan Valleru suggère.
json n'est pas le seul module qui permet de gérer cela pour vous. Peut-être il ya une raison, ce n'était pas mentionné, j'avoue que je ne suis pas un python gars. docs.python.org/3.2/library/pprint.html#module-pprint

InformationsquelleAutor Basj | 2014-02-18

7

Écrire votre propre sérialiseur JSON:
```
import numpy
INDENT = 3
SPACE = " "
NEWLINE = "\n"
def to_json(o, level=0):
ret = ""
if isinstance(o, dict):
ret += "{" + NEWLINE
comma = ""
for k,v in o.iteritems():
ret += comma
comma = ",\n"
ret += SPACE * INDENT * (level+1)
ret += '"' + str(k) + '":' + SPACE
ret += to_json(v, level + 1)
ret += NEWLINE + SPACE * INDENT * level + "}"
elif isinstance(o, basestring):
ret += '"' + o + '"'
elif isinstance(o, list):
ret += "[" + ",".join([to_json(e, level+1) for e in o]) + "]"
elif isinstance(o, bool):
ret += "true" if o else "false"
elif isinstance(o, int):
ret += str(o)
elif isinstance(o, float):
ret += '%.7g' % o
elif isinstance(o, numpy.ndarray) and numpy.issubdtype(o.dtype, numpy.integer):
ret += "[" + ','.join(map(str, o.flatten().tolist())) + "]"
elif isinstance(o, numpy.ndarray) and numpy.issubdtype(o.dtype, numpy.inexact):
ret += "[" + ','.join(map(lambda x: '%.7g' % x, o.flatten().tolist())) + "]"
else:
raise TypeError("Unknown type '%s' for json serialization" % str(type(o)))
return ret
inputJson = {'a': 'blah', 'b': 'foo', 'c': [1,2,3]}
print to_json(inputJson)
```
De sortie:
```
{
"a": "blah",
"c": [1,2,3],
"b": "foo"
}
```
- Est-ce vraiment si compliqué? Wow
- Je m'attendais à environ 10 lignes. Je suppose que Haskell m'a gâtée!!!
- Merci @ShanValleru! +1, mais d'avoir à réécrire tout le sérialiseur me semble un peu compliqué... j'imagine qu'il y a peut-être une version plus facile?
- Seulement deux façons que je connais sont: écrivez votre propre sérialiseur comme ci-dessus ou sous-classe et de personnaliser JSON codeur lui-même (comme indiqué dans le docs.python.org/2/library/json.html) qui, je crois, serait de plus en plus douloureux que le premier !
- Tellement vrai. Sous-classement JSONEncoder est une bonne approche pour la sérialisation des objets et de types de ne pas support de par défaut - mais pas tellement pour annuler la façon dont il traite ceux il ne.
- Votre sérialiseur semble fonctionner assez bien, même s'il est probablement devrait également convertir Nones en 'null's.
- N'étant pas un python gars (et ne cherche pas à créer le désordre ici) pourquoi ne pas l'OP ou toutes les réponses suggèrent d'utiliser pprint.PrettyPrinter?
- Je 'pense' pprint seulement vous permet de personnaliser le tiret, de la largeur & profondeur, et non pas les choses comme quand à cracher de la nouvelle ligne etc.; d'où la coutume de sérialiseur.
- pourquoi avez-vous choisi '"' + o + '"' au lieu de repr(o)? ne serait-il pas de se briser si le str contenir "?
- de préférence personnelle, je suppose 😉
- ah, j'ai oublié que json besoin de guillemets doubles et la plupart du temps repr retour apostrophe, mais ce que j'ai dit est toujours debout. par exemple: to_json({'test':'"'}) > '{\n "test": """\n}'
InformationsquelleAutor Shan Valleru

J'ai fini par utiliser jsbeautifier:

import jsbeautifier
opts = jsbeautifier.default_options()
opts.indent_size = 2
jsbeautifier.beautify(json.dumps(d), opts)

De sortie:

{
  "a": "blah",
  "c": [1, 2, 3],
  "b": "foo"
}

InformationsquelleAutor Allen Z.

3

Une autre alternative est print json.dumps(d, indent = None, separators=(',\n', ': '))

La sortie sera:
```
{"a": "blah",
"c": [1,
2,
3],
"b": "foo"}
```
Notez que bien que les docs officielles à https://docs.python.org/2.7/library/json.html#basic-usage dire la valeur par défaut arguments sont separators=None --qui signifie en fait "utiliser la valeur par défaut de separators=(', ',': ') ). Notez également que la virgule de séparation ne fait pas la distinction entre k/v paires et les éléments de la liste.
- Merci mais ce n'est pas exactement ce qui était nécessaire; nous aimerions avoir [1, 2, 3] en une seule ligne au lieu
- Droit, il n'est pas parfait, mais il est maigre et moyenne par rapport aux autres monstruosités. 😉 Si j'allais obtenir la fantaisie, j'utilise pypi.python.org/pypi/jq
- Tnx pour les séparateurs, m'a aidé pour lua de compatibilité. En lua aucun espace n'est autorisé.
InformationsquelleAutor MarkHu

Peut-être pas tout à fait aussi efficace, mais considérer un cas plus simple (un peu testé en Python 3, mais probablement de travail en Python 2):

def dictJSONdumps( obj, levels, indentlevels = 0 ):
import json
if isinstance( obj, dict ):
res = []
for ix in sorted( obj, key=lambda x: str( x )):
temp = ' ' * indentlevels + json.dumps( ix, ensure_ascii=False ) + ': '
if levels:
temp += dictJSONdumps( obj[ ix ], levels-1, indentlevels+1 )
else:
temp += json.dumps( obj[ ix ], ensure_ascii=False )
res.append( temp )
return '{\n' + ',\n'.join( res ) + '\n}'
else:
return json.dumps( obj, ensure_ascii=False )

Cela pourrait vous donner quelques idées, bref de la rédaction de votre propre sérialiseur complètement. J'ai utilisé mon propre favori tiret technique, et codée en dur ensure_ascii, mais vous pouvez ajouter des paramètres et de les transmettre, ou votre propre code, etc.

InformationsquelleAutor Victoria

0

Ce qui a été m'énerve pour un certain temps en tant que bien, j'ai trouvé un 1 liner, je suis presque heureux avec:
```
print json.dumps(eval(str(d).replace('[', '"[').replace(']', ']"').replace('(', '"(').replace(')', ')"')), indent=2).replace('\"\\"[', '[').replace(']\\"\"', ']').replace('\"\\"(', '(').replace(')\\"\"', ')')
```
Que l'essentiel de convertir toutes les listes ou les tuples d'une chaîne de caractères, puis utilise json.dumps avec tiret pour formater le dict. Ensuite, vous avez juste besoin d'enlever les guillemets, et vous avez terminé!

Remarque: - je convertir le dict de la chaîne de convertir facilement toutes les listes et les tuples n'importe comment imbriqués les dict est.

PS. J'espère que le Python de la Police ne viendra pas après moi pour l'utilisation de eval... (à utiliser avec précaution)

InformationsquelleAutor Tickon

Vous devez vous connecter pour publier un commentaire.