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:

Check out our free courses to get an edge over the competition.

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.

Reasons to Choose the Django REST Framework

The primary reasons to choose the Django REST framework are as follows:

Standardized Structure

The REST framework of Django can be useful for finding the right structure for a project. That structure enables developers to find out how and where to implement new features. It ensures that you find a widely accepted project structure that has been similar to various projects. 

Even if you face any complications with that project structure, you will be able to find ample support from online communities. The passionate Python developers in the industry will ensure that you are easily able to solve issues that you might witness. 

Batteries-Included Philosophy

The batteries-included philosophy ensures that you find common functionality for developing web applications inside the framework. You won’t find separate libraries for building common web functions. 

Django offers a wide range of functionalities that are necessary for tackling mainstream web development tasks. The high-level functionalities offered by Django are as follows:

• Database migrations
• ORM
• Admin panel
• Forms
• User Authentication

If you were using a micro-framework, you would have to stick together these functionalities separately. 

High Security

Django comes with a wide range of security solutions. They include prevention mechanisms for common issues like Cross-site Request Forgery or Sequel Injection. Apart from that, Django also offers clickjacking protection, SSL/HTTPS protection, session security, and other effective measures. 

GraphQL Framework for Building APIs

A large Django REST API needs multiple requests to various data endpoints for retrieving necessary data. GraphQL is a query language to help share related data in an easier fashion. Graphene-Django offers abstractions that make it convenient to include GraphQL functionality in a Django project. Regular Django models, authentication, forms, permission policies, and various other functionalities are employed again and again to develop the GraphQL schema. It also comes with an in-built API browser for testing different API endpoints. 

Easy to Add Functionality

Django applications enable developers to segment a project into different applications. Anything installed by placing in settings.INSTALLED_APPS can be easily considered an app. This makes it convenient for developers to include functionality to the web application by bringing external Django applications inside the project. You can leverage multiple reusable apps and modules to speed up the development process. 

Customizable Architecture for API Building

The Django REST framework, or DRF, comes with an extensive Python library for building APIs. It provides a modular and customizable architecture that can aid in the development of simple as well as more complex APIs. DRF comes with a set of unique permission and authentication policies. 

The Django REST framework can be described as a flexible library with multiple features to build valuable APIs. The framework is accompanied by CRUD operations as well as an in-built API browser for testing API endpoints. 

Explore our Popular Software Engineering Courses

Check out upGrad’s Advanced Certification in Cyber Security 

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.

Check out upGrad’s Advanced Certification in Cloud Computing 

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

In-Demand Software Development Skills

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

Explore Our Software Development Free Courses

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.