[Django]-Add a non-model field on a ModelSerializer in DRF 3

class MySerializer(serializers.ModelSerializer):
    write_only_char_field = serializers.CharField(write_only=True)
    write_only_list_char_field = serializers.ListField(child=serializers.CharField(max_length=100, default=''), write_only=True)
    empty_method_field = serializers.SerializerMethodField()
    read_only_custom_model_field = serializers.CharField(source='custom_property', read_only=True)

    def create(self, validated_data):
        validated_data.pop('write_only_char_field', None)
        validated_data.pop('write_only_list_char_field', None)
        return super().create(validated_data)

The serializers.CharField(write_only=True) and serializers.ListField(...) is a good solution to provide extra data to your .create() and .update() methods, as either a single string or a list of strings (you can mix ListField with other serializer field types).
With this method, you can also define def validate_write_only_char_field to implement some quick and simple validation.

serializers.SerializerMethodField() allows you to add some custom read-only field to your serializer output from a method defined on the serializer.

The read_only_custom_model_field would use a method on your model to read some data, not strictly a model field, but a custom method. I.e.

class MyModel(models.Model):
    my_field = models.CharField(max_length=100)

    @property
    def custom_property(self):
        return "Perform calculations, combine with related models, etc. etc."

class Foo(models.Model):
    . . .
    @property
    def my_field(self):
        return stuff
    . . .

Source:

Django REST Framework: adding additional field to ModelSerializer

Just an example might help you.

  class ExtensibleModelSerializerOptions(serializers.SerializerOptions):
    """
    Meta class options for ModelSerializer
    """
    def __init__(self, meta):
        super(ExtensibleModelSerializerOptions, self).__init__(meta)
        self.model = getattr(meta, 'model', None)
        self.read_only_fields = getattr(meta, 'read_only_fields', ())
        self.non_native_fields = getattr(meta, 'non_native_fields', ())


class ExtensibleModelSerializer(serializers.ModelSerializer):

    _options_class = ExtensibleModelSerializerOptions

    def restore_object(self, attrs, instance=None):
        """
        Deserialize a dictionary of attributes into an object instance.
        You should override this method to control how deserialized objects
        are instantiated.
        """
        for field in self.opts.non_native_fields:
            attrs.pop(field)

        return super(ExtensibleModelSerializer, self).restore_object(attrs, instance)

Source:
https://github.com/tomchristie/django-rest-framework/issues/951

Just give Serializer-field in serializer like this,

name = serializers.BooleanField(allow_null=True, required=False, default=False)

after then use create function in serializers like this

def create(self, validated_data):
    validated_data.pop('name', None)
    return super().create(validated_data)

Now you can enter the data from frontend-side and it will not save in the model.
And to access the data of this field you will get it in create function of view.

As mentioned there are two ways. (1) adding a model property. (2) adding a model field. I feel that adding a @property to model was explained well in this post. If you want to keep your models “lean and mean” use a Method field. Chandus answer omits some crucial points, though:

class DeliveryItemSerializer(serializers.ModelSerializer):

    product_name = serializers.SerializerMethodField(read_only=True)

    def get_product_name(self, obj):
        return obj.product.name

    class Meta:
        model = DeliveryItem
        fields = (
            (...your field names),
            'product_name',)

1. Set read_only
2. The field and the corresponding method do not have the same name. The method name defaults to get_field_name. If you use another name use the method_name=method name argument on SerializerMethodField()

In all previous answer what i saw every one recommended to remove those added fields which is not the part of Django model..

So this is not follow single responsibility principal

def create(self, validated_data):
    pass

According to drf drf doc this function only responsible for creation.

but if you want just add some extra fields in response we need to override

def to_representation(self,instance):
    pass

def to_representation(self, instance):
    return {}

add this to your create method