Custom serializer fields in Django - Step-by-Step Execution

Concept Flow - Custom serializer fields

Define custom field class

↓

Override to_internal_value

↓

Override to_representation

↓

Use custom field in serializer

↓

Serialize data -> calls to_representation

↓

Deserialize input -> calls to_internal_value

This flow shows how to create a custom serializer field by defining a class, overriding methods to convert data in and out, then using it in a serializer for data transformation.

Execution Sample

Django

from rest_framework import serializers

class UpperCaseField(serializers.CharField):
    def to_representation(self, value):
        return value.upper()

Defines a custom serializer field that converts string output to uppercase when serializing.

Execution Table

Step	Action	Input Value	Method Called	Output/Result
1	Create UpperCaseField instance	N/A	Constructor	Field ready for use
2	Serialize data with value 'hello'	'hello'	to_representation	'HELLO'
3	Deserialize input 'world'	'world'	to_internal_value (default CharField)	'world'
4	Serialize data with value 'Django'	'Django'	to_representation	'DJANGO'
5	Deserialize input 'Test'	'Test'	to_internal_value (default CharField)	'Test'

💡 Serialization and deserialization complete using custom field methods

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5
value	N/A	'hello'	'world'	'Django'	'Test'
serialized_output	N/A	'HELLO'	N/A	'DJANGO'	N/A
deserialized_output	N/A	N/A	'world'	N/A	'Test'

Key Moments - 2 Insights

Why does to_representation change the output but to_internal_value does not in this example?

Because to_representation is overridden to convert the string to uppercase during serialization (see steps 2 and 4), while to_internal_value uses the default CharField behavior for deserialization (steps 3 and 5).

What happens if you don't override to_internal_value in a custom field?

The field uses the parent class's to_internal_value method, so input data is processed normally without custom changes, as shown in steps 3 and 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the output of serializing the value 'hello' at step 2?

A 'Hello'

B 'HELLO'

C 'hello'

D 'HELlo'

💡 Hint

Check the 'Output/Result' column at step 2 in the execution_table

At which step does deserialization of input 'world' occur?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look for 'to_internal_value' method calls in the execution_table

If you override to_internal_value to convert input to lowercase, how would the deserialized output change at step 5?

A 'Test'

B 'TEST'

C 'test'

D 'tEsT'

💡 Hint

Consider how to_internal_value transforms input before returning it

Concept Snapshot

Custom serializer fields in Django REST Framework let you control how data is converted in and out.
Override to_representation to change output format.
Override to_internal_value to customize input parsing.
Use your custom field in serializers like any other field.
This helps handle special data formats or validation cleanly.

Full Transcript

This lesson shows how to create and use custom serializer fields in Django REST Framework. You define a new field class by subclassing an existing field, then override to_representation to change how data is output during serialization, and optionally override to_internal_value to customize input parsing during deserialization. The example UpperCaseField converts strings to uppercase when serializing. The execution table traces creating the field, serializing values like 'hello' and 'Django' to uppercase, and deserializing inputs like 'world' and 'Test' using default behavior. Key points include understanding that to_representation affects output, while to_internal_value affects input, and that if you don't override to_internal_value, the default method is used. The visual quiz tests understanding of these method calls and their effects on data transformation. This approach helps you handle special data formats or validation needs in your APIs.

Practice

1. What is the main purpose of creating a custom serializer field in Django REST Framework?

easy

A. To style the API response with CSS

B. To create new database tables automatically

C. To handle user authentication and permissions

D. To control how data is converted to and from JSON format

Solution

1. Step 1: Understand serializer fields role

   Serializer fields define how data is transformed between Python objects and JSON.

2. Step 2: Identify custom field purpose

   Custom fields let you control this transformation, especially for special data formats.

3. Final Answer:

   To control how data is converted to and from JSON format -> Option D

4. Quick Check:

   Custom serializer fields = control data format [OK]

Hint: Custom fields change data format in API input/output [OK]

Common Mistakes:

• Confusing serializer fields with database models
• Thinking custom fields handle authentication
• Assuming styling is done in serializers

2. Which method should you override in a custom serializer field to change how data is shown in API responses?

easy

A. to_internal_value

B. to_representation

C. validate

D. create

Solution

1. Step 1: Recall method roles in serializer fields

   to_representation converts Python data to JSON output; to_internal_value converts input JSON to Python.

2. Step 2: Identify output formatting method

   To change API response format, override to_representation.

3. Final Answer:

   to_representation -> Option B

4. Quick Check:

   Output formatting = to_representation [OK]

Hint: Output uses to_representation method [OK]

Common Mistakes:

• Using to_internal_value for output formatting
• Confusing validate with data conversion
• Overriding create instead of serialization methods

3. Given this custom serializer field code, what will be the output for input value 10?

class DoubleField(serializers.Field):
    def to_representation(self, value):
        return value * 2

field = DoubleField()
print(field.to_representation(10))

medium

A. 20

B. '10'

C. 10

D. Error

Solution

1. Step 1: Analyze to_representation method

   The method multiplies the input value by 2 before returning it.

2. Step 2: Calculate output for input 10

   10 * 2 = 20, so the output is 20.

3. Final Answer:

   20 -> Option A

4. Quick Check:

   10 doubled = 20 [OK]

Hint: to_representation transforms output value [OK]

Common Mistakes:

• Expecting input unchanged
• Confusing output type as string
• Assuming method raises error

4. Identify the error in this custom serializer field code:

class UpperCaseField(serializers.Field):
    def to_internal_value(self, data):
        return data.upper()

field = UpperCaseField()
print(field.to_internal_value(None))

medium

A. Field class must inherit from serializers.CharField

B. to_internal_value should return lowercase string

C. Calling upper() on None causes an AttributeError

D. to_internal_value method is missing a return statement

Solution

1. Step 1: Check method call on input

   The code calls data.upper() but data is None, which has no upper() method.

2. Step 2: Identify error type

   This causes an AttributeError at runtime.

3. Final Answer:

   Calling upper() on None causes an AttributeError -> Option C

4. Quick Check:

   None.upper() = AttributeError [OK]

Hint: Check input type before calling string methods [OK]

Common Mistakes:

• Assuming None is valid string input
• Thinking inheritance must be CharField
• Missing return statement (actually present)

5. You want to create a custom serializer field that accepts a comma-separated string of numbers and outputs a list of integers. Which methods should you override and how?

hard

A. Override to_internal_value to split and convert input string; override to_representation to join list into string

B. Override to_representation to split input string; override to_internal_value to join list

C. Override validate to convert string to list; no need to override to_representation

D. Override create method to parse string; override update to format list

Solution

1. Step 1: Understand input and output roles

   Input is a string (comma-separated), so to_internal_value must parse it into a list of integers.

2. Step 2: Format output for API response

   to_representation should convert the list back into a comma-separated string for output.

3. Final Answer:

   Override to_internal_value to split and convert input string; override to_representation to join list into string -> Option A

4. Quick Check:

   Input parsing = to_internal_value, output formatting = to_representation [OK]

Hint: Parse input in to_internal_value, format output in to_representation [OK]

Common Mistakes:

• Swapping input/output methods
• Using validate instead of conversion methods
• Overriding create/update which are unrelated