J'utilise Python 2 pour analyser JSON à partir de fichiers texte encodés ASCII .

Lors du chargement de ces fichiers avec jsonou simplejson, toutes mes valeurs de chaîne sont converties en objets Unicode au lieu d'objets chaîne. Le problème est que je dois utiliser les données avec certaines bibliothèques qui n'acceptent que les objets chaîne. Je ne peux pas changer les bibliothèques ni les mettre à jour.

Est-il possible d'obtenir des objets chaîne au lieu d'objets Unicode?

Exemple

>>> import json
>>> original_list = ['a', 'b']
>>> json_list = json.dumps(original_list)
>>> json_list
'["a", "b"]'
>>> new_list = json.loads(json_list)
>>> new_list
[u'a', u'b']  # I want these to be of type `str`, not `unicode`

Mettre à jour

Cette question a été posée il y a longtemps , lorsque j'étais coincé avec Python 2 . Une solution simple et claire pour aujourd'hui consiste à utiliser une version récente de Python, c'est-à-dire Python 3 et versions ultérieures .

Une solution avec object_hook

import json

def json_load_byteified(file_handle):
    return _byteify(
        json.load(file_handle, object_hook=_byteify),
        ignore_dicts=True
    )

def json_loads_byteified(json_text):
    return _byteify(
        json.loads(json_text, object_hook=_byteify),
        ignore_dicts=True
    )

def _byteify(data, ignore_dicts = False):
    # if this is a unicode string, return its string representation
    if isinstance(data, unicode):
        return data.encode('utf-8')
    # if this is a list of values, return list of byteified values
    if isinstance(data, list):
        return [ _byteify(item, ignore_dicts=True) for item in data ]
    # if this is a dictionary, return dictionary of byteified keys and values
    # but only if we haven't already byteified it
    if isinstance(data, dict) and not ignore_dicts:
        return {
            _byteify(key, ignore_dicts=True): _byteify(value, ignore_dicts=True)
            for key, value in data.iteritems()
        }
    # if it's anything else, return it in its original form
    return data

Exemple d'utilisation:

>>> json_loads_byteified('{"Hello": "World"}')
{'Hello': 'World'}
>>> json_loads_byteified('"I am a top-level string"')
'I am a top-level string'
>>> json_loads_byteified('7')
7
>>> json_loads_byteified('["I am inside a list"]')
['I am inside a list']
>>> json_loads_byteified('[[[[[[[["I am inside a big nest of lists"]]]]]]]]')
[[[[[[[['I am inside a big nest of lists']]]]]]]]
>>> json_loads_byteified('{"foo": "bar", "things": [7, {"qux": "baz", "moo": {"cow": ["milk"]}}]}')
{'things': [7, {'qux': 'baz', 'moo': {'cow': ['milk']}}], 'foo': 'bar'}
>>> json_load_byteified(open('somefile.json'))
{'more json': 'from a file'}

Comment ça marche et pourquoi devrais-je l'utiliser?

La fonction de Mark Amery est plus courte et plus claire que celles-ci, alors quel est leur intérêt? Pourquoi voudriez-vous les utiliser?

Purement pour la performance . La réponse de Mark décode le texte JSON entièrement en premier avec des chaînes unicode, puis revient dans toute la valeur décodée pour convertir toutes les chaînes en chaînes d'octets. Cela a quelques effets indésirables:

• Une copie de la structure décodée entière est créée en mémoire
• Si votre objet JSON est vraiment profondément imbriqué (500 niveaux ou plus), vous atteindrez la profondeur de récursivité maximale de Python

Cette réponse atténue ces deux problèmes de performances en utilisant le object_hookparamètre de json.loadetjson.loads . De la documentation :

object_hookest une fonction facultative qui sera appelée avec le résultat de tout objet littéral décodé (a dict). La valeur de retour de object_hook sera utilisée à la place de dict. Cette fonctionnalité peut être utilisée pour implémenter des décodeurs personnalisés

