Saya menggunakan Python 2 untuk mem-parsing JSON dari file teks yang disandikan ASCII .

Saat memuat file-file ini dengan salah satu jsonatau simplejson, semua nilai string saya dilemparkan ke objek Unicode, bukan objek string. Masalahnya adalah, saya harus menggunakan data dengan beberapa perpustakaan yang hanya menerima objek string. Saya tidak dapat mengubah perpustakaan atau memperbaruinya.

Apakah mungkin untuk mendapatkan objek string daripada objek Unicode?

Contoh

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

Memperbarui

Pertanyaan ini sudah lama ditanyakan , ketika saya terjebak dengan Python 2 . Salah satu solusi mudah dan bersih untuk hari ini adalah dengan menggunakan versi Python terbaru - yaitu Python 3 dan seterusnya.

Solusi dengan 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

Contoh penggunaan:

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

Bagaimana cara kerjanya dan mengapa saya menggunakannya?

Fungsi Mark Amery lebih pendek dan lebih jelas daripada yang ini, jadi apa gunanya? Mengapa Anda ingin menggunakannya?

Murni untuk kinerja . Jawaban Mark menerjemahkan teks JSON sepenuhnya terlebih dahulu dengan string unicode, kemudian berulang melalui seluruh nilai yang diterjemahkan untuk mengkonversi semua string ke string byte. Ini memiliki beberapa efek yang tidak diinginkan:

• Salinan seluruh struktur yang didekodekan akan dibuat dalam memori
• Jika objek JSON Anda benar-benar mendalam bersarang (500 tingkat atau lebih) maka Anda akan memukul kedalaman rekursi maksimum Python

Jawaban ini mengurangi kedua masalah kinerja tersebut dengan menggunakan object_hookparameter json.loaddan json.loads. Dari dokumen :

object_hookadalah fungsi opsional yang akan dipanggil dengan hasil dari setiap objek yang diterjemahkan secara literal (a dict). Nilai pengembalian object_hook akan digunakan sebagai ganti dict. Fitur ini dapat digunakan untuk mengimplementasikan decoder kustom

Karena kamus bersarang banyak level dalam kamus lain yang dilewati object_hook saat diterjemahkan , kita dapat mengubah byte atau daftar apa pun di dalamnya pada saat itu dan menghindari perlunya rekursi mendalam nantinya.

Jawaban Markus tidak cocok untuk digunakan sebagaimana object_hookmestinya, karena berulang menjadi kamus bersarang. Kami mencegah rekursi dalam jawaban ini dengan ignore_dictsparameter to _byteify, yang diteruskan ke sana setiap saat kecuali saat object_hookmelewatinya yang baru dictuntuk byteify. The ignore_dictsbendera mengatakan _byteifyuntuk mengabaikan dicts karena mereka sudah byteified.

Akhirnya, implementasi json_load_byteifieddan json_loads_byteifiedpanggilan kami _byteify(dengan ignore_dicts=True) pada hasil yang dikembalikan dari json.loadatau json.loadsuntuk menangani kasus di mana teks JSON yang diterjemahkan tidak memiliki dictdi tingkat atas.

Meskipun ada beberapa jawaban yang baik di sini, saya akhirnya menggunakan PyYAML untuk mengurai file JSON saya, karena memberikan kunci dan nilai sebagai strstring tipe bukan unicodetipe. Karena JSON adalah bagian dari YAML berfungsi dengan baik:

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

Catatan

Beberapa hal yang perlu diperhatikan:

• Saya mendapatkan objek string karena semua entri saya dikodekan ASCII . Jika saya akan menggunakan entri yang disandikan unicode, saya akan mendapatkannya kembali sebagai objek unicode - tidak ada konversi!

• Anda harus (mungkin selalu) menggunakan safe_loadfungsi PyYAML ; jika Anda menggunakannya untuk memuat file JSON, Anda tidak memerlukan "kekuatan tambahan" dari loadfungsi tersebut.

