Tôi đang sử dụng Python 2 để phân tích JSON từ mã hóa ASCII các tệp văn bản .

Khi tải những tập tin này với một trong hai jsonhoặc simplejson, tất cả các giá trị chuỗi của tôi được đúc để Unicode đối tượng thay vì đối tượng chuỗi. Vấn đề là, tôi phải sử dụng dữ liệu với một số thư viện chỉ chấp nhận các đối tượng chuỗi. Tôi không thể thay đổi các thư viện cũng như cập nhật chúng.

Có thể lấy các đối tượng chuỗi thay vì Unicode?

Thí dụ

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

Cập nhật

Câu hỏi này đã được hỏi từ lâu , khi tôi bị mắc kẹt với Python 2 . Một giải pháp dễ dàng và sạch sẽ cho ngày hôm nay là sử dụng phiên bản Python gần đây - tức là Python 3 và chuyển tiếp.

Một giải pháp với 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

Ví dụ sử dụng:

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

Làm thế nào để nó hoạt động và tại sao tôi sẽ sử dụng nó?

Chức năng của Mark Amery ngắn hơn và rõ ràng hơn những chức năng này, vậy quan điểm của chúng là gì? Tại sao bạn muốn sử dụng chúng?

Hoàn toàn cho hiệu suất . Câu trả lời của Mark giải mã hoàn toàn văn bản JSON trước tiên bằng các chuỗi unicode, sau đó đệ quy thông qua toàn bộ giá trị được giải mã để chuyển đổi tất cả các chuỗi thành chuỗi byte. Điều này có một vài tác dụng không mong muốn:

• Một bản sao của toàn bộ cấu trúc được giải mã được tạo trong bộ nhớ
• Nếu đối tượng JSON của bạn thực sự được lồng sâu (500 cấp trở lên) thì bạn sẽ đạt được độ sâu đệ quy tối đa của Python

Câu trả lời này giảm thiểu cả hai vấn đề về hiệu suất bằng cách sử dụng object_hooktham số của json.loadvà json.loads. Từ các tài liệu :

object_hooklà một hàm tùy chọn sẽ được gọi với kết quả của bất kỳ đối tượng nào được giải mã theo nghĩa đen (a dict). Giá trị trả về của object_hook sẽ được sử dụng thay vì dict. Tính năng này có thể được sử dụng để thực hiện các bộ giải mã tùy chỉnh

Vì các từ điển lồng nhau nhiều cấp độ sâu trong các từ điển khác được chuyển đến object_hook khi chúng được giải mã , chúng ta có thể byte hóa bất kỳ chuỗi hoặc danh sách nào bên trong chúng tại thời điểm đó và tránh sự đệ quy sâu sau này.

Câu trả lời của Mark không phù hợp để sử dụng như object_hookhiện tại, vì nó đệ quy thành từ điển lồng nhau. Chúng tôi ngăn chặn sự đệ quy trong câu trả lời này với ignore_dictstham số tới _byteify, được chuyển đến nó mọi lúc trừ khi object_hookchuyển nó thành một dictbyte mới. Các ignore_dictslá cờ nói _byteifybỏ qua dicts kể từ khi họ đã được byteified.

Cuối cùng, việc triển khai json_load_byteifiedvà json_loads_byteifiedgọi _byteify(với ignore_dicts=True) kết quả của chúng tôi được trả về từ json.loadhoặc json.loadsđể xử lý trường hợp văn bản JSON được giải mã không có dictmức cao nhất.

Mặc dù có một số câu trả lời hay ở đây, cuối cùng tôi đã sử dụng PyYAML để phân tích các tệp JSON của mình, vì nó cung cấp các khóa và giá trị dưới strdạng chuỗi kiểu thay vì unicodekiểu. Vì JSON là tập con của YAML, nó hoạt động độc đáo:

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

Ghi chú

Một số điều cần lưu ý mặc dù:

• Tôi nhận được các đối tượng chuỗi vì tất cả các mục nhập của tôi được mã hóa ASCII . Nếu tôi sử dụng các mục được mã hóa unicode, tôi sẽ lấy lại chúng dưới dạng các đối tượng unicode - không có chuyển đổi!

• Bạn nên (có thể luôn luôn) sử dụng safe_loadchức năng của PyYAML ; nếu bạn sử dụng nó để tải các tệp JSON, dù sao bạn cũng không cần "sức mạnh bổ sung" của loadhàm.

