Django REST Framework Q&A

Django REST framework interview questions with there answers

Here are some common Django REST Framework (DRF) interview questions along with their
answers:

1. What is Django REST Framework (DRF)?

Answer: Django REST Framework (DRF) is a powerful and flexible toolkit for building Web APIs. It
allows you to create RESTful APIs using Django, offering features such as serialization, authentication,
and view sets, making API development straightforward.

2. What are serializers in Django REST Framework?

Answer: Serializers in DRF are used to convert complex data types such as Django models or
QuerySets into JSON or XML format. They also perform deserialization, i.e., transforming incoming
JSON or XML into Django objects for use in the backend.

python

from rest_framework import serializers

class BookSerializer(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['title', 'author']

3. What is the difference between `APIView` and `ViewSet` in DRF?

Answer:

APIView: A base class for all views in DRF. It provides the most control but requires more work,
such as manually defining `get()`, `post()`, etc.
ViewSet: It automatically defines routes for common actions like list, create, retrieve, update,
and delete (CRUD operations), reducing code duplication.

python

# APIView Example
class BookList(APIView):
def get(self, request):
books = Book.objects.all()
serializer = BookSerializer(books, many=True)
return Response(serializer.data)

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 1/18
 # ViewSet Example
class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer

4. What are mixins in DRF?

Answer: Mixins in DRF are reusable classes that provide default implementations for actions like
`list`, `create`, `retrieve`, `update`, and `destroy`. You can combine these mixins with `APIView` to
create views for basic CRUD operations.

python

from rest_framework import mixins

from rest_framework.generics import GenericAPIView

class BookListCreateView(mixins.ListModelMixin, mixins.CreateModelMixin, GenericAPIView):

queryset = Book.objects.all()
serializer_class = BookSerializer

def get(self, request):

return self.list(request)

def post(self, request):

return self.create(request)

5. What is a QuerySet and how is it used in DRF?

Answer: A QuerySet in Django represents a collection of objects from the database. In DRF, QuerySets
are used in views to fetch data, which is then serialized before sending it to the client.

python

class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer

6. How does authentication work in Django REST Framework?

Answer: DRF supports multiple authentication methods like Basic Authentication, Token
Authentication, Session Authentication, and OAuth. You can configure the authentication classes in
your settings or views.

python

from rest_framework.authentication import TokenAuthentication

from rest_framework.permissions import IsAuthenticated

class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 2/18
 authentication_classes = [TokenAuthentication]
permission_classes = [IsAuthenticated]

7. What is pagination in DRF and how can you implement it?

Answer: Pagination in DRF refers to splitting a large list of results into smaller "pages". You can define
global pagination settings or customize them per view.

python

# settings.py
REST_FRAMEWORK = {
'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
'PAGE_SIZE': 10,
}

# Alternatively, you can add pagination to a specific view:

from rest_framework.pagination import LimitOffsetPagination

class BookList(generics.ListAPIView):
queryset = Book.objects.all()
serializer_class = BookSerializer
pagination_class = LimitOffsetPagination

8. What are permissions in DRF?

Answer: Permissions in DRF define the level of access a user has to a resource. Common permissions
include `IsAuthenticated`, `IsAdminUser`, and custom permissions.

python

from rest_framework.permissions import IsAuthenticated

class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
permission_classes = [IsAuthenticated]

9. What is the difference between `@api_view` and `APIView`?

Answer:

`@api_view`: A function-based view decorator in DRF, used for simpler use cases.
`APIView`: A class-based view that offers more flexibility and scalability.

python

# Function-based view with @api_view

from rest_framework.decorators import api_view

@api_view(['GET'])
def book_list(request):
books = Book.objects.all()

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 3/18
 serializer = BookSerializer(books, many=True)
return Response(serializer.data)

10. What are throttling and rate-limiting in DRF?

Answer: Throttling is used to control the rate of requests a client can make to an API. You can set
different throttling policies, like per-user, per-anonymous user, etc.

python

# settings.py
REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': [
'rest_framework.throttling.UserRateThrottle',
'rest_framework.throttling.AnonRateThrottle',
],
'DEFAULT_THROTTLE_RATES': {
'user': '100/day',
'anon': '10/hour',
}
}

11. How can you handle exceptions in Django REST Framework?

Answer: DRF provides custom exception handling through the `@api_view` decorator or class-based
views using the `handle_exception` method. You can also use middleware or define custom exception
handling globally.

python

from rest_framework.views import exception_handler

def custom_exception_handler(exc, context):

