Introduction To Django REST Framework: Development with Examples
Updated on Jul 03, 2023 | 10 min read | 7.8k views
Share:
For working professionals
For fresh graduates
More
Updated on Jul 03, 2023 | 10 min read | 7.8k views
Share:
Table of Contents
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.
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-
The primary reasons to choose the Django REST framework are as follows:
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.
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:
If you were using a micro-framework, you would have to stick together these functionalities separately.
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.
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.
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.
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.
Check out upGrad’s Advanced Certification in Cyber Security
Read: Django Applications: Everything You Need to Know About
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-
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’
)
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
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
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
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
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’)
)
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’>×</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 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 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.
Get Free Consultation
By submitting, I accept the T&C and
Privacy Policy
India’s #1 Tech University
Executive PG Certification in AI-Powered Full Stack Development
77%
seats filled
Top Resources