Перетворіть об'єкт "Модель Джанго", щоб промальовувати всі ці поля недоторканими

Як можна перетворити об’єкт моделі Джанго в дікт з усіма його полями? Все в ідеалі включає зовнішні ключі та поля з editable=False.

Дозвольте мені детальніше. Скажімо, у мене є модель Django на зразок наступної:

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

У терміналі я зробив наступне:

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()

Я хочу перетворити це у наступний словник:

{'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}

Запитання із незадовільними відповідями:

Django: Перетворення всього набору об'єктів Model в один словник

Як я можу перетворити об’єкти моделі Django в словник і все ще мати свої зовнішні ключі?

Існує багато способів перетворення екземпляра в словник з різним ступенем обробки кутових справ і близькості до потрібного результату.

1. instance.__dict__

instance.__dict__

який повертається

{'_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}

Це, безумовно, найпростіше, але його немає many_to_many, foreign_keyйого називають неправильним, і в ньому є дві небажані зайві речі.

2. model_to_dict

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

який повертається

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

Це єдине з many_to_many, але відсутні поля, які не можна редагувати.

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

який повертається

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

Це суворо гірше, ніж стандартне model_to_dictвиклик.

4. query_set.values()

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

який повертається

{'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}

Це такий же вихід, як instance.__dict__і без додаткових полів. foreign_key_idвсе ще помиляється і many_to_manyдосі відсутня.

5. Спеціальна функція

Код для джанго model_to_dictмав більшу частину відповіді. Він явно видалив не редаговані поля, тому видалення цієї перевірки та отримання ідентифікаторів іноземних ключів для багатьох-багатьох полів призводить до наступного коду, який веде себе як потрібно:

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

Хоча це найскладніший варіант, дзвінок to_dict(instance)дає нам точно бажаний результат:

{'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. Використовуйте серіалізатори

ModelSerialzer Django Rest Framework дозволяє створювати серіалізатор автоматично з моделі.

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

SomeModelSerializer(instance).data

повертає

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

Це майже так само добре, як і спеціальна функція, але auto_now_add - це рядок замість об'єкта datetime.

Бонусний раунд: краща модель друку

Якщо ви хочете, щоб модель django мала кращий дисплей командного рядка python, запропонуйте своїм моделям дочірнього класу наступне:

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

Так, наприклад, якщо ми визначимо наші моделі як такі:

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

Виклик SomeModel.objects.first()зараз дає вихід таким чином:

{'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}

Я знайшов акуратне рішення, щоб отримати результат:

Припустимо, у вас є об'єкт моделі o:

Просто зателефонуйте:

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

Рішення @Zags було чудовим!

Я хотів би додати умову для полів дат, щоб зробити її JSON дружньою.

Бонусний раунд

Якщо ви хочете, щоб модель django мала кращий дисплей командного рядка python, запропонуйте своїм моделям дочірнього класу наступне:

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

Так, наприклад, якщо ми визначимо наші моделі як такі:

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

Виклик SomeModel.objects.first()зараз дає вихід таким чином:

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

Найпростіший спосіб,

1. Якщо ваш запит є Model.Objects.get ():

   get () поверне один екземпляр, щоб ви могли безпосередньо використовувати його __dict__зі свого примірника

   model_dict = Model.Objects.get().__dict__

2. для filter () / all ():

   all () / filter () поверне список екземплярів, щоб ви могли використовувати values()список об'єктів.

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

просто vars(obj), він буде констатувати цілі значення об'єкта

>>> 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,
 }

Ви також можете додати це

>>> 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,
   }

Оновлення

Новіша узагальнена відповідь, опублікована @zags, є більш повною та елегантною, ніж моя власна. Натомість зверніться до цієї відповіді.

Оригінал

Якщо ви готові визначити свій власний метод to_dict, наприклад, запропонований @karthiker, це просто зводить цю проблему до заданої задачі.

>>># 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}

Нам потрібно видалити неправильно позначені іноземні ключі з іншогоDict .

Для цього ми можемо використовувати цикл, який створює новий словник, у якому є кожен елемент, за винятком знаків підкреслення. Або, щоб заощадити час, ми можемо просто додати їх до оригінального диктанту, оскільки словники - це просто набори під кришкою.

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

Таким чином, нам залишається такий вислів :

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

А ти просто повернеш це.

З іншого боку, ви не можете використовувати підкреслення в своїх редагованих = помилкових іменах полів. Зверху це буде працювати для будь-якого набору полів, де створені користувачем поля не містять підкреслених знаків.

Це не найкращий спосіб зробити це, але він може працювати як тимчасове рішення, поки не буде знайдено більш прямий метод.

Для прикладу нижче, dict формується на основі model_to_dict, а otherDict формується методом значень фільтра. Я б зробив це з самими моделями, але я не можу змусити свою машину прийняти otherModel.

>>> 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]}
>>>

Я сподіваюся, що це повинно поставити вас у грубій відповіді на ваше запитання.

Тут багато цікавих рішень. Моє рішення полягало в тому, щоб додати до моєї моделі метод as_dict з розумінням дикту.

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

Як бонус, це рішення в поєднанні зі списком розуміння запиту робить гарне рішення, якщо ви хочете експортувати свої моделі до іншої бібліотеки. Наприклад, скидання моделей у рамки даних панди:

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

(не мав на увазі робити коментар)

Гаразд, це насправді не залежить від типів таким чином. Я, можливо, неправильно зрозумів первісне питання тут, тож пробачте мене, якщо це так. Якщо ви створюєте serliazers.py, то там ви створюєте класи з мета-класами.

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

Потім, коли ви отримуєте дані в класі перегляду, ви можете:

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

Це в значній мірі те, що у мене є у великій кількості місць, і це повертає приємний JSON через JSONRenderer.

Як я вже говорив, це люб'язно DjangoRestFramework, тому варто розібратися в цьому.

Найпростіший спосіб - просто використовувати pprint, який знаходиться в базі Python

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

Це дає вихід, схожий на, json.dumps(..., indent = 4)але він правильно обробляє дивні типи даних, які можуть бути вбудовані у ваш екземпляр моделі, наприклад, ModelStateта UUIDтощо.

Тестовано на Python 3.7

Можливо, це вам допоможе. Нехай це не приховує багато до багатьох перепланувань, але це дуже зручно, коли ви хочете відправити свою модель у форматі 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

Найкраще рішення, яке ви коли-небудь бачили.

Перетворіть екземпляр django.db.models.Model і всі пов'язані з ними функції ForeignKey, ManyToManyField та @Property в 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

Відповідь від @zags є вичерпною і має бути достатньою, але метод №5 (який найкращий ІМО) видає помилку, тому я покращив функцію помічника.

Оскільки ОП вимагало перетворення many_to_manyполів у список первинних ключів, а не у список об’єктів, я посилив функцію, тому повернене значення тепер є JSON серіалізаційним - шляхом перетворення datetimeоб'єктів у strта many_to_manyоб'єкти до списку ідентифікаторів.

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