Converti l'oggetto Django Model in dict con tutti i campi intatti

Come si converte un oggetto Django Model in un dict con tutti i suoi campi? Tutto include idealmente chiavi e campi esterni con editable=False.

Lasciami elaborare. Diciamo che ho un modello Django come il seguente:

from django.db import models

class OtherModel(models.Model): pass

class SomeModel(models.Model):
    normal_value = models.IntegerField()
    readonly_value = models.IntegerField(editable=False)
    auto_now_add = models.DateTimeField(auto_now_add=True)
    foreign_key = models.ForeignKey(OtherModel, related_name="ref1")
    many_to_many = models.ManyToManyField(OtherModel, related_name="ref2")

Nel terminale, ho fatto quanto segue:

other_model = OtherModel()
other_model.save()
instance = SomeModel()
instance.normal_value = 1
instance.readonly_value = 2
instance.foreign_key = other_model
instance.save()
instance.many_to_many.add(other_model)
instance.save()

Voglio convertirlo nel seguente dizionario:

{'auto_now_add': datetime.datetime(2015, 3, 16, 21, 34, 14, 926738, tzinfo=<UTC>),
 'foreign_key': 1,
 'id': 1,
 'many_to_many': [1],
 'normal_value': 1,
 'readonly_value': 2}

Domande con risposte insoddisfacenti:

Django: conversione di un intero set di oggetti di un modello in un singolo dizionario

Come posso trasformare gli oggetti Django Model in un dizionario e avere ancora le loro chiavi esterne?

Esistono molti modi per convertire un'istanza in un dizionario, con vari gradi di gestione e vicinanza dei casi angolari al risultato desiderato.

1. instance.__dict__

instance.__dict__

che ritorna

{'_foreign_key_cache': <OtherModel: OtherModel object>,
 '_state': <django.db.models.base.ModelState at 0x7ff0993f6908>,
 'auto_now_add': datetime.datetime(2018, 12, 20, 21, 34, 29, 494827, tzinfo=<UTC>),
 'foreign_key_id': 2,
 'id': 1,
 'normal_value': 1,
 'readonly_value': 2}

Questo è di gran lunga il più semplice, ma manca many_to_many, foreign_keyè erroneamente etichettato e contiene due cose extra indesiderate.

2. model_to_dict

from django.forms.models import model_to_dict
model_to_dict(instance)

che ritorna

{'foreign_key': 2,
 'id': 1,
 'many_to_many': [<OtherModel: OtherModel object>],
 'normal_value': 1}

Questo è l'unico con many_to_many, ma mancano i campi non modificabili.

3. model_to_dict(..., fields=...)

from django.forms.models import model_to_dict
model_to_dict(instance, fields=[field.name for field in instance._meta.fields])

che ritorna

{'foreign_key': 2, 'id': 1, 'normal_value': 1}

Questo è strettamente peggio della model_to_dictchiamata standard .

4. query_set.values()

SomeModel.objects.filter(id=instance.id).values()[0]

che ritorna

{'auto_now_add': datetime.datetime(2018, 12, 20, 21, 34, 29, 494827, tzinfo=<UTC>),
 'foreign_key_id': 2,
 'id': 1,
 'normal_value': 1,
 'readonly_value': 2}

Questo è lo stesso output instance.__dict__ma senza i campi extra. foreign_key_idè ancora sbagliato e many_to_manymanca ancora.

5. Funzione personalizzata

Il codice per Django ha model_to_dictavuto la maggior parte della risposta. Ha rimosso esplicitamente i campi non modificabili, quindi rimuovendo quel controllo e ottenendo gli ID di chiavi esterne per molti o molti campi si ottiene il seguente codice che si comporta come desiderato:

from itertools import chain

def to_dict(instance):
    opts = instance._meta
    data = {}
    for f in chain(opts.concrete_fields, opts.private_fields):
        data[f.name] = f.value_from_object(instance)
    for f in opts.many_to_many:
        data[f.name] = [i.id for i in f.value_from_object(instance)]
    return data

Mentre questa è l'opzione più complicata, chiamare to_dict(instance)ci dà esattamente il risultato desiderato:

{'auto_now_add': datetime.datetime(2018, 12, 20, 21, 34, 29, 494827, tzinfo=<UTC>),
 'foreign_key': 2,
 'id': 1,
 'many_to_many': [2],
 'normal_value': 1,
 'readonly_value': 2}

