我正在使用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，即Python 3及以上版本。
虽然这里有一些好的答案，但我最终使用PyYAML来解析我的JSON文件，因为它将键和值作为str类型字符串而不是unicode类型。因为JSON是YAML的子集，所以它可以很好地工作：
>>> 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就是我在测试中所需的全部。
object_hook使用，因为它可能会在处理大文件时提高性能。请参见稍微复杂一些的来自Mirec Miskuf的答案。yaml.load(json.dumps([u'a', u'£', u'É']))，你会发现返回值是 ['a', u'\xa3', u'\xc9']（其中包含 unicode 字符串）。如果你不能确定你的数据只包含 ASCII 字符集中的字符，你应该使用另一种方法（我推荐我的答案）。 - Mark Amery[u'a', u'b']，请小心。 - Carlos Calla没有内置选项可以使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 调用中获取的输出上调用此函数。
需要注意几点：
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_hook 或 object_pairs_hook 参数来避免。目前唯一成功实现了这一点的是Mirec Miskuf 的答案，但相应地，它比我的方法复杂得多。object_pairs_hook方法可能比这个稍微难理解一点（您需要了解参数的工作原理以及为什么列表和字典需要不同的处理方式），而且大多数人不会关心性能优势...但我希望它存在，特别是对于处理异常深度嵌套的JSON对象的任何人。 - Mark Ameryobject_hook的解决方案这适用于Python 2.7和3.x。
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 isinstance(data, str):
return data
# 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.items() # changed to .items() for Python 2.7/3
}
# Python 3 compatible duck-typing
# If this is a Unicode string, return its string representation
if str(type(data)) == "<type 'unicode'>":
return data.encode('utf-8')
# If it's anything else, return it in its original form
return data
示例用法：
>>> <b><i>json_loads_byteified('{"Hello": "World"}')</i></b>
{'Hello': 'World'}
>>> <b><i>json_loads_byteified('"I am a top-level string"')</i></b>
'I am a top-level string'
>>> <b><i>json_loads_byteified('7')</i></b>
7
>>> <b><i>json_loads_byteified('["I am inside a list"]')</i></b>
['I am inside a list']
>>> <b><i>json_loads_byteified('[[[[[[[["I am inside a big nest of lists"]]]]]]]]')</i></b>
[[[[[[[['I am inside a big nest of lists']]]]]]]]
>>> <b><i>json_loads_byteified('{"foo": "bar", "things": [7, {"qux": "baz", "moo": {"cow": ["milk"]}}]}')</i></b>
{'things': [7, {'qux': 'baz', 'moo': {'cow': ['milk']}}], 'foo': 'bar'}
>>> <b><i>json_load_byteified(open('somefile.json'))</i></b>
{'more json': 'from a file'}Mark Amery的函数比这些函数更短、更清晰，那么它们的意义何在？为什么要使用它们？
纯粹是为了性能。Mark的答案首先使用Unicode字符串完全解码JSON文本，然后递归整个解码值以将所有字符串转换为字节字符串。这有一些不良影响：
这个答案通过使用json.load和json.loads的object_hook参数来缓解这两个性能问题。从文档中可以看出：
object_hook是一个可选函数，它将被调用与任何对象文本解码（一个dict）的结果。object_hook的返回值将被用于代替dict。这个特性可以用来实现自定义解码器。
由于嵌套在其他字典中的字典会在object_hook 解码时被传递，因此我们可以在那个点上将其中的任何字符串或列表变成字节，并避免以后进行深度递归。
Mark的答案不能作为object_hook使用，因为它递归进入嵌套的字典。我们通过_byteify的ignore_dicts参数在这个答案中防止了递归，该参数在除了object_hook将一个新的dict传递给它以外的所有时间都被传递给它。 ignore_dicts标志告诉_byteify忽略dict，因为它们已经被转换成字节。
最后，我们的json_load_byteified和json_loads_byteified的实现调用json.load或json.loads返回的结果上的_byteify（带有ignore_dicts=True），以处理解码文本顶层没有dict的情况。
return dict((_byteify(key, ignore_dicts=True), _byteify(value, ignore_dicts=True)) for key, value in data.iteritems()) 才能使其正常工作。 - Richard Dunnobject_hook只会在每个字典/对象上调用，而不是在每个列表/数组上调用，因此你的特定测试没有显示出我所描述的递归限制的避免是不足为奇的。请改为使用深度嵌套的字典/对象进行重试，我相信你会看到不同的结果！ - Mark Ameryif isinstance(data, unicode):
return data.encode('utf-8')
if isinstance(data, list):
return [ _byteify(item) for item in data ]
if isinstance(data, dict):
return {
_byteify(key): _byteify(value)
for key, value in data.iteritems()
}
return data - Ram Sharan Mittaljson.loads的object_hook参数来传递转换器。您不必事后进行转换。json模块将始终仅传递object_hook字典，并且它将递归地传入嵌套字典，因此您不必自己递归到嵌套字典中。我认为不应该像Wells shows那样将Unicode字符串转换为数字。如果它是Unicode字符串，则在JSON文件中将其引用为字符串，因此应该是字符串（或文件有问题）。
另外，我建议避免在unicode对象上执行类似于str(val)这样的操作。您应该使用具有有效编码的value.encode(encoding)，具体取决于您的外部库需要什么。
所以，例如：
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)
s中的对象是JSON Object（一个无序的键值对集合，用冒号':'分隔键和值，逗号分隔并用花括号括起来），那么这个方法是有效的。但如果它是一个JSON Array，比如["a", "b"]，那么结果仍然会是[u'a', u'b']。目前json.loads()提供的其他自定义钩子类型参数也无法实现这一功能。 - martineaujson模块将递归传递嵌套的dict，因此在这两个函数中检查它们是不必要的 - 因此应该删除检查它们的两个elif子句。 - martineaufrom Utility import *，那么由于那个下划线，这些函数将不会被识别。 - M Katzobject_hook会在解析每个JSON对象时被调用，因此如果您递归到所给出的内容中，那么您正在重新“字节化”已经“字节化”的内容。性能将随着对象大小的增长而呈几何级数增长。我在这里提供了一个答案，使用object_pairs_hook并且不会遇到这个问题。链接 - Travis Jensenunicode对象（即，JSON（JavaScript）字符串可以存储任何类型的Unicode字符），因此在从JSON翻译字符串时创建unicode对象是有意义的。普通字符串就不适合，因为库必须猜测您想要的编码方式。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()。两者都在标准库中。
虽然不是一个“完美”的答案，但如果您打算完全忽略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字符串时，情况就变得更加复杂了。完整的答案很快就会变得棘手。
null、true或false值，因为它们在Python中无效，会导致literal_eval()失败。 - ʇsәɹoɈ\/），或者 Unicode 转义序列（比如 "\u0061"，也可以写成 "a"）。Python 的字面语法和 JSON 在几个方面是不兼容的，如果我不是要扔掉这个脚本，我就不会相信这个答案。 - Mark Ameryjson转储数据，只需在运行Python时使用print。然后使用ast.literal_eval即可。 - Jean-François Fabre迈克·布伦南（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对象中每个对象都少实例化一个字典，如果你正在解析一个庞大的文档，这可能是值得的。
deunicodify_hook中正确处理列表呢？目前，您有一个deunicodify_hook的实现，它不会迭代列表并对其中的字符串和列表进行解码，因此您展示的输出不与您的钩子实际产生的输出匹配。修复这个问题，这个答案将优于我的。 - Mark Ameryobject_pairs_hook 仅在 对象 中调用，如果您的 JSON 文本在顶层具有字符串列表，则此解决方案将失败。 没有办法修复这个问题，除非对从 json.load 返回的东西调用一些函数； json.load 钩子中没有一个可以保证您能够处理每个字符串。 我认为这是足够严重的缺陷，因此我仍然建议使用我的解决方案而不是使用钩子。 - Mark Amery很抱歉，simplejson库中没有自动实现此功能的方法。
simplejson中的扫描器和解码器被设计用于生成Unicode文本。为此，该库使用一个名为c_scanstring（如果可用，用于提高速度）或py_scanstring（如果C版本不可用）的函数。几乎每个用于解码可能包含文本的结构的simplejson例程都会多次调用scanstring函数。您必须要么猴子补丁simplejson.decoder中的scanstring值，要么子类化JSONDecoder并提供几乎完全由您自己实现的任何可能包含文本的内容。
scanstring 实现甚至扫描并解释Inicode转义（甚至检查有误的多字节字符集表示形式），所以它能够可靠地将值返回给您，唯一的方式就是作为Unicode格式。str的旧库，我建议您要么在解析之后费力地搜索嵌套数据结构（这正是您明确说想避免的...抱歉），要么在某种外观中包装您的库，以便您可以在更细粒度的级别上调整输入参数。如果您的数据结构确实是深度嵌套的，则第二种方法可能比第一种更可管理。正如Mark (Amery)正确指出的那样：在JSON转储上使用PyYAML的反序列化器仅在您只有ASCII时才起作用。至少是开箱即用的。
关于PyYAML方法的两个快速评论：
Never use yaml.load() on data from the field. It’s a feature(!) of YAML to execute arbitrary code hidden within the structure.
You can make it work also for non ASCII via this:
def to_utf8(loader, node):
return loader.construct_scalar(node).encode('utf-8')
yaml.add_constructor(u'tag:yaml.org,2002:str', to_utf8)
但就性能而言，与Mark Amery的答案无法相比：
将一些深度嵌套的示例字典放入这两种方法中，我得到了以下结果（其中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]
simplejson 和 json 是两个不同的模块，至少在它们处理 Unicode 方式上是如此。在 Python 2.6+ 中有 json，它返回 Unicode 值，而 simplejson 返回字符串对象。
str。 - GoingMyWay