Como você serializar uma instância de modelo no Django?

votos
108

Existe uma grande quantidade de documentação sobre como serializar um QuerySet Modelo mas como é que você só seriar para JSON os campos de uma instância de modelo?

Publicado 16/04/2009 em 17:47
fonte usuário
Em outras línguas...                            


13 respostas

votos
179

Você pode facilmente usar uma lista para embrulhar o objeto desejado e isso é tudo o que django serializers precisa serializar-lo corretamente, por exemplo .:

from django.core import serializers

# assuming obj is a model instance
serialized_obj = serializers.serialize('json', [ obj, ])
Respondeu 20/07/2010 em 11:31
fonte usuário

votos
37

Para evitar o wrapper array, removê-lo antes de retornar a resposta:

import json
from django.core import serializers

def getObject(request, id):
    obj = MyModel.objects.get(pk=id)
    data = serializers.serialize('json', [obj,])
    struct = json.loads(data)
    data = json.dumps(struct[0])
    return HttpResponse(data, mimetype='application/json')

Achei isso interessante post sobre o assunto também:

http://timsaylor.com/convert-django-model-instances-to-dictionaries

Ele usa django.forms.models.model_to_dict, que se parece com a ferramenta perfeita para o trabalho.

Respondeu 14/12/2012 em 20:05
fonte usuário

votos
34

Se você está lidando com uma lista de instâncias do modelo o melhor que pode fazer é usando serializers.serialize(), ele vai caber sua necessidade perfeitamente.

No entanto, você está a enfrentar um problema com a tentativa de serializar um único não objeto, um listdos objetos. Dessa forma, a fim de se livrar de diferentes hacks, basta usar Django model_to_dict(se não me engano, serializers.serialize()confia nele, também):

from django.forms.models import model_to_dict

# assuming obj is your model instance
dict_obj = model_to_dict( obj )

Você agora só precisa de um straight json.dumpschamada para serializar para json:

import json
serialized = json.dumps(dict_obj)

É isso aí! :)

Respondeu 24/02/2016 em 20:57
fonte usuário

votos
9

Parece que você está perguntando sobre envolve a serialização a estrutura de dados de uma instância do modelo Django para a interoperabilidade. Os outros cartazes estão corretas: se você quisesse a forma serializada para ser usado com um aplicativo de python que pode consultar o banco de dados via API do Django, então você wan para serializar um queryset com um objeto. Se, por outro lado, o que você precisa é uma maneira de voltar a inflar a instância de modelo em outro lugar, sem tocar no banco de dados ou sem o uso de Django, então você tem um pouco de trabalho a fazer.

Aqui está o que eu faço:

Em primeiro lugar, eu uso demjsonpara a conversão. Ele passou a ser o que eu encontrei em primeiro lugar, mas pode não ser a melhor. Minha implementação depende de uma de suas características, mas deve haver maneiras semelhantes com outros conversores.

Em segundo lugar, implementar um json_equivalentmétodo em todos os modelos que você pode precisar serializado. Este é um método mágica para demjson, mas é provavelmente algo que você vai querer pensar em não importa o que a implementação que você escolher. A idéia é que você retornar um objeto que está diretamente conversível json(ou seja, uma matriz ou dicionário). Se você realmente quer fazer isso automaticamente:

def json_equivalent(self):
    dictionary = {}
    for field in self._meta.get_all_field_names()
        dictionary[field] = self.__getattribute__(field)
    return dictionary

Isso não vai ser útil para você, a menos que você tem uma estrutura de dados totalmente plana (não ForeignKeys, apenas números e strings no banco de dados, etc.). Caso contrário, você deve pensar seriamente sobre a maneira correta de implementar este método.

Em terceiro lugar, chamar demjson.JSON.encode(instance)e você tem o que você quer.

Respondeu 16/04/2009 em 18:36
fonte usuário

votos
8

Se você está perguntando como serializar um único objeto de um modelo e você sabe que você está indo só para obter um objeto no queryset (por exemplo, usando objects.get), então usar algo como:

import django.core.serializers
import django.http
import models

def jsonExample(request,poll_id):
    s = django.core.serializers.serialize('json',[models.Poll.objects.get(id=poll_id)])
    # s is a string with [] around it, so strip them off
    o=s.strip("[]")
    return django.http.HttpResponse(o, mimetype="application/json")

