Python 2を使用して、ASCIIエンコードされたテキストファイルからJSONを解析しています。

jsonまたは simplejsonでこれらのファイルをロードすると、すべての文字列値が文字列オブジェクトではなくUnicodeオブジェクトにキャストされます。問題は、文字列オブジェクトのみを受け入れる一部のライブラリでデータを使用する必要があることです。私は、ライブラリを変更することはできませんもそれらを更新します。

Unicodeオブジェクトの代わりに文字列オブジェクトを取得することは可能ですか？

例

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

更新

この質問は、Python 2に悩まされていた昔のことです。今日の簡単でクリーンなソリューションの1つは、Pythonの最新バージョン、つまりPython 3以降を使用することです。

ソリューション 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

使用例：

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

これはどのように機能し、なぜそれを使用するのですか？

マーク・アメリーの機能はこれらのものより短くて明確です、それでそれらのポイントは何ですか？なぜそれらを使いたいのですか？

純粋にパフォーマンスのため。Markの答えは、最初にJSONテキストを完全にUnicode文字列でデコードし、次にデコードされた値全体を再帰してすべての文字列をバイト文字列に変換します。これには、いくつかの望ましくない影響があります。

• デコードされた構造全体のコピーがメモリに作成されます
• JSONオブジェクトが本当に深くネストされている場合（500レベル以上）、Pythonの最大再帰深度に達します

この回答object_hookではjson.load、およびのパラメーターを使用することにより、これらの両方のパフォーマンスの問題を軽減していますjson.loads。ドキュメントから：

object_hookデコードされたオブジェクトリテラル（a dict）の結果で呼び出されるオプションの関数です。の代わりにobject_hookの戻り値が使用されdictます。この機能を使用して、カスタムデコーダーを実装できます。

他のディクショナリの深い階層にネストされたディクショナリobject_hook は、デコードされるときに渡されるため、その時点でそれらの内部の文字列またはリストをバイト化し、後で深い再帰を行う必要をなくすことができます。

マークの答えはobject_hook、ネストされた辞書に再帰するため、現状のままでは適切ではありません。この回答では、へのignore_dictsパラメーターを使用して再帰を防止しています。このパラメーターは_byteify、byteifyに新しいパラメーターを渡す場合を除いて、常に渡されます。フラグが伝え無視して、彼らはすでにbyteifiedされて以来秒。object_hookdictignore_dicts_byteifydict

最後に、デコードされたJSONテキストのトップレベルにaがない場合を処理するために、またはから返された結果を（で）実装しjson_load_byteifiedてjson_loads_byteified呼び出します。_byteifyignore_dicts=Truejson.loadjson.loadsdict

ここにはいくつかの良い答えがありますが、キーと値をタイプではなくタイプ文字列として提供するため、私は最終的にPyYAMLを使用してJSONファイルを解析しました。JSONはYAMLのサブセットであるため、うまく機能します。strunicode

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

ノート

ただし、次の点に注意してください。

• すべてのエントリがASCIIエンコードされているため、文字列オブジェクトを取得します。Unicodeでエンコードされたエントリを使用すると、Unicodeオブジェクトとして返されます —変換はありません！

• PyYAMLのsafe_load関数を（おそらく常に）使用する必要があります。JSONファイルをロードするためにそれを使用する場合、loadとにかく関数の「追加のパワー」は必要ありません。

• あなたは（と仕様のバージョン1.2のためのより多くのサポートを持っているYAMLパーサたい場合は、非常に低い数字を正しく解析する）してみてくださいRuamel YAMLを：pip install ruamel.yamlとimport ruamel.yaml as yaml私のテストに必要なすべての私がいました。

変換

述べたように、変換はありません！ASCII値のみを処理することが確実ではない場合（そして、ほとんどの場合確信が持てない場合）、変換関数を使用することをお勧めします。

私はMark Ameryのものを数回使用しましたが、うまく機能し、非常に使いやすいです。object_hook大きなファイルのパフォーマンスが向上する可能性があるため、代わりに同様の関数を使用することもできます。これについては、Mirec Miskufのもう少し複雑な回答を参照してください。

