Python: json.loads retorna itens com o prefixo 'u'

Receberei uma sequência de caracteres codificada em JSON, Obj-C, e estou decodificando uma sequência fictícia (por enquanto) como o código abaixo. Minha saída sai com o caractere 'u' prefixando cada item:

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

Como o JSON está adicionando esse caractere unicode? Qual é a melhor maneira de removê-lo?

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

O prefixo u significa apenas que você tem uma string Unicode. Quando você realmente usa a string, ela não aparece nos seus dados. Não seja jogado pela saída impressa.

Por exemplo, tente o seguinte:

print mail_accounts[0]["i"]

Você não verá um u.

Está tudo bem, cara. O 'u' é uma coisa boa, indica que a string é do tipo Unicode no python 2.x.

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

A d3impressão abaixo é a que você está procurando (que é a combinação de lixões e cargas) :)

Tendo:

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

Impressões:

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

O uprefixo significa que essas cadeias são unicode em vez de cadeias de 8 bits. A melhor maneira de não mostrar o uprefixo é mudar para Python 3, onde as strings são unicode por padrão. Se isso não for uma opção, o strconstrutor converterá de unicode para 8 bits, então simplesmente faça um loop recursivo sobre o resultado e converterá unicodeem str. No entanto, é provavelmente melhor deixar as seqüências como unicode.

Unicode é um tipo apropriado aqui. Os documentos JSONDecoder descrevem a tabela de conversão e afirmam que os objetos da string json são decodificados em 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

"codificação determina a codificação usada para interpretar qualquer objeto str decodificado por esta instância (UTF-8 por padrão)."

Esses caracteres 'u' sendo anexados a um objeto significam que o objeto está codificado em "unicode".

Se você deseja remover os caracteres 'u' do seu objeto, você pode fazer isso:

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

Vamos fazer o checkout do 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'}]

Continuei com esse problema ao tentar capturar dados JSON no log com a loggingbiblioteca Python , para fins de depuração e solução de problemas. Obter o upersonagem é um verdadeiro incômodo quando você deseja copiar o texto e colá-lo em seu código em algum lugar.

Como todos dirão, isso ocorre porque é uma representação Unicode e pode vir do fato de você ter usado json.loads() os dados de uma string em primeiro lugar.

Se você deseja a representação JSON no log, sem o uprefixo, o truque é usar json.dumps()antes de fazer logout. Por exemplo:

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

Tente o seguinte:

mail_accounts [0] .encode ("ascii")

Apenas substitua u por uma única citação ...

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