如何 JSON 序列化集合？

Question

我有一个 Python set ，其中包含具有 __hash__ 和 __eq__ 方法的对象，以确保集合中不包含重复项。

我需要对这个结果 set 进行 json 编码，但是即使将空的 set 传递给 json.dumps 方法也会引发 TypeError.

  File "/usr/lib/python2.7/json/encoder.py", line 201, in encode
    chunks = self.iterencode(o, _one_shot=True)
  File "/usr/lib/python2.7/json/encoder.py", line 264, in iterencode
    return _iterencode(o, 0)
  File "/usr/lib/python2.7/json/encoder.py", line 178, in default
    raise TypeError(repr(o) + " is not JSON serializable")
TypeError: set([]) is not JSON serializable

我知道我可以创建一个具有自定义 default 方法的 json.JSONEncoder 类的扩展，但我什至不确定从哪里开始通过 进行转换>设置。我应该根据默认方法中的 set 值创建一个字典，然后返回该字典的编码吗？理想情况下，我想让默认方法能够处理原始编码器阻塞的所有数据类型（我使用 Mongo 作为数据源，因此日期似乎也会引发此错误）

任何正确方向的提示都是赞赏。

编辑：

感谢您的回答！也许我应该更准确一些。

我利用（并赞成）此处的答案来解决正在翻译的 set 的限制，但内部密钥也是一个问题。

set 中的对象是转换为 __dict__ 的复杂对象，但它们本身也可以包含其属性值，这些值可能不适合 json 编码器中的基本类型。

这个集合中有很多不同的类型，散列基本上计算实体的唯一ID，但本着NoSQL的真正精神，无法确切地知道子对象包含什么。

一个对象可能包含开始的日期值，而另一个对象可能具有一些其他模式，其中不包含包含“非原始”对象的键。

这就是为什么我能想到的唯一解决方案是扩展 JSONEncoder 来替换 default 方法以打开不同的情况 - 但我不知道如何去做这和文档是不明确的。在嵌套对象中，从 default 返回的值是按键返回的，还是只是查看整个对象的通用包含/丢弃？该方法如何适应嵌套值？我浏览了之前的问题，似乎找不到特定情况编码的最佳方法（不幸的是，这似乎是我需要在这里做的）。

Answer 1

您可以创建一个自定义编码器，当遇到集合时，该编码器会返回列表。这是一个示例：

import json
class SetEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, set):
            return list(obj)
        return json.JSONEncoder.default(self, obj)

data_str = json.dumps(set([1,2,3,4,5]), cls=SetEncoder)
print(data_str)
# Output: '[1, 2, 3, 4, 5]'

您也可以通过这种方式检测其他类型。如果您需要保留列表实际上是一个集合，则可以使用自定义编码。像 return {'type':'set', 'list':list(obj)} 之类的东西可能会起作用。

为了说明嵌套类型，请考虑对其进行序列化：

class Something(object):
    pass
json.dumps(set([1,2,3,4,5,Something()]), cls=SetEncoder)

这会引发以下错误：

TypeError: <__main__.Something object at 0x1691c50> is not JSON serializable

这表明编码器将获取返回的 list 结果，并在其子级上递归调用序列化器。要为多种类型添加自定义序列化器，您可以执行以下操作：

class SetEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, set):
            return list(obj)
        if isinstance(obj, Something):
            return 'CustomSomethingRepresentation'
        return json.JSONEncoder.default(self, obj)
 
data_str = json.dumps(set([1,2,3,4,5,Something()]), cls=SetEncoder)
print(data_str)
# Output: '[1, 2, 3, 4, 5, "CustomSomethingRepresentation"]'

Answer 2

JSON 表示法只有少数本机数据类型（对象、数组、字符串、数字、布尔值和 null），因此，任何以 JSON 形式序列化的内容都需要表示为这些类型之一。