jsonモジュール関数がUnicode文字列ではなくバイト文字列を返すようにする組み込みオプションはありません。ただし、この短く単純な再帰関数は、デコードされたJSONオブジェクトをUnicode文字列の使用から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

json.loadまたはjson.loads呼び出しから取得した出力でこれを呼び出すだけです。

いくつかのメモ：

• Pythonの2.6またはそれ以前のバージョンをサポートするために、交換するreturn {byteify(key): byteify(value) for key, value in input.iteritems()}とreturn dict([(byteify(key), byteify(value)) for key, value in input.iteritems()])辞書内包表記はPython 2.7まではサポートされていなかったことから、。
• この回答はデコードされたオブジェクト全体で再帰するため、object_hookor object_pairs_hookパラメータを非常に慎重に使用することで回避できる、いくつかの望ましくないパフォーマンス特性があります。これまでのところ、Mirec Miskufの答えは、これを正しく管理できた唯一の回答ですが、結果として、私のアプローチよりもはるかに複雑になっています。

object_hookパラメータを使用json.loadsしてコンバータに渡すことができます。事後に変換を行う必要はありません。jsonモジュールは常に合格するobject_hookだけdictsを、そしてあなたは、ネストされたdictsに自分自身を再帰的にする必要はありませんので、それは再帰的に、ネストされたdictsに渡します。Wellsのショーのように、Unicode文字列を数値に変換するとは思いません。Unicode文字列の場合、JSONファイルでは文字列として引用されているため、文字列であると想定されます（またはファイルが不良です）。

また、私のような何かやって回避しようと思いますstr(val)上のunicodeオブジェクトを。value.encode(encoding)外部libが期待するものに応じて、有効なエンコーディングで使用する必要があります。

したがって、たとえば：

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)

これは、jsonが文字列オブジェクトとUnicodeオブジェクトの間に違いがないためです。それらはすべてJavaScriptの文字列です。

JSONはUnicodeオブジェクトを返すのに適していると思います。実際、JavaScript文字列は実際にはunicodeオブジェクト（つまり、JSON（JavaScript）文字列はあらゆる種類のUnicode 文字を格納できる）であるため、これ以上何も受け入れませんunicode。JSONから文字列を変換するときにオブジェクトを作成するのは理にかなっています。ライブラリは必要なエンコーディングを推測する必要があるため、プレーンな文字列は適合しません。

unicodeどこでも文字列オブジェクトを使用することをお勧めします。したがって、ライブラリを更新してUnicodeオブジェクトを処理できるようにするのが最善の方法です。

ただし、バイト文字列が本当に必要な場合は、結果を任意のエンコーディングにエンコードするだけです。

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

簡単な回避策があります。

TL; DR-のast.literal_eval()代わりに使用しますjson.loads()。astとjsonは両方とも標準ライブラリにあります。

「完全な」答えではありませんが、Unicodeを完全に無視するという計画の場合、かなり遠くまで届きます。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))

与える：

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

一部のオブジェクトが実際にUnicode文字列である場合、これはさらに複雑になります。完全な答えはすぐにわかりにくくなります。

Mike Brennanの答えは近いですが、構造全体を再走査する理由はありません。object_hook_pairs（Python 2.7+）パラメータを使用する場合：

object_pairs_hookペアの順序付きリストでデコードされたオブジェクトリテラルの結果で呼び出されるオプションの関数です。の戻り値がのobject_pairs_hook代わりに使用されdictます。この機能を使用して、キーと値のペアがデコードされる順序に依存するカスタムデコーダーを実装できます（たとえば、collections.OrderedDict挿入の順序を記憶します）。object_hookも定義されている場合は、object_pairs_hookが優先されます。

これにより、各JSONオブジェクトが渡されるので、再帰を必要とせずにデコードを実行できます。

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

を使用するとすべてのオブジェクトがフックに渡されるため、フックを再帰的に呼び出す必要がないことに注意してくださいobject_pairs_hook。リストを気にする必要はありますが、ご覧のとおり、リスト内のオブジェクトは適切に変換され、それを実行するために再帰する必要はありません。

編集：同僚は、Python2.6にはがないことを指摘しましたobject_hook_pairs。非常に小さな変更を加えるだけで、Python2.6を使用できます。上記のフックで、次のように変更します。