Étant donné que les dictionnaires imbriqués de nombreux niveaux profondément dans d'autres dictionnaires sont passés à object_hook fur et mesure qu'ils sont décodés , nous pouvons byteifier toutes les chaînes ou listes à l'intérieur à ce stade et éviter la nécessité d'une récursivité profonde plus tard.

La réponse de Mark ne peut pas être utilisée telle object_hookquelle, car elle se reproduit dans des dictionnaires imbriqués. Nous empêchons cette récursivité dans cette réponse avec le ignore_dictsparamètre to _byteify, qui lui est transmis à tout moment sauf lorsqu'il lui object_hookpasse un nouveau dictà byteify. leignore_dicts drapeau indique _byteifyd'ignorer les dicts car ils ont déjà été byteifiés.

Enfin, nos implémentations de json_load_byteifiedet json_loads_byteifiedappelons _byteify(avec ignore_dicts=True) le résultat renvoyé par json.loadou json.loadspour gérer le cas où le texte JSON en cours de décodage n'a pas de dictniveau supérieur.

Bien qu'il y ait de bonnes réponses ici, j'ai fini par utiliser PyYAML pour analyser mes fichiers JSON, car il donne les clés et les valeurs sous strforme de chaînes de unicodetype au lieu de 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']

Remarques

Quelques points à noter cependant:

• J'obtiens des objets chaîne car toutes mes entrées sont encodées en ASCII . Si j'utilisais des entrées codées unicode, je les récupérerais en tant qu'objets unicode - il n'y a pas de conversion!

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

• Si vous voulez un analyseur YAML qui prend davantage en charge la version 1.2 de la spécification (et analyse correctement des nombres très faibles ), essayez Ruamel YAML : pip install ruamel.yamlet import ruamel.yaml as yamlc'é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), mieux vaut utiliser une fonction de conversion :

J'ai utilisé celui de Mark Amery plusieurs fois maintenant, il fonctionne très bien et est très facile à utiliser. Vous pouvez également utiliser une fonction similaire à la object_hookplace, car cela pourrait vous permettre d' améliorer les performances des gros fichiers. Voir la réponse un peu plus complexe de Mirec Miskuf pour cela.

Il n'y a pas d'option intégrée pour que les fonctions du module json retournent des chaînes d'octets au lieu de chaînes unicode. Cependant, cette fonction récursive courte et simple convertira tout objet JSON décodé de l'utilisation de chaînes unicode en chaînes d'octets 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

Appelez simplement cela sur la sortie que vous obtenez d'un json.loadou json.loadsappelez.

Quelques notes:

• Pour prendre en charge Python 2.6 ou version antérieure, remplacez-le 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 compréhensions de dictionnaire n'étaient pas prises en charge avant Python 2.7.
• Étant donné que cette réponse se reproduit dans tout l'objet décodé, elle présente quelques caractéristiques de performances indésirables qui peuvent être évitées en utilisant très soigneusement les paramètres object_hookou object_pairs_hook. La réponse de Mirec Miskuf est jusqu'à présent la seule qui réussit à réussir cela, bien qu'en conséquence, c'est beaucoup plus compliqué que mon approche.

Vous pouvez utiliser le object_hookparamètre pour json.loadspasser dans un convertisseur. Vous n'avez pas à effectuer la conversion après coup. Le jsonmodule transmettra toujours les object_hookdict uniquement, et il transmettra récursivement les dicts imbriqués, vous n'avez donc pas besoin de récursivement vous-même dans les dicts imbriqués. Je ne pense pas que je convertirais des chaînes unicode en nombres comme le montre Wells. S'il s'agit d'une chaîne unicode, elle a été citée en tant que chaîne dans le fichier JSON, elle est donc censée être une chaîne (ou le fichier est incorrect).

