Hello there, in this article we will learn how to quickly make a CRUD RESTFul API in the Django rest framework. Few pre-requisite we assume that the reader knows python, very basics of Django, and have an understanding of MVC or MVT architecture

So first let's create a virtual environment, it is an optional step but is good practice to have project dependencies portable. Refer to Virtual Env guide to making one for this project.

Now let's install Django after that DjangoRestFramework and create our project.

pip install django

pip install djangorestframework

Creating Project in django

django-admin startproject 'project_name'
#django-admin startproject Marvel

go to the project directory

Create an app with the below command, one thing here is one project can have many apps and the ones we are using should be added in the settings.py file of our project inside INSTALLED_APPS[]. So we need to add our 'app_name' and 'rest_framework' to the list.

python manage.py startapp 'app_name'
#python manage.py startapp Spiderverse

We have our project ready now and the app inside as well. Open it in any IDE and go to the models.py file of your app. Quick overview it has the structure of our model(s) which is our database representation of the entity.

Here is guide to make model quickly and refer this for more insight. Below is a sample model for your reference

Marvel/Spiderverse/models.py

from django.db import models


class Spiderverse(models.Model):
    name= models.CharField(max_length = 50)
    description= models.TextField()

Now we need a Serializer class for our model, we can create it from scratch for each field of the model and have separate update() and create() methods overridden or we could just use model serializers to make things easy and quick.

Why do we need Serializers in the first place? in simple terms, serializer return data into python native datatypes from complex datatypes like Queryset, and native data can be easily converted to JSON or XML, etc which makes data representation easy.

Marvel/Spiderverse/serializers.py

from rest_framework import serializers
from .models import Spiderverse


class SpiderSerializers(serializers.ModelSerializer):
    class Meta:
        model = Spiderverse
        fields = "__all__"

Now we will move towards creating views for our mini project, views will have most of our logic of CRUD. We will use here class-based views that reuse already created code functionality from generics classes and mixins that have commonly used logic.

For example, our code logic for get() and post() method which we can overwrite using mixins that will be common for every model is already implemented in generics classes we just have inherited that code. Below is the implementation of get() post() method if we use mixin for creating and listing all the elements of the class.

class SpiderverseList(mixins.ListModelMixin, mixins.CreateModelMixin, generics.GenericAPIView):
    queryset = Spiderverse.objects.all() 
    serializer_class = SpiderSerializer 

    def get(self, request, *args, **kwargs): 
        return self.list(request, *args, **kwargs) 

    def post(self, request, *args, **kwargs): 
        return self.create(request, *args, **kwargs)

Now if we use generics.ListCreateAPIView, instead of the mixins we used above, generics have already implemented these methods for us, we will just inherit the class and assign modelserializer and queryset.

Marvel/Spiderverse/views.py

from .models import Spiderverse 
from .serializers import SpiderSerializer 
from rest_framework import generics 


class SpiderverseList(generics.ListCreateAPIView):
    queryset = Spiderverse.objects.all() 
    serializer_class = SpiderSerializers 

class SpiderverseDetail(generics.RetrieveUpdateDestroyAPIView): 
    queryset = Spiderverse.objects.all()
    serializer_class = SpiderSerializers

for Retrieve, Update, and Delete part of our implementation we used generics.RetrieveUpdateDestroyAPIView class. Now the final thing is to set up URLs for each view in urls file. Add the application to the projects urls.py file.

Marvel/urls.py

from django.urls import path, include 


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

and below code is for our app.

Marvel/Spiderverse/urls.py

from django.urls import path 
from .views import SpiderverseList, SpiderverseDetail 


urlpatterns = [ path('spider/', SpiderverseList.as_view()), 
path('spider/<int:pk>/', SpiderverseDetail.as_view()) ]

so this is it below our mini RESTFul API is ready and we can perform operations using given URLs and parameters. I have used postman for this example you can use any frontend you have, django forms or curl, etc options.

Last but not least, Do not forget to make migrations to make a database for our model.

python manage.py makemigrations
python manage.py migrate

Refer django and django restframwrok for a detailed guide.