6. Utilizzare i serializzatori

ModelSerialzer di Django Rest Framework consente di creare automaticamente un serializzatore da un modello.

from rest_framework import serializers
class SomeModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = SomeModel
        fields = "__all__"

SomeModelSerializer(instance).data

ritorna

{'auto_now_add': '2018-12-20T21:34:29.494827Z',
 'foreign_key': 2,
 'id': 1,
 'many_to_many': [2],
 'normal_value': 1,
 'readonly_value': 2}

Questo è quasi buono come la funzione personalizzata, ma auto_now_add è una stringa anziché un oggetto datetime.

Bonus Round: migliore stampa del modello

Se desideri un modello django con una migliore visualizzazione della riga di comando di Python, fai in modo che i tuoi modelli siano di classe figlio:

from django.db import models
from itertools import chain

class PrintableModel(models.Model):
    def __repr__(self):
        return str(self.to_dict())

    def to_dict(instance):
        opts = instance._meta
        data = {}
        for f in chain(opts.concrete_fields, opts.private_fields):
            data[f.name] = f.value_from_object(instance)
        for f in opts.many_to_many:
            data[f.name] = [i.id for i in f.value_from_object(instance)]
        return data

    class Meta:
        abstract = True

Quindi, ad esempio, se definiamo i nostri modelli come tali:

class OtherModel(PrintableModel): pass

class SomeModel(PrintableModel):
    normal_value = models.IntegerField()
    readonly_value = models.IntegerField(editable=False)
    auto_now_add = models.DateTimeField(auto_now_add=True)
    foreign_key = models.ForeignKey(OtherModel, related_name="ref1")
    many_to_many = models.ManyToManyField(OtherModel, related_name="ref2")

Chiamare SomeModel.objects.first()ora fornisce un output come questo:

{'auto_now_add': datetime.datetime(2018, 12, 20, 21, 34, 29, 494827, tzinfo=<UTC>),
 'foreign_key': 2,
 'id': 1,
 'many_to_many': [2],
 'normal_value': 1,
 'readonly_value': 2}

Ho trovato una soluzione pulita per arrivare al risultato:

Supponiamo di avere un oggetto modello o:

Chiama soltanto:

type(o).objects.filter(pk=o.pk).values().first()

La soluzione @Zags è stata meravigliosa!

Aggiungerei, tuttavia, una condizione per i campi di data al fine di renderlo compatibile con JSON.

Round bonus

Se vuoi un modello django con una migliore visualizzazione della riga di comando di Python, fai in modo che i tuoi modelli classifichino:

from django.db import models
from django.db.models.fields.related import ManyToManyField

class PrintableModel(models.Model):
    def __repr__(self):
        return str(self.to_dict())

    def to_dict(self):
        opts = self._meta
        data = {}
        for f in opts.concrete_fields + opts.many_to_many:
            if isinstance(f, ManyToManyField):
                if self.pk is None:
                    data[f.name] = []
                else:
                    data[f.name] = list(f.value_from_object(self).values_list('pk', flat=True))
            elif isinstance(f, DateTimeField):
                if f.value_from_object(self) is not None:
                    data[f.name] = f.value_from_object(self).timestamp()
            else:
                data[f.name] = None
            else:
                data[f.name] = f.value_from_object(self)
        return data

    class Meta:
        abstract = True

Quindi, ad esempio, se definiamo i nostri modelli come tali:

class OtherModel(PrintableModel): pass

class SomeModel(PrintableModel):
    value = models.IntegerField()
    value2 = models.IntegerField(editable=False)
    created = models.DateTimeField(auto_now_add=True)
    reference1 = models.ForeignKey(OtherModel, related_name="ref1")
    reference2 = models.ManyToManyField(OtherModel, related_name="ref2")

Chiamare SomeModel.objects.first()ora fornisce un output come questo:

{'created': 1426552454.926738,
'value': 1, 'value2': 2, 'reference1': 1, u'id': 1, 'reference2': [1]}

Il modo più semplice,

1. Se la tua query è Model.Objects.get ():

   get () restituirà una singola istanza in modo che tu possa utilizzarne direttamente __dict__l'istanza

   model_dict = Model.Objects.get().__dict__

2. per filter () / all ():

   all () / filter () restituirà un elenco di istanze in modo da poterlo utilizzare values()per ottenere un elenco di oggetti.

   model_values ​​= Model.Objects.all (). valori ()