• Jika Anda menginginkan parser YAML yang memiliki lebih banyak dukungan untuk versi 1.2 dari spesifikasi (dan dengan benar mem-parsing angka yang sangat rendah ) coba Ruamel YAML : pip install ruamel.yamldan hanya import ruamel.yaml as yamlitu yang saya butuhkan dalam pengujian saya.

Konversi

Seperti yang dinyatakan, tidak ada konversi! Jika Anda tidak yakin untuk hanya berurusan dengan nilai-nilai ASCII (dan Anda tidak bisa memastikan sebagian besar waktu), lebih baik gunakan fungsi konversi :

Saya menggunakan yang dari Mark Amery beberapa kali sekarang, ini berfungsi dengan baik dan sangat mudah digunakan. Anda juga dapat menggunakan fungsi yang sama sebagai object_hookgantinya, karena dapat meningkatkan kinerja Anda pada file besar. Lihat jawaban yang sedikit lebih terlibat dari Mirec Miskuf untuk itu.

Tidak ada opsi bawaan untuk membuat fungsi modul json mengembalikan string byte alih-alih string unicode. Namun, fungsi rekursif singkat dan sederhana ini akan mengubah objek JSON yang didekode dari menggunakan string unicode menjadi string byte UTF-8-encoded:

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

Sebut saja ini pada output yang Anda dapatkan dari json.loadatau json.loadspanggilan.

Beberapa catatan:

• Untuk mendukung Python 2.6 atau sebelumnya, ganti return {byteify(key): byteify(value) for key, value in input.iteritems()}dengan return dict([(byteify(key), byteify(value)) for key, value in input.iteritems()]), karena pemahaman kamus tidak didukung hingga Python 2.7.
• Karena jawaban ini berulang melalui seluruh objek yang diterjemahkan, itu memiliki beberapa karakteristik kinerja yang tidak diinginkan yang dapat dihindari dengan sangat hati-hati menggunakan parameter object_hookatau object_pairs_hook. Sejauh ini jawaban Mirec Miskuf adalah satu-satunya yang berhasil melakukan ini dengan benar, meskipun sebagai konsekuensinya, secara signifikan lebih rumit daripada pendekatan saya.

Anda dapat menggunakan object_hookparameter untuk json.loadslewat dalam konverter. Anda tidak perlu melakukan konversi setelah faktanya. The jsonmodul akan selalu melewati object_hookdicts saja, dan secara rekursif akan lulus dalam dicts bersarang, sehingga Anda tidak perlu recurse ke dicts bersarang sendiri. Saya tidak berpikir saya akan mengubah string unicode ke angka seperti yang ditunjukkan Wells. Jika itu adalah string unicode, itu dikutip sebagai string dalam file JSON, jadi itu seharusnya string (atau file tersebut buruk).

Juga, saya akan mencoba untuk menghindari melakukan sesuatu seperti str(val)pada suatu unicodeobjek. Anda harus menggunakan value.encode(encoding)dengan penyandian yang valid, tergantung pada apa yang diharapkan oleh lib eksternal Anda.

Jadi, misalnya:

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)

Itu karena json tidak memiliki perbedaan antara objek string dan objek unicode. Mereka semua adalah string dalam javascript.

Saya pikir JSON benar untuk mengembalikan objek unicode . Sebenarnya, saya tidak akan menerima apa pun yang kurang, karena string javascript sebenarnya adalah unicodeobjek (yaitu string JSON (javascript) dapat menyimpan segala jenis karakter unicode) sehingga masuk akal untuk membuat unicodeobjek saat menerjemahkan string dari JSON. String biasa tidak cocok karena perpustakaan harus menebak pengodean yang Anda inginkan.

Lebih baik menggunakan unicodeobjek string di mana-mana. Jadi pilihan terbaik Anda adalah memperbarui perpustakaan Anda sehingga mereka dapat menangani objek unicode.

