Estoy usando Python 2 para analizar JSON de archivos de texto codificados ASCII .

Al cargar estos archivos con jsono simplejson, todos mis valores de cadena se convierten en objetos Unicode en lugar de objetos de cadena. El problema es que tengo que usar los datos con algunas bibliotecas que solo aceptan objetos de cadena. No puedo cambiar las bibliotecas ni actualizarlas.

¿Es posible obtener objetos de cadena en lugar de Unicode?

Ejemplo

>>> 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`

Actualizar

Esta pregunta se hizo hace mucho tiempo , cuando estaba atascado con Python 2 . Una solución fácil y limpia para hoy es usar una versión reciente de Python, es decir, Python 3 y versiones posteriores .

Una solución con 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

Ejemplo de uso:

>>> 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'}

¿Cómo funciona esto y por qué lo usaría?

La función de Mark Amery es más corta y clara que estas, entonces, ¿qué sentido tienen? ¿Por qué querrías usarlos?

Puramente por su rendimiento . La respuesta de Mark decodifica el texto JSON completamente primero con cadenas unicode, luego recurre a través de todo el valor decodificado para convertir todas las cadenas en cadenas de bytes. Esto tiene un par de efectos indeseables:

• Se crea una copia de toda la estructura decodificada en la memoria
• Si su objeto JSON está realmente anidado (500 niveles o más), alcanzará la profundidad de recursión máxima de Python

Esta respuesta mitiga ambos problemas de rendimiento mediante el uso del object_hookparámetro de json.loady json.loads. De los documentos :

object_hookes una función opcional que se llamará con el resultado de cualquier objeto literal decodificado (a dict). Se utilizará el valor de retorno de object_hook en lugar de dict. Esta característica se puede usar para implementar decodificadores personalizados

Dado que los diccionarios anidan muchos niveles profundos en otros diccionarios a los que se pasan a object_hook medida que se decodifican , podemos byteificar cualquier cadena o lista dentro de ellos en ese punto y evitar la necesidad de una recursión profunda más adelante.

La respuesta de Mark no es adecuada para su uso tal object_hookcomo está, porque se repite en diccionarios anidados. Prevenimos esa recursividad en esta respuesta con el ignore_dictsparámetro to _byteify, que se le pasa en todo momento, excepto cuando se le object_hookpasa un nuevo dictpara byteificar. La ignore_dictsbandera le dice _byteifyque ignore dictlos mensajes de correo electrónico ya que han sido modificados.

Finalmente, nuestras implementaciones de json_load_byteifiedand json_loads_byteifiedcall _byteify(with ignore_dicts=True) en el resultado devuelto por json.loado json.loadspara manejar el caso en el que el texto JSON que se decodifica no tiene un dictnivel superior.

Si bien hay algunas buenas respuestas aquí, terminé usando PyYAML para analizar mis archivos JSON, ya que proporciona las claves y los valores como strcadenas de unicodetipo en lugar de tipo. Como JSON es un subconjunto de YAML, funciona 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']

Notas

Algunas cosas a tener en cuenta sin embargo:

• Obtengo objetos de cadena porque todas mis entradas están codificadas en ASCII . Si usara entradas codificadas Unicode, las recuperaría como objetos Unicode , ¡no hay conversión!

• Debería (probablemente siempre) usar la safe_loadfunción de PyYAML ; Si lo usa para cargar archivos JSON, no necesita la "potencia adicional" de la loadfunción de todos modos.

• Si desea un analizador YAML que tenga más soporte para la versión 1.2 de la especificación (y analiza correctamente números muy bajos ) intente Ruamel YAML : pip install ruamel.yamly import ruamel.yaml as yamlfue todo lo que necesitaba en mis pruebas.

Conversión

Como se dijo, no hay conversión! Si no puede estar seguro de tratar solo con valores ASCII (y no puede estar seguro la mayor parte del tiempo), mejor use una función de conversión :

Utilicé el de Mark Amery un par de veces, funciona muy bien y es muy fácil de usar. También puede usar una función similar como object_hook, ya que podría aumentar el rendimiento en archivos grandes. Vea la respuesta un poco más complicada de Mirec Miskuf para eso.

No hay una opción integrada para hacer que las funciones del módulo json devuelvan cadenas de bytes en lugar de cadenas unicode. Sin embargo, esta función recursiva corta y simple convertirá cualquier objeto JSON descodificado del uso de cadenas unicode a cadenas de bytes codificadas 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

Simplemente llame a esto en la salida que obtiene de una json.loado json.loadsllamada.

Un par de notas:

• Para admitir Python 2.6 o anterior, reemplace return {byteify(key): byteify(value) for key, value in input.iteritems()}con return dict([(byteify(key), byteify(value)) for key, value in input.iteritems()]), ya que las comprensiones de diccionario no fueron compatibles hasta Python 2.7.
• Dado que esta respuesta se repite a través de todo el objeto decodificado, tiene un par de características de rendimiento indeseables que se pueden evitar con un uso muy cuidadoso de los parámetros object_hooko object_pairs_hook. La respuesta de Mirec Miskuf es hasta ahora la única que logra llevar esto a cabo correctamente, aunque como consecuencia, es significativamente más complicado que mi enfoque.

Puede usar el object_hookparámetro para json.loadspasar en un convertidor. No tiene que hacer la conversión después del hecho. El jsonmódulo siempre pasará object_hooksolo los dictados, y pasará recursivamente rectas anidadas, por lo que no tiene que recurrir a los dictados anidados usted mismo. No creo que convertiría cadenas Unicode en números como los programas de Wells. Si se trata de una cadena Unicode, se citó como una cadena en el archivo JSON, por lo que se supone que es una cadena (o el archivo es incorrecto).

Además, trataría de evitar hacer algo como str(val)en un unicodeobjeto. Debe usar value.encode(encoding)una codificación válida, según lo que espere su lib externa.

Así por ejemplo:

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)

Eso es porque json no tiene diferencia entre los objetos de cadena y los objetos unicode. Todas son cadenas en javascript.

Creo que JSON tiene razón al devolver objetos Unicode . De hecho, no aceptaría nada menos, ya que las cadenas de JavaScript son en realidad unicodeobjetos (es decir, las cadenas JSON (javascript) pueden almacenar cualquier tipo de carácter unicode), por lo que tiene sentido crear unicodeobjetos al traducir cadenas de JSON. Las cadenas simples simplemente no encajarían, ya que la biblioteca tendría que adivinar la codificación que desea.

Es mejor usar unicodeobjetos de cadena en todas partes. Por lo tanto, su mejor opción es actualizar sus bibliotecas para que puedan manejar objetos Unicode.

Pero si realmente desea cadenas de bytes, simplemente codifique los resultados a la codificación de su elección:

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

Existe una solución fácil.

TL; DR: uso en ast.literal_eval()lugar de json.loads(). Ambos asty jsonestán en la biblioteca estándar.

Si bien no es una respuesta "perfecta", se obtiene bastante lejos si su plan es ignorar Unicode por completo. 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))

da:

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

Esto se vuelve más peludo cuando algunos objetos son realmente cadenas Unicode. La respuesta completa se vuelve peluda rápidamente.

La respuesta de Mike Brennan es cercana, pero no hay razón para volver a atravesar toda la estructura. Si usa el object_hook_pairsparámetro (Python 2.7+):

object_pairs_hookes una función opcional que se llamará con el resultado de cualquier objeto literal decodificado con una lista ordenada de pares. Se object_pairs_hookutilizará el valor de retorno de en lugar de dict. Esta característica se puede utilizar para implementar decodificadores personalizados que se basan en el orden en que se decodifican los pares clave y valor (por ejemplo, collections.OrderedDictrecordará el orden de inserción). Si object_hooktambién se define, object_pairs_hooktiene prioridad.

Con él, recibe cada objeto JSON, por lo que puede hacer la decodificación sin necesidad de recurrencia:

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'}}

Tenga en cuenta que nunca tengo que llamar al gancho de forma recursiva ya que cada objeto será entregado al gancho cuando use el object_pairs_hook. Debes preocuparte por las listas, pero como puedes ver, un objeto dentro de una lista se convertirá correctamente y no tienes que recurrir para que suceda.

EDITAR: Un compañero de trabajo señaló que Python2.6 no tiene object_hook_pairs. Todavía puede usar este Python2.6 haciendo un cambio muy pequeño. En el gancho de arriba, cambie:

for key, value in pairs:

a

for key, value in pairs.iteritems():

Luego use en object_hooklugar 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'}}

El uso de object_pairs_hookresultados en un diccionario menos que se instancia para cada objeto en el objeto JSON, que, si estaba analizando un documento enorme, podría valer la pena.

Me temo que no hay forma de lograr esto automáticamente dentro de la biblioteca simplejson.

El escáner y el decodificador en simplejson están diseñados para producir texto unicode. Para hacer esto, la biblioteca usa una función llamada c_scanstring(si está disponible, por velocidad), o py_scanstringsi la versión C no está disponible. La scanstringfunción se llama varias veces por casi todas las rutinas que tiene simplejson para decodificar una estructura que puede contener texto. Tendría que monopatch el scanstringvalor en simplejson.decoder, o subclase JSONDecodery proporcionar prácticamente su propia implementación completa de cualquier cosa que pueda contener texto.

Sin embargo, la razón por la que simplejson genera unicode es que la especificación json menciona específicamente que "Una cadena es una colección de cero o más caracteres Unicode" ... se supone que el soporte para unicode forma parte del formato en sí. La scanstringimplementación de Simplejson va tan lejos como para escanear e interpretar escapes unicode (incluso la comprobación de errores para representaciones de caracteres de múltiples bytes con formato incorrecto), por lo que la única forma en que puede devolverle el valor de manera confiable es como unicode.

Si tiene una biblioteca antigua que necesita un archivo str, le recomiendo que busque laboriosamente en la estructura de datos anidados después del análisis (lo que reconozco es lo que dijo explícitamente que quería evitar ... lo siento), o tal vez incluya sus bibliotecas en algún tipo de fachada donde puede masajear los parámetros de entrada a un nivel más granular. El segundo enfoque podría ser más manejable que el primero si sus estructuras de datos están realmente anidadas.

Como Mark (Amery) señala correctamente: El uso del deserializador de PyYaml en un volcado json solo funciona si solo tiene ASCII. Al menos fuera de la caja.

Dos comentarios rápidos sobre el enfoque PyYaml:

1. NUNCA use yaml.load en datos del campo. Es una característica (!) De yaml para ejecutar código arbitrario oculto dentro de la estructura.

2. Usted puede hacer que funcione también para no ASCII a través de este:

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

Pero el rendimiento no es comparable con la respuesta de Mark Amery:

Al arrojar algunos dictados de muestra profundamente anidados en los dos métodos, obtengo esto (con dt [j] = time delta de json.loads (json.dumps (m))):

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

Entonces, la deserialización incluye caminar completamente por el árbol y codificar, dentro del orden de magnitud de la implementación basada en C de json. Encuentro esto notablemente rápido y también es más robusto que la carga yaml en estructuras profundamente anidadas. Y menos propenso a errores de seguridad, mirando yaml.load.

=> Aunque agradecería un puntero a un convertidor basado en C, la función byteify debería ser la respuesta predeterminada.

Esto es especialmente cierto si su estructura json es del campo, que contiene la entrada del usuario. Porque entonces probablemente necesite caminar de todos modos sobre su estructura, independientemente de sus estructuras de datos internos deseadas ('sandwich unicode' o cadenas de bytes solamente).

¿Por qué?

Normalización Unicode . Para los que no saben: tome un analgésico y lea esto .

Entonces, usando la recurrencia byteify, matas dos pájaros de un tiro:

1. Obtenga sus cadenas de bytes de volcados JSON anidados
2. obtener valores de entrada del usuario normalizados, para que pueda encontrar las cosas en su almacenamiento.

En mis pruebas resultó que reemplazar el input.encode ('utf-8') con unicodedata.normalize ('NFC', input) .encode ('utf-8') fue incluso más rápido que sin NFC, pero eso depende en gran medida de los datos de la muestra, supongo.

El Gotcha es que simplejsony jsonson dos módulos diferentes, al menos en la forma que se ocupan de Unicode. Tienes jsonen py 2.6+, y esto te da valores unicode, mientras que simplejsondevuelve objetos de cadena. Simplemente intente easy_install-ing simplejson en su entorno y vea si eso funciona. Lo hizo por mi.

Simplemente use pickle en lugar de json para volcar y cargar, así:

    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 salida que produce es (las cadenas y los enteros se manejan correctamente):

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

Entonces, me he encontrado con el mismo problema. Adivina cuál fue el primer resultado de Google.

Como necesito pasar todos los datos a PyGTK, las cadenas Unicode tampoco me son muy útiles. Entonces tengo otro método de conversión recursivo. En realidad, también es necesario para la conversión JSON de typesafe: json.dump () rescataría cualquier no literal, como los objetos de Python. Sin embargo, no convierte índices 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

Tenía un JSON dict como una cadena. Las claves y los valores eran objetos unicode como en el siguiente ejemplo:

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

Podría usar la byteifyfunción sugerida anteriormente al convertir la cadena a un dictobjeto usando ast.literal_eval(myStringDict).

Admite Python2 y 3 usando hook (desde 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)

Devoluciones:

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

Esto es tarde para el juego, pero construí este lanzador recursivo. Funciona para mis necesidades y creo que es relativamente completo. Te puede ayudar.

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

Simplemente páselo como un objeto JSON así:

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

Lo tengo como miembro privado de una clase, pero puede reutilizar el método como mejor le parezca.

Reescribí _parse_json () de Wells para manejar casos en los que el objeto json en sí mismo es una matriz (mi caso de uso).

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

Aquí hay un codificador recursivo escrito en C: https://github.com/axiros/nested_encode

Sobrecarga de rendimiento para estructuras "promedio" alrededor del 10% en comparación con 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%

utilizando esta estructura de prueba:

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)

Con Python 3.6, a veces todavía me encuentro con este problema. Por ejemplo, al obtener una respuesta de una API REST y cargar el texto de respuesta en JSON, sigo obteniendo las cadenas Unicode. Encontré una solución simple usando json.dumps ().

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

También me encontré con este problema, y ​​al tener que lidiar con JSON, se me ocurrió un pequeño bucle que convierte las claves Unicode en cadenas. ( simplejsonen GAE no devuelve claves de cadena).

obj es el objeto decodificado 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()

kwargses lo que paso al constructor de la aplicación GAE (que no le gustan las unicodeclaves **kwargs)

No es tan robusto como la solución de Wells, pero es mucho más pequeño.

He adaptado el código de la respuesta de Mark Amery , particularmente para deshacerme deisinstance los pros del tipeo.

La codificación se realiza manualmente y ensure_asciiestá deshabilitada. La documentación de Python json.dumpdice que

Si sure_ascii es True (el valor predeterminado), todos los caracteres no ASCII en la salida se escapan con secuencias \ uXXXX

Descargo de responsabilidad: en el doctest utilicé el idioma húngaro. Algunas codificaciones de caracteres relacionadas con Hungría son: cp852la codificación IBM / OEM utilizada, por ejemplo. en DOS (a veces denominado ascii , incorrectamente creo que depende de la configuración de la página de códigos ), cp1250por ejemplo , se usa. en Windows (a veces denominado ansi , depende de la configuración regional) y iso-8859-2, a veces, se usa en servidores http. El texto de la prueba Tüskéshátú kígyóbűvölőse atribuye a Koltai László (formulario de nombre personal nativo) y es 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)

También me gustaría destacar la respuesta de Jarret Hardie que hace referencia a la especificación JSON , citando:

Una cadena es una colección de cero o más caracteres Unicode

En mi caso de uso, tenía archivos con json. Son utf-8archivos codificados. ensure_asciida como resultado archivos json que escapan correctamente pero no son muy legibles, es por eso que he adaptado la respuesta de Mark Amery para satisfacer mis necesidades.

El documento no es particularmente atento, pero comparto el código con la esperanza de que sea útil para alguien.

Mira esta respuesta a una pregunta similar como esta que dice que

El prefijo u solo significa que tiene una cadena Unicode. Cuando realmente use la cadena, no aparecerá en sus datos. No se deje llevar por la salida impresa.

Por ejemplo, intente esto:

print mail_accounts[0]["i"]

No verás una u.