for key, value in pairs:

に

for key, value in pairs.iteritems():

次にのobject_hook代わりに使用します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'}}

object_pairs_hook結果を使用すると、JSONオブジェクトの各オブジェクトに対してインスタンス化される辞書が1つ少なくなります。これは、巨大なドキュメントを解析している場合、価値があるかもしれません。

simplejsonライブラリ内でこれを自動的に達成する方法はないと思います。

simplejsonのスキャナーとデコーダーは、Unicodeテキストを生成するように設計されています。これを行うために、ライブラリはc_scanstring（使用可能な場合は、速度を上げるために）と呼ばれる関数を使用するpy_scanstringか、Cバージョンが使用できない場合に使用します。scanstring関数はのsimplejsonにテキストが含まれている可能性がある構造を復号するための持っているほぼすべてのルーチンで数回呼ばれています。simplejson.decoderのscanstring値をサルパッチするか、サブクラスJSONDecoderを作成して、テキストを含む可能性のあるものの独自の実装全体を提供する必要があります。

ただし、simplejsonがUnicodeを出力するのは、jsonの仕様に「文字列は0個以上のUnicode文字のコレクションである」と明記されているためです... Unicodeのサポートは、フォーマット自体の一部と見なされます。Simplejsonのscanstring実装は、Unicodeエスケープのスキャンと解釈にまで及んでいるため（不正なマルチバイト文字セット表現のエラーチェックでも）、確実に値を返す唯一の方法は、Unicodeとしてです。

を必要とする古くなったライブラリがある場合は、str解析後に入れ子になったデータ構造を手間をかけて検索するか（申し訳ありませんが、申し訳ありませんが...）より詳細なレベルで入力パラメーターをマッサージできるファサード。データ構造が実際に深くネストされている場合、2番目のアプローチは最初のアプローチよりも管理しやすくなる可能性があります。

Mark（Amery）が正しく注記しているように、jsonダンプでPyYamlのデシリアライザを使用できるのは、ASCIIしか使用できない場合のみです。少なくとも箱から出して。

PyYamlアプローチに関する2つの簡単なコメント：

1. NEVERフィールドからのデータのyaml.loadを使用していません。構造内に隠された任意のコードを実行するためのyamlの機能（！）

2. 次のようにして、非ASCIIでも機能させることができます。

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

しかし、パフォーマンスに関しては、マークアメリーの回答とは比較になりません。

2つのメソッドに深くネストされたサンプル辞書をいくつか投げると、これが得られます（dt [j] = json.loads（json.dumps（m）の時間デルタ））：

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

したがって、jsonのCベースの実装とほぼ同じ大きさで、ツリーの完全なウォーキングとエンコーディングを含む逆シリアル化を行います。これは非常に高速で、深くネストされた構造でのyamlロードよりも堅牢であることがわかります。yaml.loadを見ると、セキュリティエラーが発生しにくくなります。

=> Cのみに基づくコンバーターへのポインターに感謝しますが、byteify関数がデフォルトの答えになるはずです。

これは、json構造がユーザー入力を含むフィールドからのものである場合に特に当てはまります。おそらく、とにかくあなたの構造の上を歩く必要があるからです -希望する内部データ構造（「ユニコードサンドイッチ」またはバイト文字列のみ）とは無関係です。

どうして？

Unicodeの正規化。気づかない場合：鎮痛剤を服用してこれを読んでください。

したがって、byteify再帰を使用して、1石で2羽の鳥を殺します。

1. ネストされたjsonダンプからバイト文字列を取得する
2. 正規化されたユーザー入力値を取得して、ストレージにあるものを見つけます。

私のテストでは、input.encode（ 'utf-8'）をunicodedata.normalize（ 'NFC'、input）.encode（ 'utf-8'）で置き換えることは、NFCを使用しない場合よりもさらに高速であることがわかりましたが、それは私が推測するサンプルデータに大きく依存しています。