response = exception_handler(exc, context)
if response is not None:
response.data['status_code'] = response.status_code
return response

# settings.py
REST_FRAMEWORK = {
'EXCEPTION_HANDLER': 'my_project.my_app.utils.custom_exception_handler'
}

12. How do you perform filtering in Django REST Framework?

Answer: DRF provides built-in support for filtering using the `django-filter` package. You can filter
QuerySets based on specific fields in your views or use filter backends.

python

from django_filters.rest_framework import DjangoFilterBackend

class BookViewSet(viewsets.ModelViewSet):

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 4/18
 queryset = Book.objects.all()
serializer_class = BookSerializer
filter_backends = [DjangoFilterBackend]
filterset_fields = ['author', 'published_date']

These questions cover various aspects of the Django REST Framework, from basic to intermediate
topics. Interviewers often focus on how well you can explain concepts and apply them in practical
situations.

more questions

Thought for a second

Certainly! Here are additional Django REST Framework (DRF) interview questions along with their
comprehensive answers:

13. What is the purpose of `BrowsableAPIRenderer` in DRF?

Answer: `BrowsableAPIRenderer` is a renderer class in DRF that provides a web-browsable interface for
your API. It allows developers and users to interact with the API through a user-friendly HTML
interface, making it easier to test endpoints without the need for external tools like Postman.

python

# settings.py
REST_FRAMEWORK = {
'DEFAULT_RENDERER_CLASSES': [
'rest_framework.renderers.JSONRenderer',
'rest_framework.renderers.BrowsableAPIRenderer',
],
}

14. Explain the concept of ViewSets vs Generic Views in DRF.

Answer:

ViewSets: Provide a way to combine the logic for a set of related views in a single class. They
automatically handle standard actions like `list`, `create`, `retrieve`, `update`, and `destroy`.
This reduces boilerplate code and simplifies URL routing using routers.

python

from rest_framework import viewsets

class AuthorViewSet(viewsets.ModelViewSet):

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 5/18
 queryset = Author.objects.all()
serializer_class = AuthorSerializer

Generic Views: Offer base classes for building views with common patterns, such as listing or
creating objects. They provide more granular control compared to ViewSets and are suitable
when you need custom behavior.

python

from rest_framework import generics

class AuthorList(generics.ListCreateAPIView):
queryset = Author.objects.all()
serializer_class = AuthorSerializer

15. How do you handle nested serializers in DRF?

Answer: Nested serializers allow you to represent related objects within a serializer. This is useful for
displaying related data in a single API response.

python

from rest_framework import serializers

class BookSerializer(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['id', 'title']

class AuthorSerializer(serializers.ModelSerializer):
books = BookSerializer(many=True, read_only=True)

class Meta:
model = Author
fields = ['id', 'name', 'books']

To handle writable nested serializers (e.g., creating or updating related objects), you need to override
the `create` and `update` methods:

python

class AuthorSerializer(serializers.ModelSerializer):
books = BookSerializer(many=True)

class Meta:
model = Author
fields = ['id', 'name', 'books']

def create(self, validated_data):

books_data = validated_data.pop('books')
author = Author.objects.create(**validated_data)
for book_data in books_data:
Book.objects.create(author=author, **book_data)
return author

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 6/18
 16. What is the role of Routers in DRF?

Answer: Routers in DRF automatically generate URL configurations for ViewSets, reducing the need to
manually define URL patterns for each action. They map HTTP methods to ViewSet actions like `list`,
`create`, `retrieve`, etc.

python

from rest_framework import routers

from myapp.views import BookViewSet

router = routers.DefaultRouter()
router.register(r'books', BookViewSet)

# urls.py
from django.urls import path, include

urlpatterns = [
path('', include(router.urls)),
]

17. How can you customize the default authentication in DRF?

Answer: You can customize authentication in DRF by:

1. Adding or Removing Authentication Classes: Modify the `DEFAULT_AUTHENTICATION_CLASSES` in

`settings.py`.

python

REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework.authentication.SessionAuthentication',
'rest_framework.authentication.BasicAuthentication',
'rest_framework.authentication.TokenAuthentication',
],
}

2. Creating Custom Authentication Classes: Subclass `BaseAuthentication` and implement the

`authenticate` method.

python

from rest_framework.authentication import BaseAuthentication

from rest_framework.exceptions import AuthenticationFailed
from myapp.models import Token

class CustomTokenAuthentication(BaseAuthentication):
def authenticate(self, request):
token = request.headers.get('X-Custom-Token')
if not token:
return None
try:
user_token = Token.objects.get(key=token)
except Token.DoesNotExist:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 7/18
 raise AuthenticationFailed('Invalid token')
