bien qu'il y ait quelques bonnes réponses ici, j'ai fini par utiliser PyYAML pour analyser mes fichiers JSON, car il donne les clés et les valeurs comme str Type chaînes au lieu de unicode type. Parce que JSON est un sous-ensemble de YAML il fonctionne bien:

>>> import json
>>> import yaml
>>> list_org = ['a', 'b']
>>> list_dump = json.dumps(list_org)
>>> list_dump
'["a", "b"]'
>>> json.loads(list_dump)
[u'a', u'b']
>>> yaml.safe_load(list_dump)
['a', 'b']

Notes

certaines choses à noter cependant:

• je reçois objets string parce que tous les mes entrées sont ASCII codé . Si j'utilisais des entrées codées unicode, je les récupérerais en objets unicode - il n'y a pas de conversion!

• vous devriez (probablement toujours) utiliser la fonction safe_load de PyYAML; si vous l'utilisez pour charger des fichiers JSON, vous n'avez pas besoin de la "puissance supplémentaire" de la fonction load de toute façon.

• si vous voulez un YAML parser qui a plus de soutien pour la version 1.2 de la spec (et correctement parses très bas nombres ) try Ruamel YAML : pip install ruamel.yaml et import ruamel.yaml as yaml était tout ce dont j'avais besoin dans mes tests.

Conversion

comme indiqué, il n'y a pas de conversion! Si vous ne pouvez pas être sûr de ne traiter que les valeurs ASCII( et vous ne pouvez pas être sûr la plupart du temps), utilisez plutôt une conversion fonction :

j'ai utilisé celle de Marque Amery une couple de fois maintenant, il fonctionne très bien et est très facile à utiliser. Vous pouvez également utiliser une fonction similaire comme un object_hook à la place, car il pourrait vous gagner un boost de performance sur les gros fichiers. Voir la réponse un peu plus impliquée de Mirec Miskuf pour cela.

il n'y a pas d'option intégrée pour que les fonctions du module json renvoient des chaînes d'octets au lieu des chaînes unicode. Cependant, cette fonction recursive simple et courte convertira n'importe quel objet JSON décodé en utilisant des chaînes unicode en chaînes Byte encodées en UTF-8:

def byteify(input):
    if isinstance(input, dict):
        return {byteify(key): byteify(value)
                for key, value in input.iteritems()}
    elif isinstance(input, list):
        return [byteify(element) for element in input]
    elif isinstance(input, unicode):
        return input.encode('utf-8')
    else:
        return input

il suffit de l'appeler sur la sortie que vous obtenez à partir d'un appel json.load ou json.loads .

quelques notes:

• pour supporter Python 2.6 ou plus tôt, remplacer return {byteify(key): byteify(value) for key, value in input.iteritems()} par return dict([(byteify(key), byteify(value)) for key, value in input.iteritems()]) , car les interprétations de dictionnaires n'étaient pas supportées avant Python 2.7.
• puisque cette réponse revient à travers tout l'objet décodé, elle présente quelques caractéristiques de performance indésirables qui peuvent être évitées en utilisant très soigneusement les paramètres object_hook ou object_pairs_hook . la réponse de Mirec Miskuf est jusqu'à présent la seule qui réussit à tirer cela correctement, bien que comme un la conséquence, c'est beaucoup plus compliqué que mon approche.

vous pouvez utiliser le paramètre object_hook pour json.loads pour passer dans un convertisseur. Vous n'avez pas à faire la conversion après le fait. Le module json passera toujours les dicts object_hook seulement, et il passera récursivement dans les dicts imbriqués, de sorte que vous n'avez pas à revenir dans les dicts imbriqués vous-même. Je ne pense pas que je convertirais les chaînes unicode en nombres comme Wells montre. Si c'est une chaîne unicode, elle a été citée comme une chaîne de caractères dans le fichier JSON, donc c'est censé être une chaîne de caractères (ou le fichier est mauvais).

aussi, j'essaierais d'éviter de faire quelque chose comme str(val) sur un objet unicode . Vous devez utiliser value.encode(encoding) avec un encodage valide, en fonction de ce que votre lib externe attend.

ainsi, par exemple:

def _decode_list(data):
    rv = []
    for item in data:
        if isinstance(item, unicode):
            item = item.encode('utf-8')
        elif isinstance(item, list):
            item = _decode_list(item)
        elif isinstance(item, dict):
            item = _decode_dict(item)
        rv.append(item)
    return rv

