Jak serializować zestawy JSON?

Mam Python set, który zawiera obiekty z __hash__i __eq__metod w celu dokonania pewnych duplikatów nie są zawarte w zbiorze.

Muszę zakodować ten wynik w setformacie json , ale przekazanie nawet pustego elementu setdo json.dumpsmetody wywołuje 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

Wiem, że mogę utworzyć rozszerzenie json.JSONEncoderklasy, która ma niestandardową defaultmetodę, ale nie jestem nawet pewien, od czego zacząć konwertowanie na set. Czy powinienem utworzyć słownik z setwartości w metodzie domyślnej, a następnie zwrócić kodowanie? Idealnie chciałbym, aby domyślna metoda była w stanie obsłużyć wszystkie typy danych, na których dusi oryginalny koder (używam Mongo jako źródła danych, więc daty wydają się również powodować ten błąd)

Każda wskazówka we właściwym kierunku będzie mile widziana.

EDYTOWAĆ:

Dziękuję za odpowiedź! Może powinienem był być bardziej precyzyjny.

Wykorzystałem (i przegłosowałem) odpowiedzi tutaj, aby ominąć ograniczenia settłumaczenia, ale istnieją również klucze wewnętrzne, które również stanowią problem.

Obiekty w pliku setsą złożonymi obiektami, które są tłumaczone na __dict__, ale same mogą również zawierać wartości swoich właściwości, które mogą nie kwalifikować się do podstawowych typów w koderze json.

Wchodzi w to wiele różnych typów set, a hash w zasadzie oblicza unikalny identyfikator jednostki, ale w prawdziwym duchu NoSQL nie można dokładnie określić, co zawiera obiekt potomny.

Jeden obiekt może zawierać wartość daty dla starts, podczas gdy inny może mieć inny schemat, który nie zawiera kluczy zawierających obiekty „nieprymitywne”.

Dlatego jedynym rozwiązaniem, jakie przyszło mi do głowy, było rozszerzenie, JSONEncoderaby zastąpić defaultmetodę włączania różnych przypadków - ale nie jestem pewien, jak się do tego zabrać, a dokumentacja jest niejednoznaczna. Czy w obiektach zagnieżdżonych wartość zwracana defaultprzechodzi przez klucz, czy jest to tylko ogólne dołączenie / odrzucenie, które patrzy na cały obiekt? W jaki sposób ta metoda obsługuje zagnieżdżone wartości? Przejrzałem poprzednie pytania i nie mogę znaleźć najlepszego podejścia do kodowania specyficznego dla przypadku (co niestety wydaje się być tym, co będę musiał tutaj zrobić).

Notacja JSON ma tylko kilka rodzimych typów danych (obiekty, tablice, ciągi, liczby, wartości logiczne i null), więc wszystko, co jest serializowane w JSON, musi być wyrażone jako jeden z tych typów.

Jak pokazano w dokumentacji modułu json , ta konwersja może być wykonana automatycznie przez JSONEncoder i JSONDecoder , ale wtedy zrezygnujesz z innej struktury, której możesz potrzebować (jeśli przekonwertujesz zestawy na listę, stracisz możliwość regularnego odzyskiwania listy; jeśli przekonwertujesz zestawy na słownik za pomocą dict.fromkeys(s), utracisz możliwość odzyskiwania słowników).

Bardziej wyrafinowanym rozwiązaniem jest utworzenie niestandardowego typu, który może współistnieć z innymi natywnymi typami JSON. Pozwala to na przechowywanie zagnieżdżonych struktur, które obejmują listy, zbiory, dykty, liczby dziesiętne, obiekty daty i godziny itp .:

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

Oto przykładowa sesja pokazująca, że ​​może obsługiwać listy, dykty i zestawy:

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

Alternatywnie przydatne może być użycie techniki serializacji bardziej ogólnego przeznaczenia, takiej jak YAML , Twisted Jelly lub Python's pickle module . Każdy z nich obsługuje znacznie większy zakres typów danych.

Możesz utworzyć koder niestandardowy, który zwraca kod, listgdy napotka plik set. Oto przykład:

>>> import json
>>> class SetEncoder(json.JSONEncoder):
...    def default(self, obj):
...       if isinstance(obj, set):
...          return list(obj)
...       return json.JSONEncoder.default(self, obj)
... 
>>> json.dumps(set([1,2,3,4,5]), cls=SetEncoder)
'[1, 2, 3, 4, 5]'

W ten sposób możesz również wykryć inne typy. Jeśli chcesz zachować, że lista była w rzeczywistości zestawem, możesz użyć niestandardowego kodowania. Coś takiego return {'type':'set', 'list':list(obj)}może zadziałać.

Aby zilustrować zagnieżdżone typy, rozważ serializację tego:

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

Powoduje to następujący błąd:

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

Oznacza to, że koder pobierze listzwrócony wynik i rekurencyjnie wywoła serializator w swoich elementach podrzędnych. Aby dodać niestandardowy serializator dla wielu typów, możesz to zrobić:

>>> 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)
... 
>>> json.dumps(set([1,2,3,4,5,Something()]), cls=SetEncoder)
'[1, 2, 3, 4, 5, "CustomSomethingRepresentation"]'

Dostosowałem rozwiązanie Raymonda Hettingera do Pythona 3.

Oto, co się zmieniło:

• unicode zniknął
• zaktualizował wezwanie do rodziców defaultzsuper()
• za pomocą base64serializacji bytestypu do str(ponieważ wydaje się, że bytesw Pythonie 3 nie można przekonwertować na 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')]

W formacie JSON dostępne są tylko słowniki, listy i prymitywne typy obiektów (int, string, bool).

Nie musisz tworzyć niestandardowej klasy kodera, aby dostarczać defaultmetodę - można ją przekazać jako argument słowa kluczowego:

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)

wyniki we [1, 2, 3]wszystkich obsługiwanych wersjach języka Python.

Jeśli potrzebujesz tylko zakodować zestawy, a nie ogólne obiekty Pythona i chcesz, aby były one łatwe do odczytania przez człowieka, możesz użyć uproszczonej wersji odpowiedzi Raymonda Hettingera:

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

Jeśli potrzebujesz tylko szybkiego zrzutu i nie chcesz wdrażać niestandardowego kodera. Możesz użyć następujących:

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

Spowoduje to przekonwertowanie wszystkich zestawów (i innych elementów iteracyjnych) na tablice. Uważaj tylko, że te pola pozostaną tablicami, gdy ponownie przeanalizujesz json. Jeśli chcesz zachować typy, musisz napisać niestandardowy koder.

Jedną z wad przyjętego rozwiązania jest to, że jego dane wyjściowe są bardzo specyficzne dla Pythona. Oznacza to, że jego surowe wyjście json nie może być obserwowane przez człowieka ani załadowane przez inny język (np. Javascript). przykład:

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

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

Dostaniesz:

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

Mogę zaproponować rozwiązanie, które obniża ocenę zestawu do dyktowania zawierającego listę po wyjściu i z powrotem do zestawu po załadowaniu do Pythona za pomocą tego samego kodera, zachowując w ten sposób obserwowalność i agnostycyzm językowy:

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

Co daje ci:

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

Uwaga że serializacja słownika, który ma element z kluczem "__set__", zepsuje ten mechanizm. Więc __set__teraz stał się zarezerwowanym dictkluczem. Oczywiście możesz użyć innego, głębiej zaciemnionego klucza.