Używam Pythona 2 do analizy JSON z plików tekstowych zakodowanych w ASCII .

Podczas ładowania tych plików za pomocą jsonlub simplejson, wszystkie moje ciągi znaków są rzutowane na obiekty Unicode zamiast na ciągi znaków. Problem polega na tym, że muszę używać danych z niektórymi bibliotekami, które akceptują tylko obiekty łańcuchowe. Nie mogę zmienić bibliotek ani zaktualizować ich.

Czy można uzyskać obiekty łańcuchowe zamiast Unicode?

Przykład

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

Aktualizacja

To pytanie zostało zadane dawno temu , kiedy utknąłem w Pythonie 2 . Jednym łatwym i czystym rozwiązaniem na dziś jest użycie najnowszej wersji Pythona - tj. Python 3 i nowszych .

Rozwiązanie z 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

Przykładowe użycie:

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

Jak to działa i dlaczego miałbym go używać?

Funkcja Marka Amery jest krótsza i bardziej przejrzysta niż te, więc jaki jest ich sens? Dlaczego chcesz z nich korzystać?

Wyłącznie dla wydajności . Odpowiedź Marka dekoduje najpierw tekst JSON za pomocą ciągów Unicode, a następnie przechodzi przez całą zdekodowaną wartość, aby przekonwertować wszystkie ciągi na ciągi bajtowe. Ma to kilka niepożądanych efektów:

• Kopia całej zdekodowanej struktury zostaje utworzona w pamięci
• Jeśli obiekt JSON jest naprawdę głęboko zagnieżdżony (500 poziomów lub więcej), osiągniesz maksymalną głębokość rekurencji w Pythonie

Ta odpowiedź łagodzi oba te problemy z wydajnością przy użyciu object_hookparametru json.loadi json.loads. Z dokumentów :

object_hookjest funkcją opcjonalną, która zostanie wywołana z wynikiem dowolnego dekodowania literału obiektu (a dict). Zamiast tego zostanie użyta wartość zwracana przez object_hook dict. Tej funkcji można użyć do zaimplementowania niestandardowych dekoderów

Ponieważ słowniki zagnieżdżone na wielu poziomach głęboko w innych słownikach są przekazywane object_hook podczas dekodowania , możemy w tym miejscu bajtować wszelkie ciągi znaków lub listy i unikać późniejszej potrzeby głębokiej rekurencji.

Odpowiedź Marka nie nadaje się do użycia w object_hookobecnym kształcie, ponieważ powtarza się w zagnieżdżonych słownikach. Zapobiegamy tej rekurencji w tej odpowiedzi z ignore_dictsparametrem do _byteify, który jest do niej przekazywany przez cały czas, z wyjątkiem sytuacji, gdy object_hookprzekazuje ją do nowego dictbajtowania. ignore_dictsFlag opowiada _byteifyignorować dicts ponieważ już byteified.

Wreszcie, nasze implementacje json_load_byteifiedi json_loads_byteifiedwywołanie _byteify(z ignore_dicts=True) wyniku zwróconego z json.loadlub w json.loadscelu obsługi przypadku, w którym dekodowany tekst JSON nie ma dictnajwyższego poziomu.

Chociaż jest tu kilka dobrych odpowiedzi, ostatecznie użyłem PyYAML do parsowania moich plików JSON, ponieważ daje klucze i wartości jako strciągi znaków zamiast unicodetypu. Ponieważ JSON jest podzbiorem YAML, działa dobrze:

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

Notatki

Należy jednak pamiętać o kilku rzeczach:

• Dostaję obiekty łańcuchowe, ponieważ wszystkie moje wpisy są zakodowane w ASCII . Gdybym używał wpisów kodowanych w Unicode, odzyskałbym je jako obiekty Unicode - nie ma konwersji!

• Powinieneś (prawdopodobnie zawsze) użyć safe_loadfunkcji PyYAML ; jeśli użyjesz go do ładowania plików JSON, i tak nie potrzebujesz „dodatkowej mocy” loadfunkcji.