return (user_token.user, token)

Then, add your custom class to `DEFAULT_AUTHENTICATION_CLASSES`.

python

REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': [
'myapp.authentication.CustomTokenAuthentication',
],
}

18. What are Signals in Django, and how can they be used in DRF?

Answer: Signals in Django are a way to allow decoupled applications to get notified when certain
events occur. They are useful for executing certain actions automatically in response to events like
model creation, updates, or deletions.
Using Signals in DRF:
For example, you might want to send a notification or update related models whenever a new API
object is created.

python

# signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from myapp.models import Book
from myapp.notifications import send_new_book_notification

@receiver(post_save, sender=Book)
def notify_new_book(sender, instance, created, **kwargs):
if created:
send_new_book_notification(instance)

Connecting Signals: Ensure that the signals are connected when the app is ready.

python

# apps.py
from django.apps import AppConfig

class MyAppConfig(AppConfig):
name = 'myapp'

def ready(self):
import myapp.signals

19. Explain how to implement Versioning in DRF.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 8/18
 Answer: API versioning allows you to manage changes and updates to your API without disrupting
existing clients. DRF supports several versioning schemes:

1. URL Path Versioning: Include the version number in the URL.

python

# urls.py
from django.urls import path, include

urlpatterns = [
path('api/v1/', include('myapp.api.v1.urls')),
path('api/v2/', include('myapp.api.v2.urls')),
]

2. Query Parameter Versioning: Specify the version as a query parameter.

python

# settings.py
REST_FRAMEWORK = {
'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.QueryParameterVersioning',
'ALLOWED_VERSIONS': ['1.0', '2.0'],
'DEFAULT_VERSION': '1.0',
}

Clients can request `?version=2.0`.

3. Header Versioning: Use custom headers to specify the version.

python

# settings.py
REST_FRAMEWORK = {
'DEFAULT_VERSIONING_CLASS': 'rest_framework.versioning.HeaderVersioning',
}

Clients can send `HTTP_X_API_VERSION: 2.0`.

4. Namespace Versioning: Utilize URL namespaces for different versions.

python

# urls.py
from django.urls import path, include

urlpatterns = [
path('api/', include(('myapp.api.v1.urls', 'v1'), namespace='v1')),
path('api/', include(('myapp.api.v2.urls', 'v2'), namespace='v2')),
]

Using Version in Views:

You can access the version in your views via `request.version`.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 9/18
 python

from rest_framework.views import APIView

from rest_framework.response import Response

class ExampleView(APIView):
def get(self, request, format=None):
version = request.version
return Response({'version': version})

20. How do you implement Caching in DRF?

Answer: Caching can improve the performance of your API by storing frequently accessed data. You
can implement caching in DRF using Django’s caching framework.
Steps to Implement Caching:

1. Configure Cache Backend: Define your cache settings in `settings.py`.

python

CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': '127.0.0.1:11211',
}
}

2. Use Cache Decorators: Apply caching decorators to your views.

python

from django.views.decorators.cache import cache_page

from rest_framework.decorators import api_view
from rest_framework.response import Response

@api_view(['GET'])
@cache_page(60*15) # Cache for 15 minutes
def cached_book_list(request):
books = Book.objects.all()
serializer = BookSerializer(books, many=True)
return Response(serializer.data)

3. Cache at the ViewSet Level: Override the `list` method and apply caching.

python

from django.utils.decorators import method_decorator

from django.views.decorators.cache import cache_page
from rest_framework import viewsets

class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer

@method_decorator(cache_page(60*15))

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 10/18
 def list(self, request, *args, **kwargs):
return super().list(request, *args, **kwargs)

4. Use Third-Party Packages: Utilize packages like django-rest-framework-caching for more

advanced caching strategies.

21. What are Hyperlinked Serializers in DRF and how do they differ from standard
serializers?

Answer: HyperlinkedSerializers use hyperlinks to represent relationships between entities, whereas

ModelSerializers typically use primary keys.
Advantages of HyperlinkedSerializers:

More RESTful as they provide URLs to related resources.

Easier navigation of API endpoints.

Example:

python

from rest_framework import serializers

class AuthorSerializer(serializers.HyperlinkedModelSerializer):
books = serializers.HyperlinkedRelatedField(
many=True,
read_only=True,
view_name='book-detail'
)

class Meta:
model = Author
fields = ['url', 'id', 'name', 'books']