• Nếu bạn muốn một trình phân tích cú pháp YAML hỗ trợ nhiều hơn cho phiên bản 1.2 của thông số kỹ thuật (và phân tích chính xác các số rất thấp ), hãy thử Ruamel YAML : pip install ruamel.yamlvà đó import ruamel.yaml as yamllà tất cả những gì tôi cần trong các thử nghiệm của mình.

Chuyển đổi

Như đã nêu, không có chuyển đổi! Nếu bạn không thể chắc chắn chỉ xử lý các giá trị ASCII (và bạn không thể chắc chắn hầu hết thời gian), tốt hơn nên sử dụng chức năng chuyển đổi :

Tôi đã sử dụng một từ Mark Amery một vài lần bây giờ, nó hoạt động rất tốt và rất dễ sử dụng. Bạn cũng có thể sử dụng một chức năng tương tự như một object_hookthay thế, vì nó có thể giúp bạn tăng hiệu suất trên các tệp lớn. Xem câu trả lời liên quan nhiều hơn một chút từ Mirec Miskuf cho điều đó.

Không có tùy chọn tích hợp để làm cho các hàm mô đun json trả về chuỗi byte thay vì chuỗi unicode. Tuy nhiên, hàm đệ quy ngắn và đơn giản này sẽ chuyển đổi bất kỳ đối tượng JSON được giải mã nào từ việc sử dụng chuỗi unicode sang chuỗi byte được mã hóa 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

Chỉ cần gọi điều này trên đầu ra bạn nhận được từ một json.loadhoặc json.loadsgọi.

Một vài lưu ý:

• Để hỗ trợ Python 2.6 hoặc sớm hơn, hãy thay thế return {byteify(key): byteify(value) for key, value in input.iteritems()}bằng return dict([(byteify(key), byteify(value)) for key, value in input.iteritems()]), vì hiểu từ điển không được hỗ trợ cho đến Python 2.7.
• Vì câu trả lời này đệ quy qua toàn bộ đối tượng được giải mã, nó có một vài đặc điểm hiệu suất không mong muốn có thể tránh được bằng cách sử dụng rất cẩn thận các tham số object_hookhoặc object_pairs_hooktham số. Câu trả lời của Mirec Miskuf cho đến nay là người duy nhất có thể giải quyết vấn đề này một cách chính xác, mặc dù do đó, nó phức tạp hơn đáng kể so với cách tiếp cận của tôi.

Bạn có thể sử dụng object_hooktham số json.loadsđể truyền trong bộ chuyển đổi. Bạn không phải thực hiện chuyển đổi sau khi thực tế. Các jsonmô-đun sẽ luôn luôn vượt qua object_hookdicts chỉ, và nó sẽ vượt qua trong đệ quy dicts lồng nhau, vì vậy bạn không cần phải recurse vào dicts lồng mình. Tôi không nghĩ rằng tôi sẽ chuyển đổi chuỗi unicode thành các số như chương trình Wells. Nếu đó là một chuỗi unicode, nó được trích dẫn dưới dạng một chuỗi trong tệp JSON, do đó, nó được coi là một chuỗi (hoặc tệp là xấu).

Ngoài ra, tôi sẽ cố gắng tránh làm một cái gì đó như str(val)trên một unicodeđối tượng. Bạn nên sử dụng value.encode(encoding)với một mã hóa hợp lệ, tùy thuộc vào những gì lib bên ngoài của bạn mong đợi.

Ví dụ:

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)

Đó là bởi vì json không có sự khác biệt giữa các đối tượng chuỗi và các đối tượng unicode. Tất cả đều là chuỗi trong javascript.

Tôi nghĩ JSON là đúng khi trả về các đối tượng unicode . Trên thực tế, tôi sẽ không chấp nhận bất cứ điều gì ít hơn, vì các chuỗi javascript thực tế là unicodecác đối tượng (tức là chuỗi JSON (javascript) có thể lưu trữ bất kỳ loại ký tự unicode nào) để tạo ra unicodecác đối tượng khi dịch chuỗi từ JSON. Các chuỗi đơn giản sẽ không phù hợp vì thư viện sẽ phải đoán mã hóa bạn muốn.

Tốt hơn là sử dụng unicodecác đối tượng chuỗi ở mọi nơi. Vì vậy, lựa chọn tốt nhất của bạn là cập nhật các thư viện của bạn để chúng có thể xử lý các đối tượng unicode.

