Python des objets sérialisables json

class gpagelet:
    """
    Holds   1) the pagelet xpath, which is a string
            2) the list of pagelet shingles, list
    """
    def __init__(self, parent):
        if not isinstance( parent, gwebpage):
            raise Exception("Parent must be an instance of gwebpage")
        self.parent = parent    # This must be a gwebpage instance
        self.xpath = None       # String
        self.visibleShingles = [] # list of tuples
        self.invisibleShingles = [] # list of tuples
        self.urls = [] # list of string

class gwebpage:
    """
    Holds all the datastructure after the results have been parsed
    holds:  1) lists of gpagelets
            2) loc, string, location of the file that represents it
    """
    def __init__(self, url):
        self.url = url              # Str
        self.netloc = False         # Str
        self.gpagelets = []         # gpagelets instance
        self.page_key = ""          # str

Est-il un moyen pour moi de faire ma classe json sérialisable? La chose que je suis inquiet est la référence récursive.

InformationsquelleAutor | 2009-09-22
  1. 48

    Écrire votre propre encodeur et le décodeur, ce qui peut être très simple comme return __dict__

    par exemple, voici un codeur pour vider totalement récursive de l'arbre de la structure, vous pouvez améliorer ou les utiliser comme il est pour votre propre usage

    import json

class Tree(object):
    def __init__(self, name, childTrees=None):
        self.name = name
        if childTrees is None:
            childTrees = []
        self.childTrees = childTrees

class MyEncoder(json.JSONEncoder):
    def default(self, obj):
        if not isinstance(obj, Tree):
            return super(MyEncoder, self).default(obj)

        return obj.__dict__

c1 = Tree("c1")
c2 = Tree("c2") 
t = Tree("t",[c1,c2])