• Jeśli chcesz parser YAML, który ma większe wsparcie dla wersji 1.2 specyfikacji (i poprawnie analizuje bardzo niskie liczby ) wypróbuj Ruamel YAML : pip install ruamel.yamli to import ruamel.yaml as yamlbyło wszystko, czego potrzebowałem w moich testach.

Konwersja

Jak wspomniano, nie ma konwersji! Jeśli nie możesz być pewien, że zajmujesz się tylko wartościami ASCII (i nie masz pewności przez większość czasu), lepiej użyj funkcji konwersji :

Kilka razy korzystałem z tego od Marka Amery , działa świetnie i jest bardzo łatwy w użyciu. Zamiast tego możesz również użyć podobnej funkcji object_hook, ponieważ może ona zwiększyć wydajność dużych plików. Zobacz na to nieco bardziej zaangażowaną odpowiedź Mireca Miskufa .

Nie ma wbudowanej opcji powodującej, że funkcje modułu json zwracają ciągi bajtów zamiast ciągów Unicode. Jednak ta krótka i prosta funkcja rekurencyjna przekształci dowolny zdekodowany obiekt JSON z użycia ciągów Unicode w ciągi bajtów zakodowanych w 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

Po prostu wywołaj to na wyjściu otrzymanym z połączenia json.loadlub json.loads.

Kilka uwag:

• Aby wesprzeć Pyton 2,6 lub powyżej, zastępuje return {byteify(key): byteify(value) for key, value in input.iteritems()}się return dict([(byteify(key), byteify(value)) for key, value in input.iteritems()]), od słownika Ułatwienia nie były obsługiwane, aż Pythonie 2.7.
• Ponieważ ta odpowiedź powtarza się w całym zdekodowanym obiekcie, ma ona kilka niepożądanych charakterystyk wydajnościowych, których można uniknąć dzięki bardzo ostrożnemu użyciu parametrów object_hooklub object_pairs_hook. Odpowiedź Mireca Miskufa jest jak dotąd jedyną, która potrafi to poprawnie wykonać, choć w konsekwencji jest znacznie bardziej skomplikowana niż moje podejście.

Możesz użyć object_hookparametru, json.loadsaby przekazać konwerter. Po fakcie nie trzeba wykonywać konwersji. jsonModuł będzie zawsze przechodzą object_hookdicts tylko, a będzie to rekurencyjnie przechodzić w zagnieżdżonych dicts, więc nie musisz rekursja do zagnieżdżonych dicts siebie. Nie sądzę, bym konwertował ciągi znaków Unicode na liczby takie jak programy Wellsa. Jeśli jest to ciąg znaków Unicode, został zacytowany jako ciąg znaków w pliku JSON, więc powinien to być ciąg znaków (lub plik jest zły).

Ponadto starałbym się unikać robienia czegoś takiego jak str(val)na unicodeobiekcie. Powinieneś używać value.encode(encoding)z prawidłowym kodowaniem, w zależności od tego, czego oczekuje twoja biblioteka zewnętrzna.

Na przykład:

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)

Jest tak, ponieważ json nie ma różnicy między obiektami łańcuchowymi a obiektami Unicode. Wszystkie są łańcuchami w javascript.

Myślę, że JSON ma rację zwracając obiekty Unicode . W rzeczywistości nie zaakceptowałbym niczego mniejszego, ponieważ ciągi javascript są w rzeczywistości unicodeobiektami (tzn. Ciągi JSON (javascript) mogą przechowywać dowolny rodzaj znaku Unicode), więc sensowne jest tworzenie unicodeobiektów podczas tłumaczenia ciągów z JSON. Zwykłe ciągi po prostu nie pasowałyby, ponieważ biblioteka musiałaby odgadnąć kodowanie, jakie chcesz.

Lepiej jest używać unicodeobiektów łańcuchowych wszędzie. Dlatego najlepszą opcją jest aktualizacja bibliotek, aby mogły one obsługiwać obiekty Unicode.

