Curious about serializer optimization

[Antoliny0919]

I'm curious about serializer optimization, so I created a post on discussion.

class Wagon(models.Model):
  name = models.CharField(max_length=100)
  stuff = models...
  ...

Suppose that there is a test model called Wagon and that there is large data in the stuff field in the model object.
If the list view does not require stuff data, apply a defer method to the query set.

class WagonViewSet(viewsets.ModelViewSet)
  def list(self, request, *args, **kwargs):
    # It does not include private posts from other users.
    self.queryset = self.queryset.all().defer("stuff")
    return super().list(request, args, kwargs)

When I applied the following ModelSerializer in this state, contrary to my expectation, the stuff field value of the Wagon object was also obtained.

class WagonSerializers(serializers.ModelSerializers):
  class Meta:
    model = Wagon
    fields = "__all__"

When I removed certain columns from the query using defer, I thought Serializer wouldn't get them either.
So it was a loss in terms of speed if it provided a stuff field value that was unnecessary and had a large data.
First of all, I was curious about How can serializer get stuff field values, so I looked up data property logic.
rest_framework/fields.py

def get_attribute(instance, attrs):
    """
    Similar to Python's built in `getattr(instance, attr)`,
    but takes a list of nested attributes, instead of a single attribute.

    Also accepts either attribute lookup on objects or dictionary lookups.
    """
    for attr in attrs:
        try:
            if isinstance(instance, Mapping):
                instance = instance[attr]
            else:
                instance = getattr(instance, attr)
    ...

I found the answer to this part in the code above. I set the fields of the serializer to all so I was supposed to get all the fields, and I was able to get the stuff field value even if I applied defer to the instant.
(I think my understanding of this part is not enough)

I for solve the problem removed stuff from serializer through exclude and changed the serializer of logic that needed stuff as follows.

# serializers.py
class WagonSerializers(serializers.ModelSerializers):
  class Meta:
    model = Wagon
    exclude = ("stuff",)
# views.py
  def retrieve(self, request, *args, **kwargs):
    self.serializer_class.Meta.exclude = ()
    return super().retrieve(request, args, kwargs)

I wonder if the way I did it for optimization is right.
Can you give me a good opinion or solution?