Nhưng nếu bạn thực sự muốn bytestrings, chỉ cần mã hóa kết quả sang mã hóa mà bạn chọn:

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

Có tồn tại một công việc dễ dàng xung quanh.

TL; DR - Sử dụng ast.literal_eval()thay vì json.loads(). Cả hai astvà jsonđang ở trong thư viện tiêu chuẩn.

Mặc dù không phải là một câu trả lời 'hoàn hảo', nhưng nó sẽ trở nên khá xa nếu kế hoạch của bạn là bỏ qua Unicode hoàn toàn. Trong 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))

cho:

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

Điều này sẽ có nhiều lông hơn khi một số đối tượng thực sự là chuỗi Unicode. Câu trả lời đầy đủ nhanh chóng có lông.

Câu trả lời của Mike Brennan rất gần, nhưng không có lý do gì để duyệt lại toàn bộ cấu trúc. Nếu bạn sử dụng tham số object_hook_pairs(Python 2.7+):

object_pairs_hooklà một hàm tùy chọn sẽ được gọi với kết quả của bất kỳ đối tượng nào được giải mã theo nghĩa đen với một danh sách các cặp theo thứ tự. Giá trị trả về của object_pairs_hooksẽ được sử dụng thay vì dict. Tính năng này có thể được sử dụng để thực hiện các bộ giải mã tùy chỉnh dựa trên thứ tự các cặp khóa và giá trị được giải mã (ví dụ: collections.OrderedDictsẽ ghi nhớ thứ tự chèn). Nếu object_hookcũng được xác định, object_pairs_hookưu tiên.

Với nó, bạn nhận từng đối tượng JSON được trao cho bạn, do đó bạn có thể thực hiện giải mã mà không cần đệ quy:

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

Lưu ý rằng tôi không bao giờ phải gọi hook một cách đệ quy vì mọi đối tượng sẽ được trao cho hook khi bạn sử dụng object_pairs_hook. Bạn phải quan tâm đến danh sách, nhưng như bạn có thể thấy, một đối tượng trong danh sách sẽ được chuyển đổi chính xác và bạn không phải lặp lại để thực hiện điều đó.

EDIT: Một đồng nghiệp đã chỉ ra rằng Python2.6 không có object_hook_pairs. Bạn vẫn có thể sử dụng Python2.6 này bằng cách thực hiện một thay đổi rất nhỏ. Trong hook ở trên, thay đổi:

for key, value in pairs:

đến

for key, value in pairs.iteritems():

Sau đó sử dụng object_hookthay vì 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'}}

Sử dụng object_pairs_hookkết quả trong một từ điển ít hơn được khởi tạo cho từng đối tượng trong đối tượng JSON, nếu bạn đang phân tích một tài liệu khổng lồ, có thể có giá trị trong khi.

Tôi e rằng không có cách nào để tự động đạt được điều này trong thư viện Simplejson.

Máy quét và bộ giải mã trong Simplejson được thiết kế để tạo văn bản unicode. Để làm điều này, thư viện sử dụng một hàm gọi là c_scanstring(nếu có, với tốc độ) hoặc py_scanstringnếu phiên bản C không có sẵn. Các scanstringhàm được gọi nhiều lần bởi gần như mọi thói quen mà simplejson có để giải mã một cấu trúc có thể chứa văn bản. Bạn sẽ phải đánh dấu scanstringgiá trị trong Simplejson.decoder hoặc lớp con JSONDecodervà cung cấp khá nhiều toàn bộ việc thực hiện của riêng bạn đối với bất kỳ thứ gì có thể chứa văn bản.

Tuy nhiên, lý do mà Simplejson đưa ra unicode là do đặc tả json đề cập cụ thể rằng "Chuỗi là tập hợp các ký tự Unicode bằng 0 hoặc nhiều hơn" ... hỗ trợ cho unicode được coi là một phần của định dạng. Việc scanstringtriển khai của Simplejson đi xa đến mức quét và giải thích các lần thoát unicode (thậm chí kiểm tra lỗi đối với các biểu diễn bộ ký tự nhiều byte không đúng định dạng), do đó cách duy nhất có thể trả lại giá trị cho bạn là unicode.