De plus, j'essaierais d'éviter de faire quelque chose comme str(val)sur un unicodeobjet. Vous devez utiliser value.encode(encoding)avec un encodage valide, selon ce que votre bibliothèque 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 aucune différence entre les objets chaîne et les objets unicode. Ce sont toutes des chaînes en javascript.

Je pense que JSON a raison de renvoyer des objets Unicode . En fait, je n'accepterais rien de moins, car les chaînes javascript sont en fait des unicodeobjets (c'est-à-dire que les chaînes JSON (javascript) peuvent stocker tout type de caractère unicode), il est donc logique de créer des unicodeobjets lors de la traduction de chaînes à partir de JSON. Les chaînes simples ne conviennent tout simplement pas car la bibliothèque devrait deviner l'encodage que vous souhaitez.

Il vaut mieux utiliser unicodedes objets chaîne partout. Votre meilleure option est donc de mettre à jour vos bibliothèques afin qu'elles puissent traiter les objets Unicode.

Mais si vous voulez vraiment des bytestrings, encodez simplement les résultats dans 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 une solution de contournement facile.

TL; DR - Utilisez ast.literal_eval()au lieu de json.loads(). Les deux astet jsonsont dans la bibliothèque standard.

Bien que ce ne soit pas une réponse `` parfaite '', elle en obtient une assez loin si votre plan est d'ignorer complètement Unicode. 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 velu lorsque certains objets sont vraiment des chaînes Unicode. La réponse complète devient rapidement poilue.

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

object_pairs_hookest une fonction facultative qui sera appelée avec le résultat de tout objet littéral décodé avec une liste ordonnée de paires. La valeur de retour de object_pairs_hooksera utilisée à la place de dict. Cette fonctionnalité peut être utilisée pour implémenter des décodeurs personnalisés qui reposent sur l'ordre de décodage des paires clé / valeur (par exemple, collections.OrderedDictse souviendront de l'ordre d'insertion). Si object_hookest également défini, le object_pairs_hookprend la priorité.

Avec lui, vous obtenez chaque objet JSON, vous pouvez donc faire le décodage sans avoir besoin de récursivité:

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 de manière récursive car chaque objet sera remis au crochet lorsque vous utiliserez le object_pairs_hook. Vous devez vous soucier des listes, mais comme vous pouvez le voir, un objet dans une liste sera correctement converti, et vous n'avez pas besoin de récursivement pour y arriver.

EDIT: Un collègue a souligné que Python2.6 n'a pas object_hook_pairs. Vous pouvez toujours utiliser cette volonté Python2.6 en faisant un très petit changement. Dans le crochet ci-dessus, modifiez:

for key, value in pairs:

à

for key, value in pairs.iteritems():

Utilisez ensuite object_hookau 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_hookrésultats dans un dictionnaire de moins est instanciée pour chaque objet dans l'objet JSON, ce qui, si vous analysiez un document volumineux, pourrait valoir la peine.

Je crains qu'il n'y ait aucun moyen d'y parvenir automatiquement dans la bibliothèque simplejson.

Le scanner et le décodeur de 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_scanstringsi la version C n'est pas disponible. La scanstringfonction 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 monkeypatch la scanstringvaleur dans simplejson.decoder, ou sous JSONDecoder- classe et fournir à peu près votre propre implémentation entière de tout ce qui pourrait contenir du texte.

La raison pour laquelle simplejson génère unicode, cependant, est que la spécification json mentionne spécifiquement que "Une chaîne est une collection de zéro ou plusieurs caractères Unicode" ... la prise en charge de l'unicode est supposée faire partie du format lui-même. L' scanstringimplémentation de Simplejson va jusqu'à analyser et interpréter les échappements unicode (même en vérifiant les erreurs pour les représentations de jeux de caractères multi-octets mal formées), donc la seule façon dont il peut vous renvoyer la valeur de manière fiable est en tant qu'unicode.

