An API is used by two applications trying to communicate with each other over a network or Internet. <\/em>With this definition in mind, let\u2019s look at a block diagram.<\/em><\/p>\n The above figure helps in visualizing the working of an API. The API acts as a mediator between Django and other applications. As you can see, other applications can be from Android, iOS, Web apps, browsers, etc.<\/p>\n The API’s main task is to receive data from other applications and provide them to the backend. This data is usually in JSON format.<\/p>\n Okay, so some of you may ask what about those so-called Google APIs. Okay, let\u2019s see. They are also APIs of the same nature. Understand it like Google providing the API as a service.<\/p>\n Here, you can see some of the common examples of APIs used by developers.<\/p>\n API Examples<\/a><\/p>\n This is the link of Google geocoding API used to insert the functionality of Google Maps on your website. This is one of the many examples. Not just Google but many companies provide their APIs as a service. These services are used by the developers to provide maps service to end-users.<\/p>\n There is nothing different for these APIs and the ones we discussed earlier. These APIs do the same thing, they simply transfer data from our application to the Google server. The server then returns the response through this very same API. That response is then passed by our server to the end-user.<\/p>\n Sometimes, this can be bypassed to directly give a response to the end-user.<\/p>\n APIs are programs that exist to transfer data between applications. They are responsible for cleaning and formatting data correctly.<\/strong><\/p>\n Well, first we need to understand what is REST. Don\u2019t worry, I will explain it in simple words.<\/p>\n REST stands for Representational State Transfer<\/strong>. REST is an architecture on which we develop web services. Web services can be understood as your device connects to the internet.<\/p>\n When you search for anything on Google or watch something on YouTube, these are web services where your device is communicating to a server.<\/p>\n When these web services use REST Architecture, they are called RESTful Web Services. These web services use HTTP to transmit data between machines. now, back to the question, what are RESTful APIs?<\/p>\n A RESTful API acts as a translator between two machines communicating over a Web service.<\/strong> This is just like an API but it’s working on a RESTful Web service. Web developers program REST API such that server can receive data from applications.<\/p>\n These applications can be web-apps, Android\/iOS apps, etc. RESTful APIs today return JSON files that can be interpreted by a variety of devices.<\/p>\n The RESTful API will provide standardized data to all devices. Currently, that is achieved by JSON format but REST is not limited to that. Okay, for the last part JSON, we will see it in further sections.<\/p>\n One last question to be answered.<\/p>\n So, as we learned in previous sections, DRF is an acronym for Django REST Framework. (stating the obvious) It\u2019s used to develop REST APIs for Django. Yup, DRF is used to develop RESTful APIs which is both easy and a smart way.<\/p>\n DRF is a framework built upon the Django Framework. It is not a separate framework. You can say that it is a tool which alongside Django is used to develop RESTful APIs<\/em>. It increases the development speed. It also addresses various security issues natively.<\/p>\n DRF is an Open Source Software, just like Django. It is actively developed by various MNCs. If you made any profit from this framework then please donate it to keep it open source.<\/p>\n The documentation of DRF is actually considered better than Django\u2019s. The only catch is that you need to have a bit of previous knowledge to understand the DRF documentation. Django is, of course, the prerequisite but also some basic knowledge of REST is necessary.<\/p>\n Also, we will discuss various features of the Django Rest Framework alongside.<\/p>\n Note:\u00a0<\/strong>All the code for this article is in this repository:<\/p>\n Django Rest Framework Tutorial<\/a><\/p>\n Let\u2019s start by making a new django-project. In your virtual environment, make a new project DRFtutorial<\/strong>. We will develop a simple API to understand what is done by DRF.<\/p>\n When you make the project just move inside the DRFtutorial directory. Then run<\/p>\n The basic_api is created. Now, we also need to install Django REST Framework. To install it, execute this command.<\/p>\n Now, open settings.py<\/strong> file of your project. There install these two apps, \u2018rest_framework\u2019<\/strong> & \u2018basic_api\u2019<\/strong>. Just include them in the INSTALLED_APPS list.<\/p>\n Now, paste this code of model in basic_api\/models.py<\/strong> file.<\/p>\n Code:<\/strong><\/p>\n Also, register this model with django-admin. Add this code to basic_api\/admin.py<\/strong> file.<\/p>\n Code:<\/strong><\/p>\n Ok, now we need to migrate our changes in the database. Execute these two commands in the terminal.<\/p>\n Now, we can use the admin to populate our database. Also, before that please create a superuser. You can create a superuser by executing the following command.<\/p>\n Fill in your details which prompts you and then you should get something similar to this image.<\/p>\n Start your server and populate your database with the use of Django-admin.<\/p>\n Execute command:<\/strong><\/p>\n Then open URL: localhost:8000\/admin<\/em><\/p>\n After that, log in with your superuser credentials. Then add some records in the basic_api<\/strong> app.<\/p>\n After that, our first part of DRF comes into play.<\/p>\n We developed our models in the previous section. In this section, we will develop serializers. Let\u2019s understand what are these serializers used for.<\/p>\n Serializers are used to transform our model instances or objects into JSON.<\/strong><\/p>\n An API\u2019s end result is always JSON. API\u2019s communicate with multiple technologies which take JSON as their Input. JSON stands for JavaScript Object Notation. It is simply a JavaScript notation.<\/p>\n You can say it’s similar to the Python dictionary<\/strong><\/em>. It’s just a file that is sent\/ received by the API to various applications. That\u2019s what serializers help us do here.<\/p>\n Serializers are an important part of DRF. We will be using serializers to get the JSON files for our models. It\u2019s not easy to implement with just Django. Serializers can easily create JSON responses from our model instances. This is one of the magical things DRF can perform.<\/p>\n To implement serializers<\/strong> in our project, create a new file in the basic_api<\/strong> directory called serializers.py<\/strong>. Then paste this code in the file basic_api\/serializers.py<\/strong>:<\/p>\n Code:<\/strong><\/p>\n Understand the code:<\/strong><\/p>\n Let\u2019s understand what we just did. We created a new file serializers.py<\/strong> in our application. This file contains the code similar to modelforms<\/strong> code.<\/p>\n We imported the serializer<\/strong> class from the rest_framework<\/strong> module. This is the DRF used in Django. They couldn\u2019t use Django as it would conflict with the existing name itself. Then we imported the model we wanted serializer for.<\/p>\n Then like model forms class<\/strong>, we created serializer class<\/strong>. This is called the model serializer<\/strong> class. The model serializer class will take the model attribute and field attribute.<\/p>\n The model attribute will input the model for the serializer. The fields attribute takes a list containing the names of fields. These are the fields which will be passed as a json file. Now, we will also need views and urls to see how all this works.<\/p>\n We are going to use class_based views here. This is different from function-based views. In basic_api\/views.py<\/strong> file, paste this code:<\/p>\n Understand the code:<\/strong><\/p>\n The views written here are simply CBVs or class-based views. Also, they are not simple CBVs but DRFs generic class\u2019s CBVs.<\/p>\n In the first 4 lines, we are importing all the important things we are going to need in view. We imported models, serializer class and generics class<\/strong>. The generics class will provide us with the web browsable API. The generics class is a special class in rest_framework.<\/p>\n There are also generic views for Django itself. They are for a different purpose.<\/p>\n You need to keep it in mind that this is an API. It’s not meant to be displayed to the user. It’s for programs or applications communication. The generics class will provide us with important classes. These classes make it easy to deal with RESTful requests and send JSON data.<\/p>\n The first view class is Post_objects<\/strong>. This class extends the class generics.ListCreateAPIView class<\/strong>. It is clear from the name. This class will be used to provide a list of all model instances. These model instances will be converted to JavaScript objects<\/strong> <\/em>and transmit to application.<\/p>\n There are two fields in this class. The first is the Queryset attribute. This attribute will provide the model instances to be operated on. The view classes are written by DRF developers and we need not learn what\u2019s it doing behind the scenes. The second attribute it asks for is serializer_class<\/strong>.<\/p>\n The serializer class we just imported is entered there.<\/p>\n This means that this is the serializer model to be used to create a JSON model. The view part will handle the calling of correct classes and queries. It will then respond with the JSON response to the client or other application.<\/p>\n The second view class is also similar to the 1st. I discussed earlier; this view logics are not needed to be known. You should know what results we get. You do not need to reinvent the wheel or have an understanding of the whole framework. The second class will provide details of an individual object.<\/p>\n There are more operations that can be performed on an individual object. Therefore, we are using class generics.RetrieveUpdateDestroyAPIView class<\/strong>. This class will provide Read, Update and Delete Functions on the model instance. Ok, now let\u2019s set up the urls.<\/p>\n Now, create a new file as basic_api\/urls.py<\/strong>. This is urls for the basic_api<\/strong> app. Paste this code in the basic_api\/urls.py file.<\/p>\n Understanding the code:<\/strong><\/p>\n In this code, we have created a urls.py file. There are some new terms here though. The new import is from rest_framework.urlpatterns<\/strong>. The format_suffix_patterns<\/strong> method will be used to generalize our urls. It will make the urls to work with URIs like<\/p>\n http:\/\/basic\/4 and http:\/\/basic\/4.json<\/p>\n Both of these urls can be handled by our web app. Then we imported the views from the basic_api app. After that, we simply defined the urls.<\/p>\n The new part is the view function we have written. This is what you call a view from a Class-Based Views in Django. In the view functions, we write the name of the class. The class name is always accompanied by the as_view()<\/strong> method. This is true for all CBVs out there and is not limited to DRF.<\/p>\n That\u2019s it. After that the format_sufix_patterns()<\/strong> is used on urlpatterns.<\/p>\n Configuring main urls.py file<\/strong><\/p>\n Paste these lines of code in the DRFtutorial\/urls.py<\/strong> file.<\/p>\n Code:<\/strong><\/p>\n The setup is now complete. Save your changes and again reload the server. After you have reloaded the server, open this URL:\u00a0http:\/\/localhost:8000\/basic\/<\/em><\/p>\n It will come up with this output.<\/p>\n From the urls.py file, you can easily say that this is the list of objects.<\/p>\n The code you can see in square braces []<\/strong> is the actual JSON output. I told you earlier, JSON looks very similar to Dictionaries in Python<\/strong><\/em>.<\/p>\n For a brief introduction, JSON is simply a JavaScript Data Structure. It stores values in a key: value pairs. JSON is simply a format which is used as a standard for data interchange. It is lightweight and therefore, takes in less bandwidth.<\/p>\n A simple JSON object from our example is:<\/p>\n Here the keys<\/strong> are strings and values<\/strong> can be strings or other data-structures. The values can be objects too. JSON is beginner-friendly and easy to use.<\/p>\n The id<\/strong> is key and 1<\/strong> is value<\/strong>. That is the formatted data that applications can use to extract information. Structured information is always favored.<\/p>\n Now, your search for this URL:\u00a0\u00a0http:\/\/localhost:8000\/basic\/2\/<\/em><\/p>\n![\"Working](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/11\/Working-example-of-REST-API-1.png\")
<\/a><\/p>\n<\/a><\/p>\nWhat are RESTful APIs?<\/h3>\n
<\/a><\/p>\nWhat is Django REST Framework?<\/h3>\n
<\/a><\/p>\nMaking a basic_api with DRF<\/h3>\n
<\/a><\/p>\n django-admin startproject DRFtutorial<\/pre>\n
python manage.py startapp basic_api<\/pre>\n
<\/a><\/p>\n pip install djangorestframework==3.10<\/pre>\n
<\/a><\/p>\n<\/a><\/p>\n# basic_api\/models.py\r\nfrom django.db import models\r\n\r\n#list\r\nGrade = [\r\n ('excellent', 1),\r\n ('average', 0),\r\n ('bad', -1)\r\n]\r\n\r\n# DataFlair\r\nclass DRFPost(models.Model):\r\n name = models.CharField(max_length = 100)\r\n author = models.CharField(max_length = 100)\r\n uploaded = models.DateTimeField(auto_now_add = True)\r\n rating = models.CharField(choices = Grade, default = 'average', max_length = 50)\r\n\r\n class Meta:\r\n ordering = ['uploaded']\r\n\r\n def __str__(self):\r\n return self.name\r\n<\/pre>\n<\/a><\/p>\nfrom django.contrib import admin\r\nfrom basic_api.models import DRFPost\r\n\r\n# DataFlair\r\nadmin.site.register(DRFPost)<\/pre>\n
<\/a><\/p>\n\u00a0python manage.py makemigrations\r\n\u00a0python manage.py migrate<\/pre>\n
<\/a><\/p>\n\u00a0python manage.py createsuperuser<\/pre>\n
<\/a><\/p>\n\u00a0python manage.py runserver<\/pre>\n
<\/a><\/p>\nSerializers<\/h3>\n
from rest_framework import serializers\r\nfrom basic_api.models import DRFPost\r\n\r\nclass DRFPostSerializer(serializers.ModelSerializer):\r\n class Meta:\r\n model = DRFPost\r\n fields = '__all__'<\/pre>\n
<\/a><\/p>\nAdding views<\/h3>\n
from django.shortcuts import render\r\nfrom rest_framework import generics\r\nfrom basic_api.models import DRFPost\r\nfrom basic_api.serializers import DRFPostSerializer\r\n\r\nclass API_objects(generics.ListCreateAPIView):\r\n queryset = DRFPost.objects.all()\r\n serializer_class = DRFPostSerializer\r\n\r\nclass API_objects_details(generics.RetrieveUpdateDestroyAPIView):\r\n queryset = DRFPost.objects.all()\r\n serializer_class = DRFPostSerializer<\/pre>\n
<\/a><\/p>\nConfiguring URLs<\/h4>\n
# basic_api\/urls.py\r\nfrom django.urls import path\r\nfrom rest_framework.urlpatterns import format_suffix_patterns\r\nfrom basic_api import views\r\n\r\nurlpatterns = [\r\n path('basic\/', views.API_objects.as_view()),\r\n path('basic\/<int:pk>\/', views.API_objects_details.as_view()),\r\n]\r\n\r\nurlpatterns = format_suffix_patterns(urlpatterns)\r\n\r\n<\/pre>\n<\/a><\/p>\nfrom django.contrib import admin\r\nfrom django.urls import path, include\r\n\r\nurlpatterns = [\r\n path('admin\/', admin.site.urls),\r\n path('', include('basic_api.urls'))\r\n]\r\n<\/pre>\n<\/a><\/p>\n<\/a><\/p>\nJSON<\/h3>\n
<\/a><\/p>\n