class BookSerializer(serializers.HyperlinkedModelSerializer):
author = serializers.HyperlinkedRelatedField(
queryset=Author.objects.all(),
view_name='author-detail'
)

class Meta:
model = Book
fields = ['url', 'id', 'title', 'author']

URL Configuration: Ensure that your routers are set up with appropriate view names.

python

from rest_framework import routers

from myapp.views import AuthorViewSet, BookViewSet

router = routers.DefaultRouter()
router.register(r'authors', AuthorViewSet)
router.register(r'books', BookViewSet)

urlpatterns = [
path('', include(router.urls)),
]

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 11/18
 22. How do you implement Throttling in DRF and what types are available?

Answer: Throttling controls the rate of API requests to prevent abuse and ensure fair usage.
Types of Throttles:

1. UserRateThrottle: Limits the rate based on the authenticated user.

2. AnonRateThrottle: Limits the rate for anonymous users.
3. ScopedRateThrottle: Allows different throttle rates for different parts of the API.

Implementation Steps:

1. Configure Throttle Classes and Rates: Define in `settings.py`.

python

REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': [
'rest_framework.throttling.UserRateThrottle',
'rest_framework.throttling.AnonRateThrottle',
],
'DEFAULT_THROTTLE_RATES': {
'user': '1000/day',
'anon': '100/day',
'burst': '200/minute',
}
}

2. Apply ScopedRateThrottle: Use scopes to define specific rates for different views.

python

from rest_framework.throttling import ScopedRateThrottle

from rest_framework import viewsets

class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
throttle_classes = [ScopedRateThrottle]
throttle_scope = 'burst'

3. Custom Throttle Classes: Create custom throttle classes by subclassing `BaseThrottle`.

python

from rest_framework.throttling import BaseThrottle

class CustomThrottle(BaseThrottle):
def allow_request(self, request, view):
# Implement custom logic
return True

def wait(self):
return None

Then, add it to `DEFAULT_THROTTLE_CLASSES` or use it in specific views.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 12/18
 23. What is `django-filter` and how is it used in DRF?

Answer: `django-filter` is a Django application for allowing users to filter querysets dynamically
based on GET parameters. In DRF, it integrates seamlessly to provide robust filtering capabilities.
Installation:

bash

pip install django-filter

Configuration:

1. Add to Installed Apps:

python

INSTALLED_APPS = [
...
'django_filters',
]

2. Set Filter Backend in DRF Settings:

python

REST_FRAMEWORK = {
'DEFAULT_FILTER_BACKENDS': ['django_filters.rest_framework.DjangoFilterBackend']
}

Usage in Views:

python

from rest_framework import viewsets

from django_filters.rest_framework import DjangoFilterBackend
from myapp.models import Book
from myapp.serializers import BookSerializer

class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
filter_backends = [DjangoFilterBackend]
filterset_fields = ['author', 'genre', 'published_date']

Creating Custom FilterSets:

python

import django_filters
from myapp.models import Book

class BookFilter(django_filters.FilterSet):

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 13/18
 title = django_filters.CharFilter(lookup_expr='icontains')
published_date = django_filters.DateFromToRangeFilter()

class Meta:
model = Book
fields = ['author', 'genre', 'title', 'published_date']

Applying Custom FilterSet to ViewSet:

python

class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
filter_backends = [DjangoFilterBackend]
filterset_class = BookFilter

24. How do you handle file uploads in DRF?

Answer: Handling file uploads in DRF involves configuring serializers and views to accept and process
file data.
Steps to Handle File Uploads:

1. Define the Model:

python

from django.db import models

class Document(models.Model):
title = models.CharField(max_length=100)
file = models.FileField(upload_to='documents/')

2. Create the Serializer:

python

from rest_framework import serializers

from myapp.models import Document

class DocumentSerializer(serializers.ModelSerializer):
class Meta:
model = Document
fields = ['id', 'title', 'file']

3. Implement the View:

python

from rest_framework import viewsets

from myapp.models import Document
from myapp.serializers import DocumentSerializer

class DocumentViewSet(viewsets.ModelViewSet):

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 14/18
 queryset = Document.objects.all()
serializer_class = DocumentSerializer

4. Configure URLs with Router:

python

from rest_framework import routers

from myapp.views import DocumentViewSet

router = routers.DefaultRouter()
router.register(r'documents', DocumentViewSet)

urlpatterns = [
path('', include(router.urls)),
]

5. Client-Side Upload: Use `multipart/form-data` to send files.

bash

curl -X POST -H "Content-Type: multipart/form-data" \

-F "title=Sample Document" \
-F "file=@/path/to/file.pdf" \
http://localhost:8000/documents/