Si vous avez une bibliothèque ancienne qui a besoin d'un str, je vous recommande soit de rechercher laborieusement la structure de données imbriquée après l'analyse (ce que je reconnais être ce que vous avez explicitement dit que vous vouliez éviter ... désolé), soit d'envelopper vos 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 gérable que la première si vos structures de données sont en effet profondément imbriquées.

Comme Mark (Amery) le note correctement: L' utilisation du désérialiseur de PyYaml sur un vidage json ne fonctionne que si vous avez uniquement ASCII. Au moins hors de la boîte.

Deux commentaires rapides sur l'approche PyYaml:

1. N'utilisez JAMAIS yaml.load sur les données du champ. C'est une fonctionnalité (!) De yaml pour exécuter du code arbitraire caché dans la structure.

2. Vous pouvez le faire fonctionner également pour 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 n'est pas comparable à la réponse de Mark Amery:

En lançant des exemples de dict profondément imbriqués sur les deux méthodes, j'obtiens ceci (avec dt [j] = delta temporel de json.loads (json.dumps (m))):

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

Donc, la désérialisation, y compris la marche complète de l'arbre et l' encodage, bien dans l'ordre de grandeur de l'implémentation basée sur C de json. Je trouve cela remarquablement rapide et aussi plus robuste que la charge de yaml sur les structures profondément imbriquées. Et moins sujet aux erreurs de sécurité, en regardant yaml.load.

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

Cela est particulièrement vrai si votre structure json provient du champ, contenant des entrées utilisateur. Parce qu'alors vous devrez probablement marcher de toute façon sur votre structure - indépendamment de vos structures de données internes souhaitées («sandwich unicode» ou chaînes d'octets uniquement).

Pourquoi?

Normalisation Unicode . Pour les ignorants: prenez un analgésique et lisez ceci .

Donc, en utilisant la récursion byteify, vous tuez deux oiseaux avec une pierre:

1. obtenez vos bytestrings à partir de dumps json imbriqués
2. obtenir les valeurs d'entrée utilisateur normalisées, afin que vous trouviez les éléments dans votre stockage.

Lors de mes tests, il s'est avéré que remplacer le fichier input.encode ('utf-8') par un unicodedata.normalize ('NFC', input) .encode ('utf-8') était encore plus rapide que sans NFC - mais c'est fortement tributaire des données d'exemple, je suppose.

Le gotcha est cela simplejsonet ce jsonsont deux modules différents, au moins dans la manière dont ils traitent avec l'unicode. Vous avez jsondans py 2.6+, et cela vous donne des valeurs unicode, tandis que simplejsonrenvoie des objets chaîne. Essayez simplement easy_install-ing simplejson dans votre environnement et voyez si cela fonctionne. Ça l'a fait pour moi.

Utilisez simplement pickle au lieu de json pour le vidage et le chargement, comme ceci:

    import json
    import pickle

    d = { 'field1': 'value1', 'field2': 2, }

    json.dump(d,open("testjson.txt","w"))

    print json.load(open("testjson.txt","r"))

    pickle.dump(d,open("testpickle.txt","w"))

    print pickle.load(open("testpickle.txt","r"))

La sortie qu'il produit est (les chaînes et les entiers sont traités correctement):

    {u'field2': 2, u'field1': u'value1'}
    {'field2': 2, 'field1': 'value1'}

J'ai donc rencontré le même problème. Devinez quel a été le premier résultat Google.

Comme je dois transmettre toutes les données à PyGTK, les chaînes unicode ne me sont pas très utiles non plus. J'ai donc une autre méthode de conversion récursive. Il est en fait également nécessaire pour la conversion JSON de typeafe - json.dump () serait mis en place sur tous les non-littéraux, comme les objets Python. Ne convertit cependant pas les index dict.

