Introduction To Django REST Framework: Development with Examples

The Django REST Framework is widely distributed as a standard Python package that users may require to get started with developing RESTful APIs. It is sophisticated, powerful, amazingly easy to use, and offers an attractive and browsable version for APIs. The Django REST Framework provides the option of returning JSON objects. This framework offers a powerful serialization of the model and displays the data using basic function-based views altogether in a fully REST viewer. Know more about the Django REST framework below:

What Is The Django REST Framework?

The Django REST Framework is a flexible and robust tool kit that makes it easy for developers to build web APIs. It also offers class-based generalized views and serializers for the API. Being a source code, it is abbreviated as DRF, which represents a Python library for developing web application programming interfaces. As in this article, we are talking about development APIs with step-by-step instructions.

But before getting started with the guide, it is important to understand why the framework is even important. Many available frameworks allow developers to build APIs for their block applications easily, but the Django REST framework is preferred. This framework is convenient to use in a number of ways and offers the below-mentioned advantages-

• It offers web browsers an able Application Programming Interface, which is a great win for developers
• It has authentication policies including the packages for OAuth1, OAuth2, etc
• the serialization processor in it supports the ORM and non-ORM data sources
• this framework has extensive documentation and offers great community support
• It is utilized and trusted by great platforms, including Mozilla, Heroku, RedHat, etc.

Read: Django Applications: Everything You Need to Know About

Set The Django REST Framework Development

For starters, you have to install the Python dependencies for the operating system. If you are using the Windows platform, you can easily install the Linux platform as your secondary operating system with a virtual box or a manual command. To proceed with the framework, you can use effective and convenient Python management tools.

Most of the tools are a go-to helper. They allow developers to change Python versions quickly, set project-specific versions, manage the virtual environment, and install multiple versions on the system. If you are using Linux or Mac operating systems, it would be easy to install it.

With the Django REST framework’s help, we can convert a non-RESTful application into a RESTful one. This is inclusive of the below-mentioned procedures-

DRF Setup

For DRF Setup, you have to install-

Shell

$ pip install djangorestframework 

$ pip freeze > requirements.txt

Update settings:py:

Python

INSTALLED_APPS = (

‘django.contrib.admin’,

    ‘django.contrib.auth’,

    ‘django.contrib.contenttypes’,

    ‘django.contrib.sessions’,

    ‘django.contrib.messages’,

    ‘django.contrib.staticfiles’,

    ‘talk’,

    ‘rest_framework’

)

RESTful Structure

In a RESTful API development, the endpoints represent its structure and user access from the application with the help of methods like GET, PUT, POST, DELETE. These endpoints are logically organized around the element and collections, both of which are counted as resources. If there is a single resource then corresponding links will be used as URLs for elements and collections.

GET 

POST

PUT  

DELETE

/posts/

Show all posts 

Add new post

Update all posts 

Delete all posts

/posts/<id>

Show <id>

N/A 

Update <id>

Delete id

Serializers And Views

The major building block of the Django REST framework is serializers, and they are used to elaborate on the representation of various data records based on the Django models. Serializers are the standard Python class that can inherit the behavior of the model from the framework.

Inside the serializers class, separate fieldsets are present that utilize data types from their package of the same framework. They also noticed the similarities between the framework and classes. Serializer classes on their own do not think, and they are integrated with views that manage the bulk of REST service logic. Furthermore, it uses the serializer classes to transform the data. For example, a regular Django view method is-

from coffeehouse.stores.models import Store

from coffeehouse.stores.serializers import StoreSerializer

from rest_framework.decorators import api_view

from rest_framework.response import Response

@api_view([‘GET’,’POST’,’DELETE’])

def rest_store(request):

    if request.method == ‘GET’:

        stores = Store.objects.all()

        serializer = StoreSerializer(stores, many=True)

        return Response(serializer.data)

    elif request.method == ‘POST’:

        … #logic for HTTP POST operation

    elif request.method == ‘DELETE’:

        … #logic for HTTP DELETE operation

Class-Based Views

With the help of class-based views, the Django REST framework provides access to users’ supreme and complex functions. Class-based views offer the functions of true fully-fledged Python classes and allow Django views to easily operate with the help of object-oriented programming principles that leads to greater reusability along with short implementation times.

The Django class-based views highlight a powerful approach to build Django views, and they are also an alternative to the methods that are used to build APIs. To develop a class-based view, it is important to create a class that can inherit from one of the other classes. For example:

# views.py