def _decode_dict(data):
    rv = {}
    for key, value in data.iteritems():
        if isinstance(key, unicode):
            key = key.encode('utf-8')
        if isinstance(value, unicode):
            value = value.encode('utf-8')
        elif isinstance(value, list):
            value = _decode_list(value)
        elif isinstance(value, dict):
            value = _decode_dict(value)
        rv[key] = value
    return rv

obj = json.loads(s, object_hook=_decode_dict)

c'est parce que json n'a pas de différence entre les objets string et les objets unicode. Ce sont des chaînes en javascript.

je pense JSON est en droit de retour des objets unicode . En fait, je n'accepterais rien de moins, puisque les chaînes javascript sont en fait unicode objets (c.-à-d. JSON (javascript) chaînes peuvent stocker toute sorte de caractère unicode) il est donc logique de créer unicode objets lors de la traduction des chaînes de JSON. Les chaînes simples ne conviennent pas puisque la bibliothèque doit deviner l'encodage que vous voulez.

Il est préférable d'utiliser des unicode chaîne des objets partout. Donc votre meilleure option est de mettre à jour vos bibliothèques pour qu'elles puissent traiter des objets unicode.

mais si vous voulez vraiment bytestrings, il suffit de coder les résultats à l'encodage de votre choix:

>>> nl = json.loads(js)
>>> nl
[u'a', u'b']
>>> nl = [s.encode('utf-8') for s in nl]
>>> nl
['a', 'b']

Il existe un travail facile.

TL; DR-utiliser ast.literal_eval() au lieu de json.loads() . Les deux ast et json sont dans la bibliothèque standard.

bien que ce ne soit pas une réponse "parfaite", elle va assez loin si votre plan est d'ignorer Unicode tout à fait. En Python 2.7

import json, ast
d = { 'field' : 'value' }
print "JSON Fail: ", json.loads(json.dumps(d))
print "AST Win:", ast.literal_eval(json.dumps(d))

donne:

JSON Fail:  {u'field': u'value'}
AST Win: {'field': 'value'}

cela devient plus difficile quand certains objets sont vraiment des chaînes Unicode. Le la réponse complète devient vite velue.

je crains qu'il n'y ait aucun moyen de réaliser cela automatiquement dans la bibliothèque simplejson.

le scanner et le décodeur en simplejson sont conçus pour produire du texte unicode. Pour ce faire, la bibliothèque utilise une fonction appelée c_scanstring (si elle est disponible, pour la vitesse), ou py_scanstring si la version C n'est pas disponible. La fonction scanstring est appelée plusieurs fois par presque chaque routine que simplejson a pour décoder une structure qui pourrait contenir du texte. Vous devez soit surveiller la valeur scanstring dans simplejson.décodeur ,ou sous-classe JSONDecoder et de fournir à peu près votre propre mise en œuvre complète de tout ce qui pourrait contenir du texte.

la raison pour laquelle simplejson produit unicode, cependant, est que le JSON spec mentionne spécifiquement que"une chaîne est une collection de zéro ou plus caractères Unicode"... le support d'unicode est supposé faire partie du format lui-même. Simplejson de l' L'implémentation scanstring va jusqu'à scanner et interpréter les échappées d'unicode (même en vérifiant les erreurs pour les représentations de charset multi-octets mal formées), de sorte que la seule façon fiable de vous retourner la valeur est en unicode.

si vous avez une vieille bibliothèque qui a besoin d'un str , je vous recommande soit laborieusement rechercher la structure de données imbriquée après analyse (ce que je reconnais est ce que vous avez explicitement dit que vous vouliez éviter... désolé), ou peut-être envelopper votre bibliothèques dans une sorte de façade où vous pouvez masser les paramètres d'entrée à un niveau plus granulaire. La deuxième approche pourrait être plus facile à gérer que la première si vos structures de données sont en effet profondément imbriquées.

la réponse de Mike Brennan est proche, mais il n'y a aucune raison de traverser à nouveau toute la structure. Si vous utilisez object_hook_pairs (Python 2.7+) paramètre:

object_pairs_hook est une fonction optionnelle qui sera appelée avec le résultat de n'importe quel objet littéral décodé avec une liste ordonnée de paires. La valeur de retour de object_pairs_hook sera utilisé à la place du dict . Cette fonctionnalité peut être utilisée pour implémenter des décodeurs qui reposent sur l'ordre que les paires clé-valeur sont décodés (par exemple, collections.OrderedDict se souviendra de l'ordre d'insertion). Si object_hook est également défini, le object_pairs_hook a priorité.