# removes any objects, turns unicode back into str
def filter_data(obj):
        if type(obj) in (int, float, str, bool):
                return obj
        elif type(obj) == unicode:
                return str(obj)
        elif type(obj) in (list, tuple, set):
                obj = list(obj)
                for i,v in enumerate(obj):
                        obj[i] = filter_data(v)
        elif type(obj) == dict:
                for i,v in obj.iteritems():
                        obj[i] = filter_data(v)
        else:
                print "invalid object in data, converting to string"
                obj = str(obj) 
        return obj

J'avais un dict JSON comme chaîne. Les clés et les valeurs étaient des objets Unicode comme dans l'exemple suivant:

myStringDict = "{u'key':u'value'}"

Je pourrais utiliser la byteifyfonction suggérée ci-dessus en convertissant la chaîne en un dictobjet en utilisant ast.literal_eval(myStringDict).

Prise en charge de Python2 et 3 à l'aide du crochet (depuis https://stackoverflow.com/a/33571117/558397 )

import requests
import six
from six import iteritems

requests.packages.urllib3.disable_warnings()  # @UndefinedVariable
r = requests.get("http://echo.jsontest.com/key/value/one/two/three", verify=False)

def _byteify(data):
    # if this is a unicode string, return its string representation
    if isinstance(data, six.string_types):
        return str(data.encode('utf-8').decode())

    # if this is a list of values, return list of byteified values
    if isinstance(data, list):
        return [ _byteify(item) for item in data ]

    # if this is a dictionary, return dictionary of byteified keys and values
    # but only if we haven't already byteified it
    if isinstance(data, dict):
        return {
            _byteify(key): _byteify(value) for key, value in iteritems(data)
        }
    # if it's anything else, return it in its original form
    return data

w = r.json(object_hook=_byteify)
print(w)

Retour:

 {'three': '', 'key': 'value', 'one': 'two'}

C'est la fin du jeu, mais j'ai construit ce lanceur récursif. Cela fonctionne pour mes besoins et je pense que c'est relativement complet. Cela peut vous aider.

def _parseJSON(self, obj):
    newobj = {}

    for key, value in obj.iteritems():
        key = str(key)

        if isinstance(value, dict):
            newobj[key] = self._parseJSON(value)
        elif isinstance(value, list):
            if key not in newobj:
                newobj[key] = []
                for i in value:
                    newobj[key].append(self._parseJSON(i))
        elif isinstance(value, unicode):
            val = str(value)
            if val.isdigit():
                val = int(val)
            else:
                try:
                    val = float(val)
                except ValueError:
                    val = str(val)
            newobj[key] = val

    return newobj

Passez-lui simplement un objet JSON comme ceci:

obj = json.loads(content, parse_float=float, parse_int=int)
obj = _parseJSON(obj)

Je l'ai en tant que membre privé d'une classe, mais vous pouvez réutiliser la méthode comme bon vous semble.