semplicemente vars(obj), indicherà tutti i valori dell'oggetto

>>> obj_attrs = vars(obj)
>>> obj_attrs
 {'_file_data_cache': <FileData: Data>,
  '_state': <django.db.models.base.ModelState at 0x7f5c6733bad0>,
  'aggregator_id': 24,
  'amount': 5.0,
  'biller_id': 23,
  'datetime': datetime.datetime(2018, 1, 31, 18, 43, 58, 933277, tzinfo=<UTC>),
  'file_data_id': 797719,
 }

Puoi aggiungere anche questo

>>> keys = obj_attrs.keys()
>>> temp = [obj_attrs.pop(key) if key.startswith('_') else None for key in keys]
>>> del temp
>>> obj_attrs
   {
    'aggregator_id': 24,
    'amount': 5.0,
    'biller_id': 23,
    'datetime': datetime.datetime(2018, 1, 31, 18, 43, 58, 933277, tzinfo=<UTC>),
    'file_data_id': 797719,
   }

Aggiornare

La nuova risposta aggregata pubblicata da @zags è più completa ed elegante della mia. Si prega di fare riferimento a quella risposta.

Originale

Se sei disposto a definire il tuo metodo to_dict come suggerito da @karthiker, questo riduce il problema a un problema di insiemi.

>>># Returns a set of all keys excluding editable = False keys
>>>dict = model_to_dict(instance)
>>>dict

{u'id': 1L, 'reference1': 1L, 'reference2': [1L], 'value': 1}


>>># Returns a set of editable = False keys, misnamed foreign keys, and normal keys
>>>otherDict = SomeModel.objects.filter(id=instance.id).values()[0]
>>>otherDict

{'created': datetime.datetime(2014, 2, 21, 4, 38, 51, tzinfo=<UTC>),
 u'id': 1L,
 'reference1_id': 1L,
 'value': 1L,
 'value2': 2L}

Dobbiamo rimuovere le chiavi esterne senza etichetta da otherDict .

Per fare ciò, possiamo usare un ciclo che crea un nuovo dizionario che contiene tutti gli elementi tranne quelli con caratteri di sottolineatura. Oppure, per risparmiare tempo, possiamo semplicemente aggiungerli al dict originale poiché i dizionari sono solo set sotto il cofano.

>>>for item in otherDict.items():
...    if "_" not in item[0]:
...            dict.update({item[0]:item[1]})
...
>>>

Quindi ci rimane il seguente dict :

>>>dict
{'created': datetime.datetime(2014, 2, 21, 4, 38, 51, tzinfo=<UTC>),
 u'id': 1L,
 'reference1': 1L,
 'reference2': [1L],
 'value': 1,
 'value2': 2L}

E tu lo restituisci e basta.

Il rovescio della medaglia, non è possibile utilizzare i trattini bassi nei nomi dei campi editable = false. Sul lato positivo, questo funzionerà per qualsiasi set di campi in cui i campi creati dall'utente non contengono caratteri di sottolineatura.

Questo non è il modo migliore per farlo, ma potrebbe funzionare come soluzione temporanea fino a quando non viene trovato un metodo più diretto.

Nell'esempio seguente, dict verrebbe formato in base a model_to_dict e otherDict verrebbe formato con il metodo dei valori di filtro. Lo avrei fatto con i modelli stessi, ma non riesco a far accettare alla mia macchina altri modelli.

>>> import datetime
>>> dict = {u'id': 1, 'reference1': 1, 'reference2': [1], 'value': 1}
>>> otherDict = {'created': datetime.datetime(2014, 2, 21, 4, 38, 51), u'id': 1, 'reference1_id': 1, 'value': 1, 'value2': 2}
>>> for item in otherDict.items():
...     if "_" not in item[0]:
...             dict.update({item[0]:item[1]})
...
>>> dict
{'reference1': 1, 'created': datetime.datetime(2014, 2, 21, 4, 38, 51), 'value2': 2, 'value': 1, 'id': 1, 'reference2': [1]}
>>>

Spero che questo dovrebbe metterti in una sfera approssimativa della risposta alla tua domanda.

Molte soluzioni interessanti qui. La mia soluzione era quella di aggiungere un metodo as_dict al mio modello con una comprensione dict.

