Python: json.loads devuelve elementos con el prefijo 'u'

Recibiré una forma de cadena codificada JSON Obj-C, y estoy decodificando una cadena ficticia (por ahora) como el código a continuación. Mi salida sale con el carácter 'u' que antepone cada elemento:

[{u'i': u'imap.gmail.com', u'p': u'aaaa'}, {u'i': u'333imap.com', u'p': u'bbbb'}...

¿Cómo está JSON agregando este char unicode? ¿Cuál es la mejor manera de eliminarlo?

mail_accounts = []
da = {}
try:
    s = '[{"i":"imap.gmail.com","p":"aaaa"},{"i":"imap.aol.com","p":"bbbb"},{"i":"333imap.com","p":"ccccc"},{"i":"444ap.gmail.com","p":"ddddd"},{"i":"555imap.gmail.com","p":"eee"}]'
    jdata = json.loads(s)
    for d in jdata:
        for key, value in d.iteritems():
            if key not in da:
                da[key] = value
            else:
                da = {}
                da[key] = value
        mail_accounts.append(da)
except Exception, err:
    sys.stderr.write('Exception Error: %s' % str(err))

print mail_accounts

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.

Todo está bien, hombre. La 'u' es algo bueno, indica que la cadena es de tipo Unicode en python 2.x.

http://docs.python.org/2/howto/unicode.html#the-unicode-type

La d3impresión a continuación es la que está buscando (que es la combinación de volcados y cargas) :)

Teniendo:

import json

d = """{"Aa": 1, "BB": "blabla", "cc": "False"}"""

d1 = json.loads(d)              # Produces a dictionary out of the given string
d2 = json.dumps(d)              # Produces a string out of a given dict or string
d3 = json.dumps(json.loads(d))  # 'dumps' gets the dict from 'loads' this time

print "d1:  " + str(d1)
print "d2:  " + d2
print "d3:  " + d3

Huellas dactilares:

d1:  {u'Aa': 1, u'cc': u'False', u'BB': u'blabla'}
d2:  "{\"Aa\": 1, \"BB\": \"blabla\", \"cc\": \"False\"}"
d3:  {"Aa": 1, "cc": "False", "BB": "blabla"}

El uprefijo significa que esas cadenas son unicode en lugar de cadenas de 8 bits. La mejor manera de no mostrar el uprefijo es cambiar a Python 3, donde las cadenas son unicode por defecto. Si esa no es una opción, el strconstructor convertirá de unicode a 8 bits, así que simplemente haga un bucle recursivo sobre el resultado y convierta unicodea str. Sin embargo, probablemente sea mejor dejar las cadenas como unicode.

Unicode es un tipo apropiado aquí. Los documentos de JSONDecoder describen la tabla de conversión y establecen que los objetos de cadena json se decodifican en objetos Unicode

https://docs.python.org/2/library/json.html#encoders-and-decoders

JSON                    Python
==================================
object                  dict
array                   list
string                  unicode
number (int)            int, long
number (real)           float
true                    True
false                   False
null                    None

"la codificación determina la codificación utilizada para interpretar cualquier objeto str decodificado por esta instancia (UTF-8 por defecto)".

Esos caracteres 'u' que se agregan a un objeto significa que el objeto está codificado en "unicode".

Si desea eliminar esos caracteres 'u' de su objeto, puede hacer esto:

import json, ast
jdata = ast.literal_eval(json.dumps(jdata)) # Removing uni-code chars

Hagamos el pago desde Python Shell

>>> import json, ast
>>> jdata = [{u'i': u'imap.gmail.com', u'p': u'aaaa'}, {u'i': u'333imap.com', u'p': u'bbbb'}]
>>> jdata = ast.literal_eval(json.dumps(jdata))
>>> jdata
[{'i': 'imap.gmail.com', 'p': 'aaaa'}, {'i': '333imap.com', 'p': 'bbbb'}]

Me encontré con este problema al intentar capturar datos JSON en el registro con la loggingbiblioteca de Python , para fines de depuración y solución de problemas. Obtener el upersonaje es una verdadera molestia cuando quieres copiar el texto y pegarlo en tu código en alguna parte.

Como todo el mundo le dirá, esto se debe a que es una representación Unicode y, json.loads()en primer lugar , podría deberse al hecho de que ha utilizado para cargar los datos de una cadena.

Si desea la representación JSON en el registro, sin el uprefijo, el truco es usar json.dumps()antes de cerrar la sesión. Por ejemplo:

import json
import logging

# Prepare the data
json_data = json.loads('{"key": "value"}')

# Log normally and get the Unicode indicator
logging.warning('data: {}'.format(json_data))
>>> WARNING:root:data: {u'key': u'value'}

# Dump to a string before logging and get clean output!
logging.warning('data: {}'.format(json.dumps(json_data)))
>>> WARNING:root:data: {'key': 'value'}

Prueba esto:

mail_accounts [0] .encode ("ascii")

Simplemente reemplace la u 'con una comilla simple ...

print (str.replace(mail_accounts,"u'","'"))