如 json 模块文档所示，此转换可以通过 JSONEncoder 和 JSONDecoder，但是这样你就会放弃一些你可能需要的其他结构（如果你将集合转换为列表，那么你就失去了恢复常规列表的能力；如果你使用将集合转换为字典dict.fromkeys(s) 然后你就失去了恢复字典的能力）。

更复杂的解决方案是构建可以与其他本机 JSON 类型共存的自定义类型。这使您可以存储包括列表、集合、字典、小数、日期时间对象等的嵌套结构：

from json import dumps, loads, JSONEncoder, JSONDecoder
import pickle

class PythonObjectEncoder(JSONEncoder):
    def default(self, obj):
        try:
            return {'_python_object': pickle.dumps(obj).decode('latin-1')}
        except pickle.PickleError:
            return super().default(obj)

def as_python_object(dct):
    if '_python_object' in dct:
        return pickle.loads(dct['_python_object'].encode('latin-1'))
    return dct

这是一个示例会话，显示它可以处理列表、字典和集合：

>>> data = [1,2,3, set(['knights', 'who', 'say', 'ni']), {'key':'value'}, Decimal('3.14')]

>>> j = dumps(data, cls=PythonObjectEncoder)

>>> loads(j, object_hook=as_python_object)
[1, 2, 3, set(['knights', 'say', 'who', 'ni']), {'key': 'value'}, Decimal('3.14')]

或者，使用更通用的方法可能会很有用目的序列化技术，例如 YAML、Twisted Jelly，或 Python 的 pickle 模块。它们都支持更广泛的数据类型。

Answer 3

您不需要创建自定义编码器类来提供 default 方法 - 它可以作为关键字参数传入：

import json

def serialize_sets(obj):
    if isinstance(obj, set):
        return list(obj)

    return obj

json_str = json.dumps(set([1,2,3]), default=serialize_sets)
print(json_str)

结果为 [1, 2, 3]在所有受支持的 Python 版本中。

Answer 4

如果您确定唯一的不可序列化数据将是 set，那么有一个非常简单（且肮脏）的解决方案：

json.dumps({"Hello World": {1, 2}}, default=tuple)

只有不可序列化数据将使用 给出的函数进行处理默认，因此只有set会被转换为tuple。

Answer 5

我将 Raymond Hettinger 的解决方案改编为 python 3。

以下是更改的内容：

• unicode 消失
• 更新了通过 super() 调用父级的 default
• ，使用 base64 将 bytes 类型序列化为str （因为python 3中的bytes似乎无法转换为JSON）

from decimal import Decimal
from base64 import b64encode, b64decode
from json import dumps, loads, JSONEncoder
import pickle

class PythonObjectEncoder(JSONEncoder):
    def default(self, obj):
        if isinstance(obj, (list, dict, str, int, float, bool, type(None))):
            return super().default(obj)
        return {'_python_object': b64encode(pickle.dumps(obj)).decode('utf-8')}

def as_python_object(dct):
    if '_python_object' in dct:
        return pickle.loads(b64decode(dct['_python_object'].encode('utf-8')))
    return dct

data = [1,2,3, set(['knights', 'who', 'say', 'ni']), {'key':'value'}, Decimal('3.14')]
j = dumps(data, cls=PythonObjectEncoder)
print(loads(j, object_hook=as_python_object))
# prints: [1, 2, 3, {'knights', 'who', 'say', 'ni'}, {'key': 'value'}, Decimal('3.14')]

Answer 6

如果您只需要快速转储并且不想实现自定义编码器。您可以使用以下内容：

json_string = json.dumps(data, iterable_as_array=True)

这会将所有集合（和其他可迭代对象）转换为数组。请注意，当您解析回 JSON 时，这些字段将保留为数组。如果你想保留类型，你需要编写自定义编码器。

另请确保已安装并需要 simplejson。
您可以在 PyPi 上找到它。

Answer 7

JSON 中仅提供字典、列表和原始对象类型（int、string、bool）。

Answer 8

@AnttiHaapala 的缩短版本：