Ale jeśli naprawdę chcesz bajtowania, po prostu zakoduj wyniki do wybranego kodowania:

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

Istnieje łatwe obejście problemu.

TL; DR - użyj ast.literal_eval()zamiast json.loads(). Zarówno asti jsonsą w bibliotece standardowej.

Chociaż nie jest to „idealna” odpowiedź, jest ona dość daleko, jeśli twoim planem jest całkowite zignorowanie Unicode. W Pythonie 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))

daje:

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

Robi się bardziej włochaty, gdy niektóre obiekty są tak naprawdę łańcuchami Unicode. Pełna odpowiedź szybko staje się owłosiona.

Odpowiedź Mike'a Brennana jest bliska, ale nie ma powodu, aby przemierzać całą strukturę. Jeśli używasz parametru object_hook_pairs(Python 2.7+):

object_pairs_hookjest funkcją opcjonalną, która zostanie wywołana z wynikiem dowolnego literału obiektu dekodowanego za pomocą uporządkowanej listy par. Zwrócona wartość object_pairs_hookzostanie użyta zamiast dict. Ta funkcja może być wykorzystana do implementacji niestandardowych dekoderów, które opierają się na kolejności dekodowania par klucza i wartości (na przykład collections.OrderedDictzapamięta kolejność wstawiania). Jeśli object_hookjest również zdefiniowane, object_pairs_hookpierwszeństwo ma.

Za jego pomocą otrzymujesz każdy obiekt JSON, dzięki czemu możesz dekodować bez potrzeby rekurencji:

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

Zauważ, że nigdy nie muszę wywoływać haka rekurencyjnie, ponieważ każdy obiekt zostanie przekazany do haka, gdy go użyjesz object_pairs_hook. Musisz dbać o listy, ale jak widać, obiekt na liście zostanie poprawnie przekonwertowany i nie musisz się powtarzać, aby tak się stało.

EDYCJA: Współpracownik zauważył, że Python2.6 nie ma object_hook_pairs. Nadal możesz tego używać w Pythonie 2.6, dokonując bardzo małej zmiany. W haku powyżej zmień:

for key, value in pairs:

do

for key, value in pairs.iteritems():

Następnie użyj object_hookzamiast 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'}}

Wykorzystanie object_pairs_hookwyników powoduje utworzenie instancji jednego mniejszego słownika dla każdego obiektu w obiekcie JSON, co może być przydatne, jeśli analizujesz ogromny dokument.

Obawiam się, że nie ma możliwości automatycznego osiągnięcia tego celu w bibliotece simplejson.

Skaner i dekoder w simplejson są zaprojektowane do generowania tekstu Unicode. Aby to zrobić, biblioteka używa funkcji o nazwie c_scanstring(jeśli jest dostępna, dla szybkości) lub py_scanstringjeśli wersja C nie jest dostępna. scanstringFunkcja nazywa się kilka razy przez prawie każdej rutyny że simplejson ma do dekodowania strukturę, która może zawierać tekst. Będziesz musiał albo scanstringwpisać małpą wartość w simplejson.decoder, albo podklasę JSONDecoderi podać prawie całą własną implementację wszystkiego, co może zawierać tekst.

Powodem, dla którego simplejson wypisuje kod Unicode, jest jednak to, że specyfikacja json wyraźnie wspomina, że ​​„Łańcuch jest zbiorem zerowych lub więcej znaków Unicode” ... zakłada się, że obsługa Unicode jest częścią samego formatu. Implementacja Simplejsona scanstringposuwa się tak daleko, że skanuje i interpretuje zmiany znaczenia Unicode (nawet sprawdzanie błędów w przypadku zniekształconych reprezentacji wielobajtowych zestawów znaków), więc jedynym sposobem, w jaki można niezawodnie zwrócić ci wartość, jest unicode.

