Comment JSON sérialiser des jeux?

JSON notation a seulement une poignée de native types de données (objets, tableaux, chaînes de caractères, des nombres, booléens, et null), donc tout ce que sérialisé en JSON doit être exprimé en tant que l'un de ces types.

Comme indiqué dans le json module docs, cette conversion peut être effectuée automatiquement par un JSONEncoder et JSONDecoder, mais alors vous seriez en donnant une autre structure que vous pourriez avoir besoin (si vous convertissez des ensembles d'une liste, puis de vous perdre la capacité de récupérer régulièrement des listes; si vous convertissez des ensembles d'un dictionnaire à l'aide de dict.fromkeys(s) alors vous perdez la capacité de récupérer des dictionnaires).

Une solution plus élaborée est de construire un type personnalisé qui peut coexister avec d'autres natif JSON types. Cela vous permet de stocker des structures imbriquées qui incluent des listes, ensembles, dicts, les décimales, datetime objets, etc.:

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

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

def as_python_object(dct):
    if '_python_object' in dct:
        return pickle.loads(str(dct['_python_object']))
    return dct

Voici un exemple de session, en montrant qu'il peut gérer des listes, des dicts, et définit:

>>> 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']), {u'key': u'value'}, Decimal('3.14')]

Alternativement, il peut être utile d'utiliser un objectif général de sérialisation technique comme YAML, Twisted Jelly, ou Python module pickle. Ces chacun en charge une gamme de types de données.

Seulement dictionnaires, Listes et objet primitif types (int, string, bool) sont disponibles en JSON.

Si vous avez seulement besoin de coder des jeux, pas en général des objets Python, et que vous voulez la garder facilement lisible par l'homme, une version simplifiée de Raymond Hettinger de réponse peuvent être utilisés:

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