Why Generic views in DRF in Django? - Purpose & Use Cases

The Big Idea

Discover how to stop repeating yourself and build APIs faster with less code!

The Scenario

Imagine building an API where you write separate code for listing, creating, updating, and deleting items for every model.

You have to repeat similar code again and again for each endpoint.

The Problem

Writing all these views manually is slow and boring.

It's easy to make mistakes or forget to handle some HTTP methods properly.

Maintaining and updating this repeated code becomes a headache as your project grows.

The Solution

Generic views in DRF provide ready-made classes that handle common API actions like list, create, update, and delete.

You just configure them with your model and serializer, and they do the heavy lifting for you.

Before vs After

✗ Before

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

✓ After

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

What It Enables

You can build clean, consistent, and maintainable APIs quickly without rewriting common logic.

Real Life Example

When creating a blog API, you can use generic views to handle posts and comments with minimal code, focusing on unique features instead of boilerplate.

Key Takeaways

Manual API views require repetitive code for common actions.

Generic views provide reusable classes for standard API operations.

This saves time, reduces errors, and makes your code easier to maintain.

Practice

1. What is the main purpose of using generic views in Django REST Framework (DRF)?

easy

A. To provide ready-made classes that simplify common API tasks like CRUD operations

B. To write raw SQL queries directly in views

C. To handle user authentication manually

D. To create HTML templates for the frontend

Solution

1. Step 1: Understand generic views role

   Generic views in DRF offer pre-built classes to handle common API tasks such as listing, creating, updating, and deleting data.

2. Step 2: Compare options

   Options B, C, and D describe unrelated tasks: raw SQL, manual auth, and frontend templates, which are not the main purpose of generic views.

3. Final Answer:

   To provide ready-made classes that simplify common API tasks like CRUD operations -> Option A

4. Quick Check:

   Generic views simplify CRUD = A [OK]

Hint: Generic views = ready-made CRUD classes in DRF [OK]

Common Mistakes:

• Confusing generic views with authentication classes
• Thinking generic views handle frontend rendering
• Assuming generic views require manual SQL

2. Which of the following is the correct way to use a generic view to list all objects of a model named Book in DRF?

easy

A. class BookList(generics.ListAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer

B. class BookList(generics.CreateAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer

C. class BookList(generics.UpdateAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer

D. class BookList(generics.DestroyAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer

Solution

1. Step 1: Identify the generic view for listing objects

   The ListAPIView is designed to list all objects of a model.

2. Step 2: Match the class with the task

   Options B, C, and D correspond to creating, updating, and deleting respectively, which do not list objects.

3. Final Answer:

   class BookList(generics.ListAPIView):\n queryset = Book.objects.all()\n serializer_class = BookSerializer -> Option A

4. Quick Check:

   List all objects = ListAPIView = A [OK]

Hint: List objects use ListAPIView class [OK]

Common Mistakes:

• Using CreateAPIView for listing data
• Confusing UpdateAPIView with ListAPIView
• Forgetting to set queryset or serializer_class

3. Given this DRF generic view code, what will be the HTTP method supported and the main action performed?

class ArticleDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

medium

A. Supports only POST method to create a new article

B. Supports GET, PUT, PATCH, DELETE methods to retrieve, update, or delete an article

C. Supports GET method to list all articles

D. Supports DELETE method only to remove all articles

Solution

1. Step 1: Understand RetrieveUpdateDestroyAPIView

   This generic view supports retrieving a single object (GET), updating it (PUT/PATCH), and deleting it (DELETE).

2. Step 2: Match HTTP methods to actions

   Supports GET, PUT, PATCH, DELETE methods to retrieve, update, or delete an article correctly describes the supported methods (GET for retrieve, PUT/PATCH for update, DELETE for destroy) for a single article. Options A, C, and D describe incorrect methods or actions.

3. Final Answer:

   Supports GET, PUT, PATCH, DELETE methods to retrieve, update, or delete an article -> Option B

4. Quick Check:

   RetrieveUpdateDestroyAPIView = GET, PUT/PATCH, DELETE [OK]

Hint: RetrieveUpdateDestroyAPIView handles GET, PUT/PATCH, DELETE [OK]

Common Mistakes:

• Thinking it supports POST for creation
• Confusing list view with detail view
• Assuming it deletes all objects instead of one

4. Identify the error in this DRF generic view code snippet:

class UserCreate(generics.CreateAPIView):
    serializer_class = UserSerializer

medium

A. CreateAPIView does not exist in DRF

B. serializer_class should be named serializer

C. Class name should be lowercase

D. Missing queryset attribute causes runtime error

Solution

1. Step 1: Check required attributes for CreateAPIView

   While CreateAPIView requires serializer_class, it also typically needs a queryset attribute to function properly without errors, especially in standard setups with permissions.

2. Step 2: Identify the error

   The missing queryset attribute causes runtime errors in many scenarios. Options A, B, and D are incorrect: CreateAPIView does exist (A), serializer_class is the correct name (B), and class names should use PascalCase (D).

3. Final Answer:

   Missing queryset attribute causes runtime error -> Option D

4. Quick Check:

   Missing queryset = runtime error [OK]

Hint: Always set queryset with generic views unless serializer handles all [OK]

Common Mistakes:

• Omitting queryset attribute
• Renaming serializer_class incorrectly
• Thinking CreateAPIView is invalid
• Using lowercase class names

5. You want to create a DRF API endpoint that allows listing all Product items and creating new ones in the same view. Which generic view class should you use and why?

hard

A. Use generics.ListAPIView only because creation should be separate

B. Use generics.RetrieveUpdateDestroyAPIView because it handles all CRUD operations

C. Use generics.ListCreateAPIView because it supports both listing and creating in one view

D. Use generics.CreateAPIView only because listing is not needed

Solution

1. Step 1: Identify the requirement

   The endpoint must list all products and allow creating new ones in the same view.

2. Step 2: Match generic view to requirement

   ListCreateAPIView is the correct choice as it supports GET (listing) and POST (creating). Use generics.RetrieveUpdateDestroyAPIView because it handles all CRUD operations (RetrieveUpdateDestroyAPIView) is for single-object detail operations. Options A and C support only a single action each.

3. Final Answer:

   Use generics.ListCreateAPIView because it supports both listing and creating in one view -> Option C

4. Quick Check:

   List + Create = ListCreateAPIView [OK]

Hint: ListCreateAPIView combines list and create in one view [OK]

Common Mistakes:

• Using RetrieveUpdateDestroyAPIView for list/create
• Choosing only CreateAPIView or ListAPIView alone
• Not combining actions in one view