Jeśli masz starzejącą się bibliotekę, która tego potrzebuje str, polecam ci żmudne przeszukanie zagnieżdżonej struktury danych po parsowaniu (co, jak mówię, jest tym, co wyraźnie powiedziałeś, że chcesz uniknąć ... przepraszam), lub może zapakuj swoje biblioteki w coś w rodzaju fasada, w której można masować parametry wejściowe na bardziej szczegółowym poziomie. Drugie podejście może być łatwiejsze do zarządzania niż pierwsze, jeśli struktury danych są rzeczywiście głęboko zagnieżdżone.

Jak słusznie zauważa Mark (Amery): Używanie deserializatora PyYamla na zrzutie jsona działa tylko, jeśli masz tylko ASCII. Przynajmniej po wyjęciu z pudełka.

Dwa szybkie komentarze na temat podejścia PyYaml:

1. NIGDY nie używaj yaml.load do danych z pola. Jest to funkcja (!) Programu yaml do wykonywania dowolnego kodu ukrytego w strukturze.

2. Państwo może zrobić to działa również za brak ASCII przez to:

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

Ale pod względem wydajności nie ma porównania z odpowiedzią Marka Amery:

Rzucając głęboko zagnieżdżone przykładowe dykty na dwie metody, otrzymuję to (z dt [j] = delta czasowa json.loads (json.dumps (m))):

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

Tak więc deserializacja, w tym pełne chodzenie po drzewie i kodowanie, w zakresie wielkości implementacji opartej na C. Uważam to za niezwykle szybkie i również bardziej wytrzymałe niż obciążenie yaml w głęboko zagnieżdżonych strukturach. I mniej podatne na błędy bezpieczeństwa, patrząc na yaml.load.

=> Chociaż doceniłbym wskaźnik do konwertera opartego tylko na C, funkcja bajtowania powinna być odpowiedzią domyślną.

Jest to szczególnie ważne, jeśli twoja struktura json pochodzi z pola zawierającego dane wprowadzone przez użytkownika. Bo wtedy prawdopodobnie trzeba chodzić w każdym razie nad strukturą - niezależnego od żądanej wewnętrznych struktur danych (unicode „kanapkę” lub ciągów bajtów tylko).

Czemu?

Normalizacja Unicode . Dla nieświadomych: weź środek przeciwbólowy i przeczytaj to .

Tak więc za pomocą rekurencji bajtowej zabijasz dwa ptaki jednym kamieniem:

1. pobierz swoje bajty z zagnieżdżonych zrzutów Jsona
2. znormalizować wartości wejściowe użytkownika, aby znaleźć rzeczy w pamięci.

W moich testach okazało się, że zastąpienie input.encode ('utf-8') unicodedata.normalize ('NFC', wejście) .encode ('utf-8') było nawet szybsze niż bez NFC - ale to w dużym stopniu zależy od przykładowych danych.

Gotcha jest tym simplejsoni jsonsą to dwa różne moduły, przynajmniej w sposób, w jaki radzą sobie z Unicode. Masz jsonw py 2.6+, a to daje ci wartości Unicode, podczas gdy simplejsonzwraca obiekty łańcuchowe. Po prostu spróbuj easy_install-ing simplejson w swoim środowisku i sprawdź, czy to działa. To mi zrobiło.

Po prostu użyj marynaty zamiast jsona do zrzutu i załadowania, tak:

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

Dane wyjściowe są generowane (ciągi i liczby całkowite są obsługiwane poprawnie):

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

Więc napotkałem ten sam problem. Zgadnij, jaki był pierwszy wynik Google.

Ponieważ muszę przekazać wszystkie dane do PyGTK, ciągi Unicode też nie są dla mnie bardzo przydatne. Mam więc inną metodę konwersji rekurencyjnej. W rzeczywistości jest również potrzebny do bezpiecznej konwersji JSON - json.dump () zwolniłby kaucję za wszelkie nie-literały, takie jak obiekty Python. Nie konwertuje jednak indeksów 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