Tetapi jika Anda benar-benar ingin bytestrings, cukup enkode hasilnya ke enkode pilihan Anda:

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

Ada solusi yang mudah.

TL; DR - Gunakan ast.literal_eval()sebagai ganti json.loads(). Keduanya astdan jsonberada di perpustakaan standar.

Meskipun bukan jawaban 'sempurna', ada satu yang cukup jauh jika rencana Anda mengabaikan Unicode sama sekali. Dalam 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))

memberi:

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

Ini menjadi lebih berbulu ketika beberapa objek benar-benar string Unicode. Jawaban lengkap menjadi cepat berbulu.

Jawaban Mike Brennan dekat, tetapi tidak ada alasan untuk menelusuri ulang seluruh struktur. Jika Anda menggunakan object_hook_pairsparameter (Python 2.7+):

object_pairs_hookadalah fungsi opsional yang akan dipanggil dengan hasil objek apa pun yang diterjemahkan dengan daftar pasangan terurut. Nilai pengembalian object_pairs_hookakan digunakan sebagai ganti dict. Fitur ini dapat digunakan untuk mengimplementasikan decoder kustom yang bergantung pada urutan pasangan kunci dan nilai yang diterjemahkan (misalnya, collections.OrderedDictakan mengingat urutan penyisipan). Jika object_hookjuga ditentukan, object_pairs_hookprioritas akan diambil.

Dengan itu, Anda mendapatkan setiap objek JSON yang diserahkan kepada Anda, sehingga Anda dapat melakukan decoding tanpa perlu rekursi:

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

Perhatikan bahwa saya tidak pernah harus memanggil kait secara berulang karena setiap objek akan diserahkan ke kait ketika Anda menggunakan object_pairs_hook. Anda memang harus memperhatikan daftar, tetapi seperti yang Anda lihat, objek dalam daftar akan dikonversi dengan benar, dan Anda tidak perlu berulang untuk mewujudkannya.

EDIT: Seorang rekan kerja menunjukkan bahwa Python2.6 tidak punya object_hook_pairs . Anda masih bisa menggunakan ini akan Python2.6 dengan membuat perubahan yang sangat kecil. Pada kait di atas, ubah:

for key, value in pairs:

untuk

for key, value in pairs.iteritems():

Kemudian gunakan object_hooksebagai ganti 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'}}

Menggunakan object_pairs_hookhasil dalam satu kamus kurang sedang dipakai untuk setiap objek di objek JSON, yang, jika Anda parsing dokumen besar, mungkin bernilai sementara.

Saya khawatir tidak ada cara untuk mencapai ini secara otomatis dalam perpustakaan simplejson.

Pemindai dan dekoder di simplejson dirancang untuk menghasilkan teks unicode. Untuk melakukan ini, perpustakaan menggunakan fungsi yang disebut c_scanstring(jika tersedia, untuk kecepatan), atau py_scanstringjika versi C tidak tersedia. The scanstringfungsi disebut beberapa kali oleh hampir setiap rutinitas yang simplejson memiliki untuk decoding struktur yang mungkin berisi teks. Anda harus melakukan monkeypatch scanstringnilai dalam simplejson.decoder, atau subclass JSONDecoderdan memberikan cukup banyak seluruh implementasi Anda sendiri dari apa pun yang mungkin berisi teks.

Alasan bahwa simplejson mengeluarkan unicode, adalah, karena spesifikasi json menyebutkan bahwa "string adalah kumpulan dari nol atau lebih karakter Unicode" ... dukungan untuk unicode dianggap sebagai bagian dari format itu sendiri. Implementasi Simplejson scanstringsejauh ini untuk memindai dan menafsirkan unicode escapes (bahkan pengecekan kesalahan untuk representasi charset multi-byte yang salah), sehingga satu-satunya cara andal dapat mengembalikan nilai kepada Anda adalah sebagai unicode.