Nếu bạn có một thư viện lâu đời cần một str, tôi khuyên bạn nên tìm kiếm cấu trúc dữ liệu lồng nhau sau khi phân tích cú pháp (mà tôi thừa nhận là những gì bạn nói rõ ràng muốn tránh ... xin lỗi), hoặc có thể bọc thư viện của bạn theo một số loại mặt tiền nơi bạn có thể xoa bóp các tham số đầu vào ở mức độ chi tiết hơn. Cách tiếp cận thứ hai có thể dễ quản lý hơn phương pháp thứ nhất nếu cấu trúc dữ liệu của bạn thực sự được lồng sâu.

Như Mark (Amery) lưu ý chính xác: Sử dụng trình giải nén của PyYaml trên bãi chứa json chỉ hoạt động nếu bạn chỉ có ASCII. Ít nhất là ra khỏi hộp.

Hai nhận xét nhanh về phương pháp PyYaml:

1. KHÔNG BAO GIỜ sử dụng yaml.load trên dữ liệu từ trường. Đây là một tính năng (!) Của yaml để thực thi mã tùy ý ẩn trong cấu trúc.

2. Bạn cũng có thể làm cho nó hoạt động cho cả ASCII thông qua điều này:

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

Nhưng hiệu suất khôn ngoan không so sánh với câu trả lời của Mark Amery:

Ném một số mẫu được lồng sâu vào hai phương thức, tôi nhận được điều này (với dt [j] = delta delta của json.loads (json.dumps (m))):

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

Vì vậy, khử lưu huỳnh bao gồm đi bộ hoàn toàn cây và mã hóa, theo thứ tự độ lớn của việc thực hiện dựa trên C của json. Tôi thấy điều này nhanh đáng kể và nó cũng mạnh hơn tải trọng yaml tại các cấu trúc lồng nhau sâu. Và ít có lỗi bảo mật hơn, nhìn vào yaml.load.

=> Mặc dù tôi sẽ đánh giá cao một con trỏ tới bộ chuyển đổi chỉ dựa trên C, hàm byteify sẽ là câu trả lời mặc định.

Điều này đặc biệt đúng nếu cấu trúc json của bạn là từ trường, chứa đầu vào của người dùng. Bởi vì sau đó bạn có thể cần phải đi bộ nào trên cấu trúc của bạn - độc lập về mong muốn cấu trúc dữ liệu nội bộ của bạn ( 'bánh sandwich unicode' hoặc các chuỗi byte chỉ).

Tại sao?

Chuẩn hóa Unicode . Đối với những người không biết: Hãy uống thuốc giảm đau và đọc nó .

Vì vậy, bằng cách sử dụng đệ quy byteify, bạn giết hai con chim bằng một hòn đá:

1. nhận được bytestrings của bạn từ bãi rác json lồng nhau
2. lấy giá trị đầu vào của người dùng được chuẩn hóa, để bạn tìm thấy nội dung trong bộ lưu trữ của mình.

Trong các thử nghiệm của tôi, hóa ra việc thay thế input.encode ('utf-8') bằng unicodingata.n normalize ('NFC', input) .encode ('utf-8') thậm chí còn nhanh hơn w / o NFC - nhưng Điều đó phụ thuộc rất nhiều vào dữ liệu mẫu mà tôi đoán.

Gotcha là thế simplejsonvà jsonlà hai mô-đun khác nhau, ít nhất là theo cách chúng xử lý unicode. Bạn có jsontrong py 2.6+ và điều này cung cấp cho bạn các giá trị unicode, trong khi simplejsontrả về các đối tượng chuỗi. Chỉ cần thử easy_install-ing Simplejson trong môi trường của bạn và xem nó có hoạt động không. Nó đã làm cho tôi.

Chỉ cần sử dụng dưa chua thay vì json để đổ và tải, như vậy:

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

Đầu ra mà nó tạo ra là (chuỗi và số nguyên được xử lý chính xác):

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

Vì vậy, tôi đã gặp vấn đề tương tự. Đoán kết quả đầu tiên của Google là gì.

Vì tôi cần chuyển tất cả dữ liệu cho PyGTK, nên chuỗi unicode cũng không hữu ích cho tôi. Vì vậy, tôi có một phương pháp chuyển đổi đệ quy khác. Nó thực sự cũng cần thiết cho chuyển đổi JSON an toàn - json.dump () sẽ bảo lãnh cho bất kỳ người không biết chữ nào, như các đối tượng Python. Không chuyển đổi chỉ mục dict mặc dù.

# 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

Tôi đã có một dict JSON như một chuỗi. Các khóa và giá trị là các đối tượng unicode như trong ví dụ sau:

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