Miałem dykta JSON jako ciąg. Klucze i wartości były obiektami Unicode, jak w poniższym przykładzie:

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

Mógłbym użyć byteifyfunkcji sugerowanej powyżej, przekształcając ciąg znaków w dictobiekt za pomocą ast.literal_eval(myStringDict).

Obsługa Python2 i 3 przy użyciu hooka (od 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)

Zwroty:

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

Jest późno na grę, ale zbudowałem ten rekurencyjny rzucający. Działa na moje potrzeby i myślę, że jest względnie kompletny. To może ci pomóc.

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

Po prostu przekaż mu obiekt JSON w taki sposób:

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

Mam go jako prywatnego członka klasy, ale możesz zmienić przeznaczenie metody według własnego uznania.

Przepisałem _parse_json () Wellsa, aby obsługiwać przypadki, w których sam obiekt json jest tablicą (mój przypadek użycia).

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

tutaj jest koder rekurencyjny napisany w C: https://github.com/axiros/nested_encode

Narzut wydajności dla „średnich” struktur około 10% w porównaniu do 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%

za pomocą tej struktury testowej:

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)

W Pythonie 3.6 czasami napotykam ten problem. Na przykład podczas pobierania odpowiedzi z interfejsu API REST i ładowania tekstu odpowiedzi do JSON nadal otrzymuję ciągi Unicode. Znaleziono proste rozwiązanie za pomocą json.dumps ().

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

Wpadłem również na ten problem i mając do czynienia z JSON, wpadłem na małą pętlę, która konwertuje klucze Unicode na ciągi. ( simplejsonw GAE nie zwraca kluczy ciągów).

obj jest obiekt zdekodowany z 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()

kwargsprzekazuję konstruktorowi aplikacji GAE (która nie lubi unicodekluczy **kwargs)

Nie tak solidne jak rozwiązanie Wellsa, ale znacznie mniejsze.

Mam dostosowany kod z odpowiedzią z Markiem Amery , w szczególności w celu pozbycia isinstancedla profesjonalistów z kaczki wzorcowego.

Kodowanie odbywa się ręcznie i ensure_asciijest wyłączone. Python docs json.dumpmówi o tym

Jeśli parametr sure_ascii ma wartość True (domyślnie), wszystkie znaki inne niż ASCII na wyjściu są poprzedzane znakami \ uXXXX

Uwaga: w doctest użyłem języka węgierskiego. Niektóre znaczące kodowania znaków związane z Węgrami to: cp852stosowane kodowanie IBM / OEM, np. w DOS (czasami nazywany ascii , błędnie myślę, że zależy to od ustawienia strony kodowej ), cp1250używany np. w systemie Windows (czasem określanym jako ansi , w zależności od ustawień regionalnych), a iso-8859-2czasem używany na serwerach HTTP. Tekst testowy Tüskéshátú kígyóbűvölőjest przypisany Koltai László (natywny formularz imienia) i pochodzi z wikipedii .

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

Chciałbym również podkreślić jak odpowiedź z Jarret Hardie który References Spec JSON , cytując:

Łańcuch jest zbiorem zerowego lub więcej znaków Unicode

W moim przypadku użycia miałem pliki z Jsonem. Są to utf-8pliki zakodowane. ensure_asciipowoduje powstanie poprawnie ukrytych, ale niezbyt czytelnych plików json, dlatego dostosowałem odpowiedź Marka Ameryka do moich potrzeb.

Doctest nie jest szczególnie przemyślany, ale dzielę się kodem w nadziei, że komuś się przyda.

Sprawdź tę odpowiedź na podobne pytanie, które to stwierdza

Prefiks u oznacza po prostu, że masz ciąg Unicode. Gdy naprawdę użyjesz ciągu, nie pojawi się on w twoich danych. Nie daj się wyrzucić wydrukowi.

Na przykład spróbuj tego:

print mail_accounts[0]["i"]

Nie zobaczysz cię.