Handling Large Files: For large file uploads, consider using chunked uploads or integrating with
cloud storage services like AWS S3.

25. What are Signals in DRF and how do they differ from Django Signals?

Answer: This appears to be a duplicate or confusion between DRF and Django signals. To clarify:
Django Signals: Django provides a built-in signal dispatcher that allows decoupled applications to get
notified when certain actions occur (e.g., model creation).
DRF Signals: DRF does not have its own signal system separate from Django’s. Instead, developers
use Django signals within DRF projects to handle events related to API operations.
Example Use Case: Using Django’s `post_save` signal to perform actions after an API creates a new
object.

python

from django.db.models.signals import post_save

from django.dispatch import receiver
from myapp.models import Book

@receiver(post_save, sender=Book)
def after_book_save(sender, instance, created, **kwargs):
if created:
# Perform action, e.g., send notification
pass

26. How can you implement Rate Limiting based on IP in DRF?

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 15/18
 Answer: By default, DRF throttling can be based on user or anonymous access, but to implement rate
limiting based on IP, you can create a custom throttle class.
Steps to Implement IP-Based Throttling:

1. Create a Custom Throttle Class:

python

from rest_framework.throttling import SimpleRateThrottle

class IPRateThrottle(SimpleRateThrottle):
scope = 'ip'

def get_cache_key(self, request, view):

return self.get_ident(request) # IP address

2. Configure Throttle Rates: Add the custom throttle to `DEFAULT_THROTTLE_CLASSES` and define its
rate.

python

REST_FRAMEWORK = {
'DEFAULT_THROTTLE_CLASSES': [
'myapp.throttling.IPRateThrottle',
],
'DEFAULT_THROTTLE_RATES': {
'ip': '100/day',
}
}

3. Apply Throttle to Views: Ensure that your views use the throttle classes.

python

from rest_framework import viewsets

class BookViewSet(viewsets.ModelViewSet):
queryset = Book.objects.all()
serializer_class = BookSerializer
throttle_classes = [IPRateThrottle]

Note: `get_ident(request)` retrieves the client’s IP address. Ensure your application correctly handles
cases where the app is behind proxies or load balancers by configuring `USE_X_FORWARDED_HOST` and
related settings.

27. Explain how to use JWT (JSON Web Tokens) with DRF.

Answer: JWT is a popular method for authenticating API requests. To use JWT with DRF, you typically
integrate the `djangorestframework-simplejwt` package.
Steps to Implement JWT Authentication:

1. Install the Package:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 16/18
 bash

pip install djangorestframework-simplejwt

2. Configure DRF to Use JWT:

python

# settings.py
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': (
'rest_framework_simplejwt.authentication.JWTAuthentication',
),
}

3. Update URLs to Include JWT Endpoints:

python

from django.urls import path

from rest_framework_simplejwt.views import (
TokenObtainPairView,
TokenRefreshView,
)

urlpatterns = [
path('api/token/', TokenObtainPairView.as

27th question answer again

Sure! Here's the answer again for the 27th question:

27. How do you handle nested serializers in DRF?

Answer: Nested serializers allow you to represent related objects within a serializer. This is useful for
displaying related data in a single API response.

Example of Nested Serialization:

python

from rest_framework import serializers

class BookSerializer(serializers.ModelSerializer):
class Meta:
model = Book
fields = ['id', 'title']

class AuthorSerializer(serializers.ModelSerializer):

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 17/18
 books = BookSerializer(many=True, read_only=True)

class Meta:
model = Author
fields = ['id', 'name', 'books']

Handling Writable Nested Serializers:

To handle writable nested serializers (e.g., creating or updating related objects), you need to override
the `create` and `update` methods in the parent serializer:

python

class AuthorSerializer(serializers.ModelSerializer):
books = BookSerializer(many=True)

class Meta:
model = Author
fields = ['id', 'name', 'books']

def create(self, validated_data):

books_data = validated_data.pop('books')
author = Author.objects.create(**validated_data)
for book_data in books_data:
Book.objects.create(author=author, **book_data)
return author

def update(self, instance, validated_data):

books_data = validated_data.pop('books')
instance.name = validated_data.get('name', instance.name)
instance.save()

# Update books
for book_data in books_data:
book = instance.books.get(id=book_data.get('id'))
book.title = book_data.get('title', book.title)
book.save()
return instance

In this example, the `AuthorSerializer` can create and update authors along with their associated
books by handling nested data properly.
ChatGPT can make mistakes. Check important info.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 18/18