落とし穴があることsimplejsonとjson、少なくともそれらがユニコードを扱うようにして、二つの異なるモジュールです。あなたはjsonpy 2.6+を持っています、そしてこれはあなたにユニコード値を与えますsimplejsonが、文字列オブジェクトを返します。環境でeasy_install-ing simplejsonを試してみて、それが機能するかどうかを確認してください。それは私のためにした。

ダンプとロードには、jsonの代わりにpickleを使用するだけです。

    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'field2': 2, u'field1': u'value1'}
    {'field2': 2, 'field1': 'value1'}

だから、私は同じ問題に遭遇しました。最初のGoogleの結果を推測してください。

すべてのデータをPyGTKに渡す必要があるため、Unicode文字列もあまり役に立ちません。だから私は別の再帰的な変換方法を持っています。タイプセーフなJSON変換にも実際に必要です。json.dump（）は、Pythonオブジェクトのような非リテラルをベイルします。ただし、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

文字列としてJSON dictがありました。キーと値は、次の例のようなUnicodeオブジェクトでした。

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

私は使うことができました byteify上記関数をて文字列をdictオブジェクトに変換しますast.literal_eval(myStringDict)。

フックを使用してPython2＆3をサポートします（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)

戻り値：

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

これはゲームに遅れますが、私はこの再帰キャスターを作成しました。それは私のニーズに合っており、比較的完成していると思います。それはあなたを助けるかもしれません。

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

次のようにJSONオブジェクトを渡すだけです。

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

クラスのプライベートメンバーとして持っていますが、必要に応じてメソッドを再利用できます。

Wellsの_parse_json（）を書き直して、jsonオブジェクト自体が配列である場合（私の使用例）を処理しました。

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

これはCで書かれた再帰的なエンコーダです：https : //github.com/axiros/nested_encode

json.loadsと比較して、「平均的な」構造のパフォーマンスオーバーヘッドは約10％です。

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%

このテスト構造を使用して：

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)

Python 3.6では、まだこの問題が発生することがあります。たとえば、REST APIから応答を取得し、応答テキストをJSONにロードしても、Unicode文字列を取得します。json.dumps（）を使用した簡単な解決策が見つかりました。

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

私もこの問題に遭遇し、JSONを処理する必要があるため、Unicodeキーを文字列に変換する小さなループを思いつきました。（simplejsonGAEでは文字列キーを返しません。）

obj 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()

kwargsGAEアプリケーションのコンストラクターに渡すものです（これはのunicodeキーが好きではありません**kwargs）。

Wellsのソリューションほど堅牢ではありませんが、はるかに小さいです。

私はからコード適応してきた答えのマークアメリーを特にを取り除くために、isinstanceダックタイピングの長所のために。

エンコードは手動で行われ、ensure_ascii無効になっています。のPythonドキュメントjson.dumpはそれを言っています

Ensure_asciiがTrue（デフォルト）の場合、出力内のすべての非ASCII文字は\ uXXXXシーケンスでエスケープされます

免責事項：doctestでは、ハンガリー語を使用しました。いくつかの注目すべきハンガリー関連の文字エンコーディングは、次のとおりcp852です。DOSで（asciiと呼ばれることもありますが、誤ってコードページ設定に依存していると思います）cp1250。Windowsでは（ロケール設定に応じてansiと呼ばれることもあります）、iso-8859-2httpサーバーで使用されることもあります。テストテキストTüskéshátú kígyóbűvölőはKoltaiLászló（ネイティブの個人名フォーム）によるもので、ウィキペディアからのものです。

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

私は思いも強調したいの答えのジャレットハーディ参照JSONの仕様を引用：

文字列は0個以上のUnicode文字のコレクションです

私のユースケースでは、jsonのファイルがありました。それらはutf-8エンコードされたファイルです。ensure_ascii結果は適切にエスケープされますが、あまり読み込めないjsonファイルになります。そのため、Mark Ameryの回答を自分のニーズに合わせて調整しました。

doctestは特に思慮深いものではありませんが、誰かに役立つことを期待してコードを共有しています。

このような同様の質問に対するこの回答を確認してください

u-接頭辞は、Unicode文字列があることを意味します。文字列を実際に使用すると、データに表示されません。印刷された出力によってスローされません。

たとえば、これを試してください：

print mail_accounts[0]["i"]

uは表示されません。