Tôi có thể sử dụng byteifyhàm được đề xuất ở trên bằng cách chuyển đổi chuỗi thành một dictđối tượng bằng cách sử dụng ast.literal_eval(myStringDict).

Hỗ trợ Python2 & 3 bằng cách sử dụng hook (từ 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)

Trả về:

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

Đây là trò chơi muộn, nhưng tôi đã xây dựng caster đệ quy này. Nó hoạt động cho nhu cầu của tôi và tôi nghĩ nó tương đối đầy đủ. Nó có thể giúp bạn.

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

Chỉ cần truyền cho nó một đối tượng JSON như vậy:

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

Tôi có nó như là một thành viên tư nhân của một lớp, nhưng bạn có thể sử dụng lại phương thức mà bạn thấy phù hợp.

Tôi viết lại _parse_json () của Wells để xử lý các trường hợp trong đó đối tượng json là một mảng (trường hợp sử dụng của tôi).

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

đây là một bộ mã hóa đệ quy được viết bằng C: https://github.com/axiros/nested_encode

Chi phí hoạt động cho các cấu trúc "trung bình" khoảng 10% so với 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%

sử dụng cấu trúc này:

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)

Với Python 3.6, đôi khi tôi vẫn gặp phải vấn đề này. Ví dụ: khi nhận được phản hồi từ API REST và tải văn bản phản hồi vào JSON, tôi vẫn nhận được các chuỗi unicode. Tìm thấy một giải pháp đơn giản bằng cách sử dụng json.dumps ().

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

Tôi cũng gặp phải vấn đề này và phải xử lý JSON, tôi đã nghĩ ra một vòng lặp nhỏ chuyển đổi các khóa unicode thành chuỗi. (simplejson trên GAE không trả về khóa chuỗi.)

obj là đối tượng được giải mã từ 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()

kwargslà những gì tôi chuyển đến hàm tạo của ứng dụng GAE (không thích unicodecác khóa trong **kwargs)

Không mạnh mẽ như giải pháp từ Wells, nhưng nhỏ hơn nhiều.

Tôi đã điều chỉnh mã từ câu trả lời của Mark Amery , đặc biệt là để loại bỏ isinstancenhững ưu điểm của việc gõ vịt.

Việc mã hóa được thực hiện thủ công và ensure_asciibị vô hiệu hóa. Các tài liệu trăn json.dumpnói rằng

Nếu notify_ascii là True (mặc định), tất cả các ký tự không phải ASCII trong đầu ra sẽ được thoát với các chuỗi \ uXXXX

Disclaimer: trong doctest tôi đã sử dụng ngôn ngữ Hungary. Một số mã hóa ký tự liên quan đến Hungary đáng chú ý là: mã hóa cp852IBM / OEM được sử dụng, vd. trong DOS (đôi khi được gọi là ascii , tôi nghĩ không chính xác, nó phụ thuộc vào cài đặt codepage ), cp1250được sử dụng , vd. trong Windows (đôi khi được gọi là ansi , phụ thuộc vào cài đặt ngôn ngữ) và iso-8859-2đôi khi được sử dụng trên các máy chủ http. Văn bản kiểm tra Tüskéshátú kígyóbűvölőđược quy cho Koltai László (mẫu tên cá nhân bản địa) và từ 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)

Tôi cũng muốn làm nổi bật câu trả lời của Jarret Hardie tham chiếu thông số JSON , trích dẫn:

Chuỗi là một tập hợp gồm 0 hoặc nhiều ký tự Unicode

Trong trường hợp sử dụng của tôi, tôi đã có các tập tin với json. Chúng là utf-8các tập tin được mã hóa. ensure_asciidẫn đến các tệp json được thoát đúng nhưng không dễ đọc, đó là lý do tại sao tôi đã điều chỉnh câu trả lời của Mark Amery để phù hợp với nhu cầu của mình.

Các doctest không đặc biệt chu đáo nhưng tôi chia sẻ mã với hy vọng rằng nó sẽ hữu ích cho ai đó.

Kiểm tra câu trả lời này cho một câu hỏi tương tự như thế này nói rằng

Tiền tố chỉ có nghĩa là bạn có một chuỗi Unicode. Khi bạn thực sự sử dụng chuỗi, nó sẽ không xuất hiện trong dữ liệu của bạn. Đừng bị ném bởi đầu ra in.

Ví dụ: thử điều này:

print mail_accounts[0]["i"]

Bạn sẽ không nhìn thấy một u.