que pegar algo da forma:

{"pk": 1, "model": "polls.poll", "fields": {"pub_date": "2013-06-27T02:29:38.284Z", "question": "What's up?"}}
Respondeu 01/07/2013 em 11:24
fonte usuário

votos
4

Eu resolvi esse problema adicionando um método de serialização para o meu modelo:

def toJSON(self):
    import simplejson
    return simplejson.dumps(dict([(attr, getattr(self, attr)) for attr in [f.name for f in self._meta.fields]]))

Aqui é o equivalente detalhado para aqueles avessos a one-liners:

def toJSON(self):
    fields = []
    for field in self._meta.fields:
        fields.append(field.name)

    d = {}
    for attr in fields:
        d[attr] = getattr(self, attr)

    import simplejson
    return simplejson.dumps(d)

_meta.fields é uma lista ordenada de campos do modelo, que pode ser acessado a partir de casos e do próprio modelo.

Respondeu 11/04/2010 em 16:18
fonte usuário

votos
3

Use lista, ele vai resolver problema

Passo 1:

 result=YOUR_MODELE_NAME.objects.values('PROP1','PROP2').all();

Passo 2:

 result=list(result)  #after getting data from model convert result to list

Etapa 3:

 return HttpResponse(json.dumps(result), content_type = "application/json")
Respondeu 09/10/2016 em 12:56
fonte usuário

votos
2

Aqui está a minha solução para isso, o que lhe permite personalizar facilmente o JSON, bem como organizar registros relacionados

Em primeiro lugar implementar um método no modelo. Eu chamo é json, mas você pode chamá-lo o que quiser, por exemplo:

class Car(Model):
    ...
    def json(self):
        return {
            'manufacturer': self.manufacturer.name,
            'model': self.model,
            'colors': [color.json for color in self.colors.all()],
        }

Em seguida, na visão eu faço:

data = [car.json for car in Car.objects.all()]
return HttpResponse(json.dumps(data), content_type='application/json; charset=UTF-8', status=status)
Respondeu 01/04/2013 em 09:53
fonte usuário

votos
2

como sobre esta maneira:

def ins2dic(obj):
    SubDic = obj.__dict__
    del SubDic['id']
    del SubDic['_state']
return SubDic

ou excluir qualquer coisa que você não quer.

Respondeu 22/06/2011 em 06:11
fonte usuário

votos
2
ville = UneVille.objects.get(nom='lihlihlihlih')
....
blablablab
.......

return HttpResponse(simplejson.dumps(ville.__dict__))

Eu voltar a dict da minha instância

por isso retornar algo como { 'campo1': valor "field2": valor, ....}

Respondeu 24/05/2009 em 09:54
fonte usuário

votos
1

Há uma boa resposta para isso e eu estou surpreso que não tenha sido mencionado. Com algumas linhas você pode lidar com datas, modelos e tudo mais.

Faça um codificador personalizado que pode lidar com os modelos:

from django.forms import model_to_dict
from django.core.serializers.json import DjangoJSONEncoder
from django.db.models import Model

class ExtendedEncoder(DjangoJSONEncoder):

    def default(self, o):

        if isinstance(o, Model):
            return model_to_dict(o)

        return super().default(o)

Agora usá-lo quando você usa json.dumps

json.dumps(data, cls=ExtendedEncoder)

Agora modelos, datas e tudo pode ser serializado e não tem que estar em um array ou serializado e desserializado.

Respondeu 15/07/2018 em 03:36
fonte usuário

votos
1

Para serializar e deserialze, use o seguinte:

from django.core import serializers

serial = serializers.serialize("json", [obj])
...
# .next() pulls the first object out of the generator
# .object retrieves django object the object from the DeserializedObject
obj = serializers.deserialize("json", serial).next().object
Respondeu 09/04/2015 em 22:15
fonte usuário

votos
1

Não parece que você pode serializar uma instância, você teria que serializar um QuerySet de um objeto.

from django.core import serializers
from models import *

def getUser(request):
    return HttpResponse(json(Users.objects.filter(id=88)))

Eu corro para fora do svnlançamento do Django, então isso pode não ser nas versões anteriores.

Respondeu 16/04/2009 em 17:51
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more