from Django.views.generic import TemplateView

class AboutIndex(TemplateView):

      template_name = ‘index.html’

      def get_context_data(self, **kwargs):

         # **kwargs contains keyword context initialization values (if any)

         # Call base implementation to get a context

         context = super(AboutIndex, self).get_context_data(**kwargs)

         # Add context data to pass to template

         context[‘aboutdata’] = ‘Custom data’

         return context 

# urls.py

from coffeehouse.about.views import AboutIndex

from django.urls import path

urlpatterns = [

   path(‘about/index/’,AboutIndex.as_view(),{‘onsale’:True}),

Checkout: Top 12 Django Interview Questions & Answers for Beginners

Update Views

To fit the RESTful application structure it is important to refactor the current views. You can comment out these views and add them as-

Python

from django.shortcuts import render

from django.http import HttpResponse

from rest_framework.decorators import api_view

from rest_framework.response import Response

from talk.models import Post

from talk.serializers import PostSerializer

from talk.forms import PostForm

def home(request):

    tmpl_vars = {‘form’: PostForm()}

    return render(request, ‘talk/index.html’, tmpl_vars)

@api_view([‘GET’])

def post_collection(request):

    if request.method == ‘GET’:

        posts = Post.objects.all()

        serializer = PostSerializer(posts, many=True)

        return Response(serializer.data)

@api_view([‘GET’])

def post_element(request, pk):

    try:

        post = Post.objects.get(pk=pk)

    except Post.DoesNotExist:

        return HttpResponse(status=404)

    if request.method == ‘GET’:

        serializer = PostSerializer(post)

        return Response(serializer.data)

Explanation

• In the instructions that are given above, the @api_view decorator analyses the corresponding HTTP request, which is passed into the view function.
• Now the view either use a single post if it is for an element or grabs the entire data if it is for the collection
• Finally, the data is now serialized to the JSON and returned accordingly

Web Browsable API Or Updated URL

Some updated URLs for Python are:

# Talk URLs

from django.conf.urls import patterns, URL

urlpatterns = patterns(

    ‘talk.views’,

    url(r’^$’, ‘home’),

    # api

    url(r’^api/v1/posts/$’, ‘post_collection’),

    url(r’^api/v1/posts/(?P<pk>[0-9]+)$’, ‘post_element’)

)

Refactor For RESTful API Integration

It is inclusive of the major HTTP methods like-

GET

Initial page load, it is important to display the posts, and to do that, you can add this request:

load_posts()

// Load all posts on page load

function load_posts() {

    $.ajax({

        url : “api/v1/posts/”, // the endpoint

        type : “GET”, // http method

        // handle a successful response

        success : function(json) {

            for (var i = 0; i < json.length; i++) {

                console.log(json[i])

                $(“#talk”).prepend(“<li id=’post-“+json[i].id+”‘><strong>”+json[i].text+”</strong> – <em> “+json[i].author+”</em> – <span> “+json[i].created+

                “</span> – <a id=’delete-post-“+json[i].id+”‘>delete me</a></li>”);

            }

        },

        // handle a non-successful response

        error : function(xhr,errmsg,err) {

            $(‘#results’).html(“<div class=’alert-box alert radius’ data-alert>Oops! We have encountered an error: “+errmsg+

                ” <a href=’#’ class=’close’>&times;</a></div>”); // add the error to the dom

            console.log(xhr.status + “: ” + xhr.responseText); // provide a bit more info about the error to the console

        }

    });

};

POST

POST requests are managed in a similar fashion and you can test this by updating the views. You can update the post_collection () function in views.py:

@api_view([‘GET’, ‘POST’])

def post_collection(request):

    if request.method == ‘GET’:

        posts = Post.objects.all()

        serializer = PostSerializer(posts, many=True)

        return Response(serializer.data)

    elif request.method == ‘POST’:

        data = {‘text’: request.DATA.get(‘the_post’), ‘author’: request.user.pk}

        serializer = PostSerializer(data=data)

        if serializer.is_valid():

            serializer.save()

            return Response(serializer.data, status=status.HTTP_201_CREATED)

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Also Read: Django Developer Salary in India

The Bottom Line

The actual Django REST framework‘s REST part is pretty simple and all you have to do is update the post element function in order to handle the request. If you still have any queries then there are a number of Django REST frameworks and resources for improvisation.

If you’re interested to learn more about Django and other full-stack developer languages and tools, check out upGrad & IIIT-B’s PG Diploma in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects, and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.