avec elle, vous obtenez chaque objet JSON remis à vous, de sorte que vous pouvez faire le décodage sans besoin de recursion:

def deunicodify_hook(pairs):
    new_pairs = []
    for key, value in pairs:
        if isinstance(value, unicode):
            value = value.encode('utf-8')
        if isinstance(key, unicode):
            key = key.encode('utf-8')
        new_pairs.append((key, value))
    return dict(new_pairs)

In [52]: open('test.json').read()
Out[52]: '{"1": "hello", "abc": [1, 2, 3], "def": {"hi": "mom"}, "boo": [1, "hi", "moo", {"5": "some"}]}'                                        

In [53]: json.load(open('test.json'))
Out[53]: 
{u'1': u'hello',
 u'abc': [1, 2, 3],
 u'boo': [1, u'hi', u'moo', {u'5': u'some'}],
 u'def': {u'hi': u'mom'}}

In [54]: json.load(open('test.json'), object_pairs_hook=deunicodify_hook)
Out[54]: 
{'1': 'hello',
 'abc': [1, 2, 3],
 'boo': [1, 'hi', 'moo', {'5': 'some'}],
 'def': {'hi': 'mom'}}

notez que je n'ai jamais à appeler le crochet récursivement puisque chaque objet sera remis au crochet lorsque vous utilisez le object_pairs_hook . Vous devez vous soucier des listes, mais comme vous pouvez le voir, un objet à l'intérieur d'une liste sera correctement converti, et vous n'avez pas à recommencer pour le faire se produire.

EDIT: un collaborateur a souligné que Python2.6 n'a pas object_hook_pairs . Vous pouvez toujours utiliser ce sera Python2.6 en faisant un très petit changement. Dans le crochet ci-dessus, changer:

for key, value in pairs:

à

for key, value in pairs.iteritems():

puis utiliser object_hook au lieu de object_pairs_hook :

In [66]: json.load(open('test.json'), object_hook=deunicodify_hook)
Out[66]: 
{'1': 'hello',
 'abc': [1, 2, 3],
 'boo': [1, 'hi', 'moo', {'5': 'some'}],
 'def': {'hi': 'mom'}}

L'utilisation de object_pairs_hook résulte en un dictionnaire de moins étant instancié pour chaque objet dans l'objet JSON, qui, si vous parsiez un document énorme, pourrait être utile pendant.

comme marque (Amery) note correctement: L'utilisation de PyYaml 's deserializer sur un dump JSON ne fonctionne que si vous avez ASCII seulement. Au moins hors de la boîte.

deux rapides commentaires sur L'approche PyYaml:

1. jamais utilisez yaml.charge sur les données du champ. Sa fonctionnalité(!) de yaml pour exécuter du code arbitraire caché dans la structure.

2. Vous peut faire fonctionner aussi pour les non ASCII via ceci:

   def to_utf8(loader, node):
       return loader.construct_scalar(node).encode('utf-8')
   yaml.add_constructor(u'tag:yaml.org,2002:str', to_utf8)
   

mais la performance sage De aucune comparaison à la réponse de Mark Amery:

jetant quelques dicts échantillons profondément emboîtés sur les deux méthodes, j'obtiens ceci (avec dt[j] = delta de temps de JSON.charges(json.dumps (m)):

     dt[yaml.safe_load(json.dumps(m))] =~ 100 * dt[j]
     dt[byteify recursion(Mark Amery)] =~   5 * dt[j]

ainsi désérialisation y compris la marche complète de l'arbre et Encodage , bien dans l'ordre de grandeur de l'implémentation basée sur le C. Je trouve cela remarquablement rapide et son aussi plus robuste que la charge yaml à des structures profondément imbriquées. Et moins d'erreurs de sécurité, en regardant yaml.charge.

= > alors que j'apprécierais un pointeur vers un convertisseur C uniquement basé la fonction byteify devrait être la réponse par défaut.

Cela est particulièrement vrai si votre structure json est depuis le champ, contenant les entrées de l'utilisateur. Parce qu'alors vous avez probablement besoin de marcher de toute façon sur votre structure - indépendant sur vos structures de données internes désirées ("sandwich unicode" ou chaînes byte seulement).

pourquoi?

Unicode normalisation "de la 151940920" . Pour les non-avertis: prendre un analgésique et lire ce .