J'ai réécrit _parse_json () de Wells pour gérer les cas où l'objet json lui-même est un tableau (mon cas d'utilisation).

def _parseJSON(self, obj):
    if isinstance(obj, dict):
        newobj = {}
        for key, value in obj.iteritems():
            key = str(key)
            newobj[key] = self._parseJSON(value)
    elif isinstance(obj, list):
        newobj = []
        for value in obj:
            newobj.append(self._parseJSON(value))
    elif isinstance(obj, unicode):
        newobj = str(obj)
    else:
        newobj = obj
    return newobj

voici un encodeur récursif écrit en C: https://github.com/axiros/nested_encode

Surcoût de performance pour les structures "moyennes" d'environ 10% par rapport à json.loads.

python speed.py                                                                                            
  json loads            [0.16sec]: {u'a': [{u'b': [[1, 2, [u'\xd6ster..
  json loads + encoding [0.18sec]: {'a': [{'b': [[1, 2, ['\xc3\x96ster.
  time overhead in percent: 9%

en utilisant cette structure de test:

import json, nested_encode, time

s = """
{
  "firstName": "Jos\\u0301",
  "lastName": "Smith",
  "isAlive": true,
  "age": 25,
  "address": {
    "streetAddress": "21 2nd Street",
    "city": "\\u00d6sterreich",
    "state": "NY",
    "postalCode": "10021-3100"
  },
  "phoneNumbers": [
    {
      "type": "home",
      "number": "212 555-1234"
    },
    {
      "type": "office",
      "number": "646 555-4567"
    }
  ],
  "children": [],
  "spouse": null,
  "a": [{"b": [[1, 2, ["\\u00d6sterreich"]]]}]
}
"""


t1 = time.time()
for i in xrange(10000):
    u = json.loads(s)
dt_json = time.time() - t1

t1 = time.time()
for i in xrange(10000):
    b = nested_encode.encode_nested(json.loads(s))
dt_json_enc = time.time() - t1

print "json loads            [%.2fsec]: %s..." % (dt_json, str(u)[:20])
print "json loads + encoding [%.2fsec]: %s..." % (dt_json_enc, str(b)[:20])

print "time overhead in percent: %i%%"  % (100 * (dt_json_enc - dt_json)/dt_json)

Avec Python 3.6, parfois je rencontre toujours ce problème. Par exemple, lorsque j'obtiens une réponse d'une API REST et que je charge le texte de la réponse dans JSON, j'obtiens toujours les chaînes unicode. Trouvé une solution simple en utilisant json.dumps ().

response_message = json.loads(json.dumps(response.text))
print(response_message)

J'ai également rencontré ce problème, et devant faire face à JSON, j'ai trouvé une petite boucle qui convertit les clés unicode en chaînes. ( simplejsonsur GAE ne renvoie pas de clés de chaîne.)

obj est l'objet décodé à partir de JSON:

if NAME_CLASS_MAP.has_key(cls):
    kwargs = {}
    for i in obj.keys():
        kwargs[str(i)] = obj[i]
    o = NAME_CLASS_MAP[cls](**kwargs)
    o.save()

kwargsest ce que je passe au constructeur de l'application GAE (qui n'aime pas les unicodeclés **kwargs)

Pas aussi robuste que la solution de Wells, mais beaucoup plus petit.

J'ai adapté le code de la réponse de Mark Amery , notamment pour se débarrasser des isinstancepros de la frappe de canard.

L'encodage se fait manuellement et ensure_asciiest désactivé. La documentation de python pour json.dumpdit que

Si Ensure_ascii est True (par défaut), tous les caractères non ASCII dans la sortie sont échappés avec des séquences \ uXXXX

Avertissement: dans le doctorat, j'ai utilisé la langue hongroise. Certains encodages de caractères liés à la Hongrie notables sont: cp852l'encodage IBM / OEM utilisé par exemple. sous DOS (parfois appelé ascii , à tort je pense, cela dépend du réglage de la page de code ), cp1250utilisé par exemple. sous Windows (parfois appelé ansi , en fonction des paramètres régionaux), et iso-8859-2parfois utilisé sur les serveurs http. Le texte du test Tüskéshátú kígyóbűvölőest attribué à Koltai László (forme de nom personnel natif) et provient de wikipedia .

# coding: utf-8
"""
This file should be encoded correctly with utf-8.
"""
import json

def encode_items(input, encoding='utf-8'):
    u"""original from: https://stackoverflow.com/a/13101776/611007
    adapted by SO/u/611007 (20150623)
    >>> 
    >>> ## run this with `python -m doctest <this file>.py` from command line
    >>> 
    >>> txt = u"Tüskéshátú kígyóbűvölő"
    >>> txt2 = u"T\\u00fcsk\\u00e9sh\\u00e1t\\u00fa k\\u00edgy\\u00f3b\\u0171v\\u00f6l\\u0151"
    >>> txt3 = u"uúuutifu"
    >>> txt4 = b'u\\xfauutifu'
    >>> # txt4 shouldn't be 'u\\xc3\\xbauutifu', string content needs double backslash for doctest:
    >>> assert u'\\u0102' not in b'u\\xfauutifu'.decode('cp1250')
    >>> txt4u = txt4.decode('cp1250')
    >>> assert txt4u == u'u\\xfauutifu', repr(txt4u)
    >>> txt5 = b"u\\xc3\\xbauutifu"
    >>> txt5u = txt5.decode('utf-8')
    >>> txt6 = u"u\\u251c\\u2551uutifu"
    >>> there_and_back_again = lambda t: encode_items(t, encoding='utf-8').decode('utf-8')
    >>> assert txt == there_and_back_again(txt)
    >>> assert txt == there_and_back_again(txt2)
    >>> assert txt3 == there_and_back_again(txt3)
    >>> assert txt3.encode('cp852') == there_and_back_again(txt4u).encode('cp852')
    >>> assert txt3 == txt4u,(txt3,txt4u)
    >>> assert txt3 == there_and_back_again(txt5)
    >>> assert txt3 == there_and_back_again(txt5u)
    >>> assert txt3 == there_and_back_again(txt4u)
    >>> assert txt3.encode('cp1250') == encode_items(txt4, encoding='utf-8')
    >>> assert txt3.encode('utf-8') == encode_items(txt5, encoding='utf-8')
    >>> assert txt2.encode('utf-8') == encode_items(txt, encoding='utf-8')
    >>> assert {'a':txt2.encode('utf-8')} == encode_items({'a':txt}, encoding='utf-8')
    >>> assert [txt2.encode('utf-8')] == encode_items([txt], encoding='utf-8')
    >>> assert [[txt2.encode('utf-8')]] == encode_items([[txt]], encoding='utf-8')
    >>> assert [{'a':txt2.encode('utf-8')}] == encode_items([{'a':txt}], encoding='utf-8')
    >>> assert {'b':{'a':txt2.encode('utf-8')}} == encode_items({'b':{'a':txt}}, encoding='utf-8')
    """
    try:
        input.iteritems
        return {encode_items(k): encode_items(v) for (k,v) in input.iteritems()}
    except AttributeError:
        if isinstance(input, unicode):
            return input.encode(encoding)
        elif isinstance(input, str):
            return input
        try:
            iter(input)
            return [encode_items(e) for e in input]
        except TypeError:
            return input

def alt_dumps(obj, **kwargs):
    """
    >>> alt_dumps({'a': u"T\\u00fcsk\\u00e9sh\\u00e1t\\u00fa k\\u00edgy\\u00f3b\\u0171v\\u00f6l\\u0151"})
    '{"a": "T\\xc3\\xbcsk\\xc3\\xa9sh\\xc3\\xa1t\\xc3\\xba k\\xc3\\xadgy\\xc3\\xb3b\\xc5\\xb1v\\xc3\\xb6l\\xc5\\x91"}'
    """
    if 'ensure_ascii' in kwargs:
        del kwargs['ensure_ascii']
    return json.dumps(encode_items(obj), ensure_ascii=False, **kwargs)

Je voudrais également souligner la réponse de Jarret Hardie qui fait référence à la spécification JSON , citant:

Une chaîne est une collection de zéro ou plusieurs caractères Unicode

Dans mon cas d'utilisation, j'avais des fichiers avec json. Ce sont utf-8des fichiers encodés. ensure_asciise traduit par des fichiers json correctement échappés mais peu lisibles, c'est pourquoi j'ai adapté la réponse de Mark Amery à mes besoins.

Le docteur n'est pas particulièrement réfléchi mais je partage le code dans l'espoir qu'il sera utile à quelqu'un.

Découvrez cette réponse à une question similaire comme celle-ci qui dit que

Le préfixe u signifie simplement que vous avez une chaîne Unicode. Lorsque vous utilisez vraiment la chaîne, elle n'apparaîtra pas dans vos données. Ne soyez pas éjecté par la sortie imprimée.

Par exemple, essayez ceci:

print mail_accounts[0]["i"]

Vous ne verrez pas un u.