Jika Anda memiliki perpustakaan lama yang membutuhkan str, saya sarankan Anda dengan susah payah mencari struktur data bersarang setelah penguraian (yang saya akui adalah apa yang secara eksplisit Anda katakan ingin Anda hindari ... maaf), atau mungkin bungkus perpustakaan Anda dalam semacam fasad tempat Anda dapat memijat parameter input pada tingkat yang lebih terperinci. Pendekatan kedua mungkin lebih mudah dikelola daripada yang pertama jika struktur data Anda benar-benar bersarang.

Sebagai Mark (Amery) dengan benar mencatat: Menggunakan deserializer PyYaml pada json dump hanya berfungsi jika Anda memiliki ASCII saja. Setidaknya di luar kotak.

Dua komentar cepat tentang pendekatan PyYaml:

1. JANGAN PERNAH menggunakan yaml.load data dari lapangan. Ini adalah fitur (!) Dari yaml untuk mengeksekusi kode arbitrer yang tersembunyi dalam struktur.

2. Anda dapat membuatnya berfungsi juga untuk non ASCII melalui ini:

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

Namun kinerja tidak ada bedanya dengan jawaban Mark Amery:

Melemparkan beberapa dict sampel yang sangat bersarang ke dua metode, saya mendapatkan ini (dengan dt [j] = waktu delta json.loads (json.dumps (m))):

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

Jadi deserialisasi termasuk sepenuhnya berjalan pohon dan pengkodean, baik dalam urutan besarnya implementasi berbasis json C. Saya menemukan ini sangat cepat dan juga lebih kuat daripada beban yaml di struktur yang sangat bersarang. Dan rawan kesalahan keamanan, melihat yaml.load.

=> Sementara saya akan menghargai pointer ke konverter hanya berbasis C fungsi byteify harus menjadi jawaban default.

Ini berlaku terutama jika struktur json Anda berasal dari bidang, yang berisi input pengguna. Karena itu, Anda mungkin harus tetap berjalan di atas struktur Anda - independen pada struktur data internal yang Anda inginkan ('unicode sandwich' atau string byte saja).

Mengapa?

Normalisasi Unicode . Untuk yang tidak sadar: Ambil obat penghilang rasa sakit dan baca ini .

Jadi menggunakan rekursi byteify Anda membunuh dua burung dengan satu batu:

1. dapatkan bytestrings Anda dari nested json dumps
2. dapatkan nilai input pengguna dinormalisasi, sehingga Anda menemukan barang-barang di penyimpanan Anda.

Dalam tes saya ternyata mengganti input.encode ('utf-8') dengan unicodedata.normalisasi ('NFC', input) .encode ('utf-8') bahkan lebih cepat daripada tanpa NFC - tetapi itu sangat tergantung pada data sampel saya kira.

Gotcha adalah itu simplejsondan jsondua modul yang berbeda, setidaknya dalam cara mereka menangani unicode. Anda memiliki jsondi py 2.6+, dan ini memberi Anda nilai unicode, sedangkan simplejsonmengembalikan objek string. Coba saja easy_install-ing simplejson di lingkungan Anda dan lihat apakah itu berhasil. Itu untuk saya.

Cukup gunakan acar daripada json untuk dump dan memuat, seperti:

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

Output yang dihasilkannya adalah (string dan integer ditangani dengan benar):

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

Jadi, saya mengalami masalah yang sama. Coba tebak apa hasil Google pertama.

Karena saya harus meneruskan semua data ke PyGTK, string unicode juga tidak berguna bagi saya. Jadi saya punya metode konversi rekursif lain. Ini sebenarnya juga diperlukan untuk konversi JSON typesafe - json.dump () akan menjamin pada non-literal, seperti objek Python. Tidak mengonversi indeks 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

Saya memiliki dict JSON sebagai string. Kunci dan nilai adalah objek unicode seperti pada contoh berikut:

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