def as_dict(self):
    return dict((f.name, getattr(self, f.name)) for f in self._meta.fields)

Come bonus, questa soluzione accoppiata con una comprensione dell'elenco su una query rende una soluzione piacevole se vuoi esportare i tuoi modelli in un'altra libreria. Ad esempio, scaricando i tuoi modelli in un frame di dati Panda:

pandas_awesomeness = pd.DataFrame([m.as_dict() for m in SomeModel.objects.all()])

(non intendeva fare il commento)

Ok, non dipende davvero dai tipi in quel modo. Potrei aver capito male la domanda originale qui, quindi perdonami se è così. Se crei serliazers.py, allora lì crei le classi che hanno metaclassi.

Class MyModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = modelName
        fields =('csv','of','fields')

Quindi quando ottieni i dati nella classe di visualizzazione puoi:

model_data - Model.objects.filter(...)
serializer = MyModelSerializer(model_data, many=True)
return Response({'data': serilaizer.data}, status=status.HTTP_200_OK)

Questo è praticamente quello che ho in una varietà di posti e restituisce un bel JSON tramite JSONRenderer.

Come ho già detto, questo è per gentile concessione di DjangoRestFramework, quindi vale la pena esaminarlo.

Il modo più semplice è semplicemente usare pprint, che è in Python di base

import pprint
item = MyDjangoModel.objects.get(name = 'foo')
pprint.pprint(item.__dict__, indent = 4)

Ciò fornisce un output simile json.dumps(..., indent = 4)ma che gestisce correttamente gli strani tipi di dati che potrebbero essere incorporati nell'istanza del modello, come ModelStatee UUID, ecc.

Testato su Python 3.7

Forse questo ti aiuta. Possa questo non rivelare molte a molte relazioni, ma è piuttosto utile quando si desidera inviare il proprio modello in formato json.

def serial_model(modelobj):
  opts = modelobj._meta.fields
  modeldict = model_to_dict(modelobj)
  for m in opts:
    if m.is_relation:
        foreignkey = getattr(modelobj, m.name)
        if foreignkey:
            try:
                modeldict[m.name] = serial_model(foreignkey)
            except:
                pass
  return modeldict

La migliore soluzione che tu abbia mai visto.

Converti l'istanza django.db.models.Model e tutti i campi delle funzioni ForeignKey, ManyToManyField e @Property correlati in dict.

"""
Convert django.db.models.Model instance and all related ForeignKey, ManyToManyField and @property function fields into dict.
Usage:
    class MyDjangoModel(... PrintableModel):
        to_dict_fields = (...)
        to_dict_exclude = (...)
        ...
    a_dict = [inst.to_dict(fields=..., exclude=...) for inst in MyDjangoModel.objects.all()]
"""
import typing

import django.core.exceptions
import django.db.models
import django.forms.models


def get_decorators_dir(cls, exclude: typing.Optional[set]=None) -> set:
    """
    Ref: /programming/4930414/how-can-i-introspect-properties-and-model-fields-in-django
    :param exclude: set or None
    :param cls:
    :return: a set of decorators
    """
    default_exclude = {"pk", "objects"}
    if not exclude:
        exclude = default_exclude
    else:
        exclude = exclude.union(default_exclude)

    return set([name for name in dir(cls) if name not in exclude and isinstance(getattr(cls, name), property)])