print json.dumps(t, cls=MyEncoder)

    il imprime 

    {"childTrees": [{"childTrees": [], "name": "c1"}, {"childTrees": [], "name": "c2"}], "name": "t"}

    vous pouvez même écrire un décodeur, mais là, vous allez en quelque sorte besoin d'identifier les est il est de votre objet ou pas, donc peut-être vous pouvez mettre un type trop si nécessaire.

    • Cela m'a aidé. Merci. 🙂
    • Documentation pour simplejson explicitement dit que vous devez appeler JSONEncoder.par défaut() pour augmenter le TypeError, donc je pense qu'il serait mieux de remplacer votre relance avec un appel pour que.
    • Ou encore mieux, mettre en place votre propre [simple]json.JSONEncoder sous-classe et de remplacer le default méthode avec une version qui de retour d'un serializable représentation de vos objets ou des appels JSONEncoder.default pour tous les autres types. Voir docs.python.org/library/json.html#json.JSONEncoder.
    • n'est-ce pas Anurag la méthode ci-dessus ne?
    • Mon commentaire est plus ancienne que la dernière modification de la réponse, j'ai donc été probabyl se référant à une version antérieure.
    InformationsquelleAutor Anurag Uniyal
  2. 16

    jsonpickle POUR LA VICTOIRE!

    (Juste eu cette même question... json pickle poignées récursive/objet imbriqué des graphiques ainsi que des courts-circuits pour les graphes d'objets).

    InformationsquelleAutor longda
  3. 5

    Réponse indirecte: au lieu d'utiliser JSON, vous pouvez utiliser YAML, qui n'a pas de problème à faire ce que vous voulez. (JSON est essentiellement un sous-ensemble de YAML.)

    Exemple:

    import yaml
o1 = gwebpage("url")
o2 = gpagelet(o1)
o1.gpagelets = [o2]
print yaml.dump(o1)

    En fait, YAML bien poignées cyclique références pour vous.

    • Ne jamais unpickle données que vous n'avez pas confiance!
    • Article intéressant, mais il y a aucun unpickling dans cette réponse, que décapage (c'est à dire pas de load(), mais dump()).
    • En effet, mais il est utile de garder à l'esprit. En outre, pourquoi voulez-vous pickle quelque chose, sauf si vous avez prévu de l'utiliser plus tard?...
    • En effet. Cependant, il est parfaitement sûr pour load() le YAML dumped par le code ci-dessus (il ne peut pas conduire à l'interprétation du code Python, bar d'un bug dans PyYAML, comme le code source montre [pas de code Python injection...]).
    • Oui, nous sommes d'accord: est coffre-fort dans ce de cas, mais pas nécessairement dans tous cas. Je suis paranoïaque et en extrapolant utiliser à partir de votre exemple. Donc juste (ce qui a commencé comme un petit commentaire.
    InformationsquelleAutor Eric O Lebigot
  4. 3

    J'ai mis en place un système très simple todict méthode avec l'aide de https://stackoverflow.com/a/11637457/1766716

    • Itérer sur les propriétés qui n'est pas commence avec __
    • Éliminer les méthodes
    • Éliminer certaines propriétés manuellement ce qui n'est pas nécessaire (pour mon cas, venant de sqlalcemy)

    Et utilisé getattr pour construire le dictionnaire.

    class User(Base):
    id = Column(Integer, primary_key=True)
    firstname = Column(String(50))
    lastname = Column(String(50))
    password = Column(String(20))
    def props(self):
        return filter(
            lambda a:
            not a.startswith('__')
            and a not in ['_decl_class_registry', '_sa_instance_state', '_sa_class_manager', 'metadata']
            and not callable(getattr(self, a)),
            dir(self))
    def todict(self):
        return {k: self.__getattribute__(k) for k in self.props()}
    InformationsquelleAutor guneysus
  5. 2

    Ma solution pour cela est d'étendre le 'dict' classe et effectuer des contrôles autour obligatoire/attributs autorisés en substituant init, mise à jour, et de définir les méthodes de la classe.

    class StrictDict(dict):
required=set()
at_least_one_required=set()
cannot_coexist=set()
allowed=set()
def __init__(self, iterable={}, **kwargs):
super(StrictDict, self).__init__({})
keys = set(iterable.keys()).union(set(kwargs.keys()))
if not keys.issuperset(self.required):
msg = str(self.__class__.__name__) + " requires: " + str([str(key) for key in self.required])
raise AttributeError(msg)
if len(list(self.at_least_one_required)) and len(list(keys.intersection(self.at_least_one_required))) < 1:
msg = str(self.__class__.__name__) + " requires at least one: " + str([str(key) for key in self.at_least_one_required])
raise AttributeError(msg)
for key, val in iterable.iteritems():
self.__setitem__(key, val)
for key, val in kwargs.iteritems():
self.__setitem__(key, val)
def update(self, E=None, **F):
for key, val in E.iteritems():
self.__setitem__(key, val)
for key, val in F.iteritems():
self.__setitem__(key, val)
super(StrictDict, self).update({})
def __setitem__(self, key, value):
all_allowed = self.allowed.union(self.required).union(self.at_least_one_required).union(self.cannot_coexist)
if key not in list(all_allowed):
msg = str(self.__class__.__name__) + " does not allow member '" + key + "'"
raise AttributeError(msg)
if key in list(self.cannot_coexist):
for item in list(self.cannot_coexist):
if key != item and item in self.keys():
msg = str(self.__class__.__name__) + "does not allow members '" + key + "' and '" + item + "' to coexist'"
raise AttributeError(msg)
super(StrictDict, self).__setitem__(key, value)

    Exemple d'utilisation:

    class JSONDoc(StrictDict):
"""
Class corresponding to JSON API top-level document structure
http://jsonapi.org/format/#document-top-level
"""
at_least_one_required={'data', 'errors', 'meta'}
allowed={"jsonapi", "links", "included"}
cannot_coexist={"data", "errors"}
def __setitem__(self, key, value):
if key == "included" and "data" not in self.keys():
msg = str(self.__class__.__name__) + " does not allow 'included' member if 'data' member is not present"
raise AttributeError(msg)
super(JSONDoc, self).__setitem__(key, value)
json_doc = JSONDoc(
data={
"id": 5,
"type": "movies"
},
links={
"self": "http://url.com"
}
)
    InformationsquelleAutor g.carey