Saya bisa menggunakan byteifyfungsi yang disarankan di atas dengan mengubah string ke dictobjek menggunakan ast.literal_eval(myStringDict).

Mendukung Python2 & 3 menggunakan kait (dari 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)

Pengembalian:

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

Ini sudah terlambat dari permainan, tetapi saya membangun kastor rekursif ini. Ini berfungsi untuk kebutuhan saya dan saya pikir itu relatif lengkap. Ini dapat membantu Anda.

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

Cukup berikan objek JSON seperti ini:

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

Saya memilikinya sebagai anggota pribadi kelas, tetapi Anda dapat menggunakan kembali metode yang Anda inginkan.

Saya menulis ulang Wells _parse_json () untuk menangani kasus-kasus di mana objek json itu sendiri adalah array (kasus penggunaan saya).

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

di sini adalah encoder rekursif yang ditulis dalam C: https://github.com/axiros/nested_encode

Overhead kinerja untuk struktur "rata-rata" sekitar 10% dibandingkan dengan 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%

menggunakan struktur tes ini:

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)

Dengan Python 3.6, terkadang saya masih mengalami masalah ini. Misalnya, ketika mendapatkan respons dari REST API dan memuat teks respons ke JSON, saya masih mendapatkan string unicode. Menemukan solusi sederhana menggunakan json.dumps ().

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

Saya mengalami masalah ini juga, dan karena harus berurusan dengan JSON, saya membuat loop kecil yang mengubah kunci unicode menjadi string. ( simplejsonpada GAE tidak mengembalikan kunci string.)

obj adalah objek yang diterjemahkan dari 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()

kwargsadalah apa yang saya sampaikan ke konstruktor aplikasi GAE (yang tidak suka unicodekunci **kwargs)

Tidak sekuat solusi dari Wells, tetapi jauh lebih kecil.

Saya sudah diadaptasi kode dari jawaban dari Mark Amery , terutama untuk menyingkirkanisinstance untuk pro bebek-mengetik.

Pengkodean dilakukan secara manual dan ensure_asciidinonaktifkan. Python docs for json.dumpmengatakan itu

Jika sure_ascii Benar (default), semua karakter non-ASCII dalam output dikeluarkan dengan urutan \ uXXXX

Penafian: dalam dokumen saya menggunakan bahasa Hongaria. Beberapa pengkodean karakter terkait Hongaria yang terkenal adalah: pengkodean cp852IBM / OEM yang digunakan misalnya. di DOS (kadang-kadang disebut ascii , salah saya pikir, itu tergantung pada pengaturan codepage ), cp1250misalnya digunakan. di Windows (kadang-kadang disebut sebagai ansi , tergantung pada pengaturan lokal), dan iso-8859-2, kadang-kadang digunakan pada server http. Teks tes Tüskéshátú kígyóbűvölődikaitkan dengan Koltai László (bentuk nama pribadi asli) dan dari 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)

Saya juga ingin menyoroti jawaban dari Jarret Hardie yang referensi yang JSON spesifikasi , mengutip:

String adalah kumpulan nol atau lebih karakter Unicode

Dalam kasus penggunaan saya, saya punya file dengan json. Mereka adalah utf-8file yang disandikan. ensure_asciihasil dalam file json yang lolos dengan benar tetapi tidak terlalu mudah dibaca, itulah sebabnya saya mengadaptasi jawaban Mark Amery agar sesuai dengan kebutuhan saya.

Doctest tidak terlalu bijaksana tetapi saya membagikan kode dengan harapan akan bermanfaat bagi seseorang.

Lihat jawaban ini untuk pertanyaan serupa seperti ini yang menyatakan itu

Awalan u- artinya Anda memiliki string Unicode. Ketika Anda benar-benar menggunakan string, itu tidak akan muncul di data Anda. Jangan terlempar oleh hasil cetak.

Misalnya, coba ini:

print mail_accounts[0]["i"]

Anda tidak akan melihat Anda.