class PrintableModel(django.db.models.Model):

    class Meta:
        abstract = True

    def __repr__(self):
        return str(self.to_dict())

    def to_dict(self, fields: typing.Optional[typing.Iterable]=None, exclude: typing.Optional[typing.Iterable]=None):
        opts = self._meta
        data = {}

        # support fields filters and excludes
        if not fields:
            fields = set()
        else:
            fields = set(fields)
        default_fields = getattr(self, "to_dict_fields", set())
        fields = fields.union(default_fields)

        if not exclude:
            exclude = set()
        else:
            exclude = set(exclude)
        default_exclude = getattr(self, "to_dict_exclude", set())
        exclude = exclude.union(default_exclude)

        # support syntax "field__childField__..."
        self_fields = set()
        child_fields = dict()
        if fields:
            for i in fields:
                splits = i.split("__")
                if len(splits) == 1:
                    self_fields.add(splits[0])
                else:
                    self_fields.add(splits[0])

                    field_name = splits[0]
                    child_fields.setdefault(field_name, set())
                    child_fields[field_name].add("__".join(splits[1:]))

        self_exclude = set()
        child_exclude = dict()
        if exclude:
            for i in exclude:
                splits = i.split("__")
                if len(splits) == 1:
                    self_exclude.add(splits[0])
                else:
                    field_name = splits[0]
                    if field_name not in child_exclude:
                        child_exclude[field_name] = set()
                    child_exclude[field_name].add("__".join(splits[1:]))

        for f in opts.concrete_fields + opts.many_to_many:
            if self_fields and f.name not in self_fields:
                continue
            if self_exclude and f.name in self_exclude:
                continue

            if isinstance(f, django.db.models.ManyToManyField):
                if self.pk is None:
                    data[f.name] = []
                else:
                    result = []
                    m2m_inst = f.value_from_object(self)
                    for obj in m2m_inst:
                        if isinstance(PrintableModel, obj) and hasattr(obj, "to_dict"):
                            d = obj.to_dict(
                                fields=child_fields.get(f.name),
                                exclude=child_exclude.get(f.name),
                            )
                        else:
                            d = django.forms.models.model_to_dict(
                                obj,
                                fields=child_fields.get(f.name),
                                exclude=child_exclude.get(f.name)
                            )
                        result.append(d)
                    data[f.name] = result
            elif isinstance(f, django.db.models.ForeignKey):
                if self.pk is None:
                    data[f.name] = []
                else:
                    data[f.name] = None
                    try:
                        foreign_inst = getattr(self, f.name)
                    except django.core.exceptions.ObjectDoesNotExist:
                        pass
                    else:
                        if isinstance(foreign_inst, PrintableModel) and hasattr(foreign_inst, "to_dict"):
                            data[f.name] = foreign_inst.to_dict(
                                fields=child_fields.get(f.name),
                                exclude=child_exclude.get(f.name)
                            )
                        elif foreign_inst is not None:
                            data[f.name] = django.forms.models.model_to_dict(
                                foreign_inst,
                                fields=child_fields.get(f.name),
                                exclude=child_exclude.get(f.name),
                            )

            elif isinstance(f, (django.db.models.DateTimeField, django.db.models.DateField)):
                v = f.value_from_object(self)
                if v is not None:
                    data[f.name] = v.isoformat()
                else:
                    data[f.name] = None
            else:
                data[f.name] = f.value_from_object(self)

        # support @property decorator functions
        decorator_names = get_decorators_dir(self.__class__)
        for name in decorator_names:
            if self_fields and name not in self_fields:
                continue
            if self_exclude and name in self_exclude:
                continue

            value = getattr(self, name)
            if isinstance(value, PrintableModel) and hasattr(value, "to_dict"):
                data[name] = value.to_dict(
                    fields=child_fields.get(name),
                    exclude=child_exclude.get(name)
                )
            elif hasattr(value, "_meta"):
                # make sure it is a instance of django.db.models.fields.Field
                data[name] = django.forms.models.model_to_dict(
                    value,
                    fields=child_fields.get(name),
                    exclude=child_exclude.get(name),
                )
            elif isinstance(value, (set, )):
                data[name] = list(value)
            else:
                data[name] = value

        return data

https://gist.github.com/shuge/f543dc2094a3183f69488df2bfb51a52

La risposta di @zags è completa e dovrebbe essere sufficiente, ma il metodo # 5 (che è il migliore IMO) genera un errore, quindi ho migliorato la funzione di supporto.

Poiché l'OP ha richiesto la conversione dei many_to_manycampi in un elenco di chiavi primarie anziché in un elenco di oggetti, ho migliorato la funzione in modo che il valore restituito sia ora serializzabile JSON, convertendo datetimeoggetti in stre many_to_manyoggetti in un elenco di ID.

import datetime

def ModelToDict(instance):
    '''
    Returns a dictionary object containing complete field-value pairs of the given instance

    Convertion rules:

        datetime.date --> str
        many_to_many --> list of id's

    '''

    concrete_fields = instance._meta.concrete_fields
    m2m_fields = instance._meta.many_to_many
    data = {}

    for field in concrete_fields:
        key = field.name
        value = field.value_from_object(instance)
        if type(value) == datetime.datetime:
            value = str(field.value_from_object(instance))
        data[key] = value

    for field in m2m_fields:
        key = field.name
        value = field.value_from_object(instance)
        data[key] = [rel.id for rel in value]

    return data