                                   % ', '.join(non_model_fields))
  
          # If saving to the same database, and this model is deferred, then
          # automatically do a "update_fields" save on the loaded fields.
          elif not force_insert and self._deferred and using == self._state.db:
              field_names = set()
              for field in self._meta.concrete_fields:
                  if not field.primary_key and not hasattr(field, 'through'):
                      field_names.add(field.attname)
              deferred_fields = [
 
</s> remove             deferred_fields = [
                f.attname for f in self._meta.fields
                if (f.attname not in self.__dict__ and
                    isinstance(self.__class__.__dict__[f.attname], DeferredAttribute))
            ]

 </s> add  </s> remove ``field_names`` are in the same order as the ``values``, so it is possible to
use ``cls(**(zip(field_names, values)))`` to instantiate the object. If all
of the model's fields are present, then ``values`` are guaranteed to be in
the order ``__init__()`` expects them. That is, the instance can be created
by ``cls(*values)``. It is possible to check if all fields are present by
consulting ``cls._deferred`` - if ``False``, then all fields have been loaded
from the database.
 </s> add ``field_names`` are in the same order as the ``values``. If all of the model's
fields are present, then ``values`` are guaranteed to be in the order
``__init__()`` expects them. That is, the instance can be created by
``cls(*values)``. If any fields are deferred, they won't appear in
``field_names``. In that case, assign a value of ``django.db.models.DEFERRED``
to each of the missing fields. </s> remove         # default implementation of from_db() (could be replaced
        # with super())
        if cls._deferred:
            instance = cls(**zip(field_names, values))
        else:
            instance = cls(*values)
 </s> add         # Default implementation of from_db() (subject to change and could
        # be replaced with super()).
        if len(values) != len(cls._meta.concrete_fields):
            values = list(values)
            values.reverse()
            values = [
                values.pop() if f.attname in field_names else DEFERRED
                for f in cls._meta.concrete_fields
            ]
        new = cls(*values) </s> remove         if self._deferred:
            non_deferred_model = self._meta.proxy_for_model
        else:
            non_deferred_model = self.__class__
        db_instance_qs = non_deferred_model._default_manager.using(db).filter(pk=self.pk)
 </s> add         db_instance_qs = self.__class__._default_manager.using(db).filter(pk=self.pk)
        elif not force_insert and deferred_fields and using == self._state.db:
                                   % ', '.join(non_model_fields))
  
          # If saving to the same database, and this model is deferred, then
          # automatically do a "update_fields" save on the loaded fields.
        elif not force_insert and deferred_fields and using == self._state.db:
              field_names = set()
              for field in self._meta.concrete_fields:
                  if not field.primary_key and not hasattr(field, 'through'):
                      field_names.add(field.attname)
              deferred_fields = [
keep keep keep keep replace keep keep keep keep keep
 Fixed #26207 -- Replaced dynamic classes with non-data descriptors for deferred instance loading. 
django/db/models/base.py