Rendre l'objet JSON sérialisable avec un encodeur régulier

comme je l'ai dit dans un commentaire à votre question, après avoir regardé le code source du module json , il ne semble pas se prêter à faire ce que vous voulez. Toutefois, l'objectif pourrait être atteint par ce qui est connu sous le nom de "patching (voir la question Qu'est-ce qu'un patch de singe? ). Cela pourrait être fait dans le script d'initialisation __init__.py de votre paquet et affecterait tous les json module de sérialisation étant donné que les modules sont généralement seulement chargé une fois et le résultat est mis en cache dans sys.modules .

le correctif modifie la méthode par défaut de l'encodeur json default -la méthode par défaut default() .

voici un exemple implémenté comme un module autonome pour simplifier:

Module: make_json_serializable.py

""" Module that monkey-patches json module when it's imported so
JSONEncoder.default() automatically checks for a special "to_json()"
method and uses it to encode the object if found.
"""
from json import JSONEncoder

def _default(self, obj):
    return getattr(obj.__class__, "to_json", _default.default)(obj)

_default.default = JSONEncoder.default  # Save unmodified default.
JSONEncoder.default = _default # Replace it.

son utilisation est triviale puisque le patch est appliqué par simplement importer le module.

exemple de script client:

import json
import make_json_serializable  # apply monkey-patch

class Foo(object):
    def __init__(self, name):
        self.name = name
    def to_json(self):  # New special method.
        """ Convert to JSON format string representation. """
        return '{"name": "%s"}' % self.name

foo = Foo('sazpaz')
print(json.dumps(foo))  # -> "{\"name\": \"sazpaz\"}"

pour conserver l'information de type d'objet, la méthode spéciale peut également l'inclure dans la chaîne retournée:

        return ('{"type": "%s", "name": "%s"}' %
                 (self.__class__.__name__, self.name))

qui produit le JSON suivant qui comprend maintenant le nom de classe:

"{\"type\": \"Foo\", \"name\": \"sazpaz\"}"

encore mieux que d'avoir le remplacement default() chercher une méthode spécialement nommée, serait pour lui d'être en mesure pour sérialiser la plupart des objets Python automatiquement , y compris les instances de classe définies par l'utilisateur, sans avoir besoin d'ajouter une méthode spéciale. Après avoir recherché un certain nombre d'alternatives, ce qui suit qui utilise le module pickle , a semblé le plus proche de cet idéal pour moi:

Module: make_json_serializable2.py

""" Module that imports the json module and monkey-patches it so
JSONEncoder.default() automatically pickles any Python objects
encountered that aren't standard JSON data types.
"""
from json import JSONEncoder
import pickle

def _default(self, obj):
    return {'_python_object': pickle.dumps(obj)}

JSONEncoder.default = _default  # Replace with the above.

bien sûr tout ne peut pas être décapé-les types d'extension par exemple. Cependant il y a des moyens définis pour les gérer par le biais du protocole pickle en écrivant des méthodes spéciales-semblables à ce que vous avez suggéré et que j'ai décrit plus tôt-mais faire cela serait probablement nécessaire pour un nombre beaucoup moins élevé de cas.

quoi qu'il en soit, l'utilisation du protocole pickle signifie également qu'il serait assez facile de reconstruire l'objet Python original en fournissant un argument de fonction personnalisé object_hook sur tous les appels json.loads() qui cherchaient une touche '_python_object' dans le dictionnaire passé. Quelque chose comme:

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

pyobj = json.loads(json_str, object_hook=as_python_object)

si cela doit être fait dans de nombreux endroits, il pourrait être utile de définir une fonction d'enrubannage qui a fourni automatiquement l'argument de mot-clé supplémentaire:

json_pkloads = functools.partial(json.loads, object_hook=as_python_object)

pyobj = json_pkloads(json_str)

naturellement, cela pourrait être patché en singe dans le module json ainsi, ce qui rend la fonction par défaut object_hook (au lieu de None ).

j'ai eu l'idée d'utiliser pickle à partir d'une réponse par Raymond Hettinger à l'autre, la sérialisation JSON question, que je considère comme exceptionnellement crédible ainsi qu'une source officielle (comme en Python core developer).

portabilité à Python 3

le code ci-dessus ne fonctionne pas comme indiqué dans Python 3 parce que json.dumps() renvoie un bytes objet que le JSONEncoder ne peut pas gérer. Toutefois, cette approche est toujours valable. Une façon simple de contourner le l'édition est à latin1 "décoder" la valeur retournée de pickle.dumps() et puis "l'encoder" de latin1 avant de la transmettre à pickle.loads() dans la fonction as_python_object() . Cela fonctionne parce que les chaînes binaires arbitraires sont valides latin1 qui peut toujours être décodé en Unicode et puis encodé à nouveau à la chaîne originale (comme indiqué dans cette réponse par Sven Marnach ).

^{(Bien que ce qui suit fonctionne bien en Python 2, le latin1 décodant et encodant il fait est superflu.)}

from decimal import Decimal

class PythonObjectEncoder(json.JSONEncoder):
    def default(self, obj):
        return {'_python_object': pickle.dumps(obj).decode('latin1')}

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

data = [1,2,3, set(['knights', 'who', 'say', 'ni']), {'key':'value'},
        Decimal('3.14')]
j = json.dumps(data, cls=PythonObjectEncoder, indent=4)
data2 = json.loads(j, object_hook=as_python_object)
assert data == data2  # both should be same