json.dumps(dict_with_sets, default=lambda x: list(x) if isinstance(x, set) else x)

Answer 9

如果您只需要对集合进行编码，而不是一般的 Python 对象，并且希望使其易于人类阅读，则可以使用 Raymond Hettinger 答案的简化版本：

import json
import collections

class JSONSetEncoder(json.JSONEncoder):
    """Use with json.dumps to allow Python sets to be encoded to JSON

    Example
    -------

    import json

    data = dict(aset=set([1,2,3]))

    encoded = json.dumps(data, cls=JSONSetEncoder)
    decoded = json.loads(encoded, object_hook=json_as_python_set)
    assert data == decoded     # Should assert successfully

    Any object that is matched by isinstance(obj, collections.Set) will
    be encoded, but the decoded value will always be a normal Python set.

    """

    def default(self, obj):
        if isinstance(obj, collections.Set):
            return dict(_set_object=list(obj))
        else:
            return json.JSONEncoder.default(self, obj)

def json_as_python_set(dct):
    """Decode json {'_set_object': [1,2,3]} to set([1,2,3])

    Example
    -------
    decoded = json.loads(encoded, object_hook=json_as_python_set)

    Also see :class:`JSONSetEncoder`

    """
    if '_set_object' in dct:
        return set(dct['_set_object'])
    return dct

Answer 10

公认的解决方案的一个缺点是它的输出非常特定于Python。即它的原始 json 输出无法被人类观察或被其他语言（例如 javascript）加载。
示例：

db = {
        "a": [ 44, set((4,5,6)) ],
        "b": [ 55, set((4,3,2)) ]
        }

j = dumps(db, cls=PythonObjectEncoder)
print(j)

会得到你：

{"a": [44, {"_python_object": "gANjYnVpbHRpbnMKc2V0CnEAXXEBKEsESwVLBmWFcQJScQMu"}], "b": [55, {"_python_object": "gANjYnVpbHRpbnMKc2V0CnEAXXEBKEsCSwNLBGWFcQJScQMu"}]}

我可以提出一个解决方案，将集合降级为包含出路列表的字典，并在使用相同编码器加载到 python 时返回到集合，从而保留可观察性和语言不可知论：

from decimal import Decimal
from base64 import b64encode, b64decode
from json import dumps, loads, JSONEncoder
import pickle

class PythonObjectEncoder(JSONEncoder):
    def default(self, obj):
        if isinstance(obj, (list, dict, str, int, float, bool, type(None))):
            return super().default(obj)
        elif isinstance(obj, set):
            return {"__set__": list(obj)}
        return {'_python_object': b64encode(pickle.dumps(obj)).decode('utf-8')}

def as_python_object(dct):
    if '__set__' in dct:
        return set(dct['__set__'])
    elif '_python_object' in dct:
        return pickle.loads(b64decode(dct['_python_object'].encode('utf-8')))
    return dct

db = {
        "a": [ 44, set((4,5,6)) ],
        "b": [ 55, set((4,3,2)) ]
        }

j = dumps(db, cls=PythonObjectEncoder)
print(j)
ob = loads(j)
print(ob["a"])

这可以得到你：

{"a": [44, {"__set__": [4, 5, 6]}], "b": [55, {"__set__": [2, 3, 4]}]}
[44, {'__set__': [4, 5, 6]}]

请注意，序列化包含带有键 "__set__" 元素的字典将破坏此机制。所以 __set__ 现在已经成为保留的 dict 键。显然，可以随意使用另一个更深度混淆的密钥。

Answer 11

>>> import json
>>> set_object = set([1,2,3,4])
>>> json.dumps(list(set_object))
'[1, 2, 3, 4]'

Answer 12

你应该尝试 jsonwhatever

https://pypi.org/project/jsonwhatever/

pip install jsonwhatever

from jsonwhatever import JsonWhatEver

set_a = {1,2,3}

jsonwe = JsonWhatEver()

string_res = jsonwe.jsonwhatever('set_string', set_a)

print(string_res)