Django Interview Questions

Django is a free, open-source web framework written in Python programming language. If you are seeking for making a career in Django, you may encounter plenty of Django interview questions and answers during the interview. Preparing for Django interview can be difficult. It can, however, be made easier with these expert-authored Django interview questions and answers.

  • 4.8 Rating
  • 39 Question(s)
  • 30 Mins of Read
  • 20645 Reader(s)

Advanced

In Django, a model is a special kind of object and it is saved in the database. In the model, you will store information about users, your books, etc. In terms of the database, you can think of a spreadsheet with columns (fields), and rows (data), as a model.

We are assuming here that the project is created and database connection is set up, and you are in a project folder( or directory where manage.py file is).

To create an application 'dailyblog' execute the command -

$ python manage.py startapp dailyblog

The new dailyblog directory will be created with the number of files.

Register your dailyblog with the Django project. Open settings.py in the code editor and Update INSTALLED_APPS tuple by adding a line containing 'dailyblog'.

//settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'dailyblog',
]

In the dailyblog/models.py file, we will define models, that is an object. Here we will define our blog post.

Now open dailyblog/models.py in the code editor, remove all from it and write below code -

//models.py
from django.conf import settings
from django.db import models
from django.utils import timezone
class Post(models.Model):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    title = models.CharField(max_length=200)
    text = models.TextField()
    created_date = models.DateTimeField(default=timezone.now)
    published_date = models.DateTimeField(blank=True, null=True)

    def publish(self):
        self.published_date = timezone.now()
        self.save()

    def __str__(self):
        return self.title

Let us see what the above model code means -

Lines starting with 'from' or 'import' add some bits from other files.

class Post(models.Model) - This line defines the object, that is our model.

  • Class - is a keyword, used to indicate that we are defining an object.
  • Post - is the model name. It can be anything but should start with upper case and we should avoid special characters and whitespace. 
  • models.Model - Django understands this model should be saved in the database.
  • models.ForeignKey - link to another model.
  • models.CharField - defines text with a character field.
  • models.TextField - defines text without limit.
  • models.DateTimeField - date and time field.
  • def publish(self) - def is a function/method and publish is the name of the method. 
  • __str__() - when called __str__(), we will get text string with Post title.

In Django, migration is a way of applying changes made in models that are adding the field, deleting model, etc. into a database. To manage database schema changes migrations are a great way. You will find Django has created migration files inside the migration folder for each model. Each table is mapped to the model. Most migrations are designed to be automatic, but you need to know when to migrate, and when to run migrations.

Django has various commands to interact with migrations and Django's handling of a database schema. These commands perform migration-related tasks. After creating models you can use these commands.

makemigration - This command is used to create a migration file.
migrate - This command creates a table according to the schema defined in migration file
sqlmigrate - This command is used to show a raw SQL query of the applied migration.
showmigrations - This command list all the migrations and their status.

To manage database schema changes migrations are a great way. You will find Django has created migration files inside the migration folder for each model. Each table is mapped to the model.

Django has various commands to perform migration-related tasks. After creating models you can use these commands.

makemigration - This command is used to create a migration file that contains code for the tabled schema of a model.
migrate - This command creates a table according to the schema defined in migration file
sqlmigrate - This command is used to show a raw SQL query of the applied migration.
showmigrations - This command list all the migrations and their status.

We have a model with attributes as given below  -

//models.py
from django.conf import settings
from django.db import models
from django.utils import timezone
class Post(models.Model):
    author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    title = models.CharField(max_length=200)
    text = models.TextField()
    created_date = models.DateTimeField(default=timezone.now)
    published_date = models.DateTimeField(blank=True, null=True)
    class Meta:  
        db_table = "blog"  

Let us create a migration for this model, use the below command and it will create a migration file inside the migration folder.

$ python3 manage.py makemigrations

After creating a migration, to reflect changes in the database permanently execute migrate command -

$ python3 manage.py migrate

To see raw SQL query executing behind applied migration execute the command -

$ sqlmigrate app-name migration-name (for example sqlmigrate blog 001)

To see app-specific migrations by specifying app-name, execute the command -

$ python3 manage.py showmigrations blog

To see all migrations, execute the command -

$ python3 manage.py showmigrations

A piece of information stored in the client browser is called cookies and itis used to store user's data in a file. Cookies can be stored permanently or for the specified time.

Cookies are removed automatically when expired. Django has built-in methods to set and fetch cookies.

The set_cookies() method can be used to set cookies. The getcookies() method can be used to get the cookies. The request.COOKIES['key'] array is used to get cookies value.

Let us see the example of Django Cookie -

Two functions setcookies() and getcookie() are used to set and get the cookie in views.py.

// views.py

    from django.shortcuts import render  
    from django.http import HttpResponse  
    def setcookie(request):  
        response = HttpResponse("Cookie Set")  
        response.set_cookie('selenium-tutorial', 'nikasio.com')  
        return response  
    def getcookie(request):  
        tutorial  = request.COOKIES['selenium-tutorial']  
        return HttpResponse("selenium tutorials @: "+  tutorial);

Update URLs specified to access these functions -

//urls.py

    from django.contrib import admin  
    from django.urls import path  
    from myapp import views  
    urlpatterns = [  
        path('admin/', admin.site.urls),  
        path('index/', views.index),  
        path('scookie',views.setcookie),  
        path('gcookie',views.getcookie)  
    ]  

Execute below command to start server -

$ python3 manage.py runserver 

Once the server is up, set cookies by using localhost:80000/scookie url and get cookies by using localhost:8000/gcookie URL.

Django is known for MVC(model, view, controller) web framework, but it can be used to build a backend that is an API.

Let us see step by step process for creating API

1. Installation

Install Django and Django REST Framework by creating a virtual environment.

sudo pip install virtualenv
virtualenv venv
source venv/bin/activate

$ pip install Django==1.9
$ pip install djangorestframework==3.6.3

Now create project tutorial and inside project create an app quickstart.

$ django-admin.py startproject tutorial
$ cd samplelibrary
$ django-admin.py startapp quickstart

Now let us create and apply schema migration by executing following -

$ python manage.py makemigrations
$ python manage.py migrate

Now create a user with user name 'admin' and  password  'password123'

python manage.py createsuperuser --email admin@example.com --username admin

2. Create Serializer

Serializers are used to convert data from one format to another. For example to convert formats like JSON, XML to complex data types like querysets and model instances and vice versa.

Now create a new module named tutorial/quickstart/serialisers.py for data presentations.

//serialisers.py
from django.contrib.auth.models import User, Group
from rest_framework import serializers

class UserSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = User
        fields = ('url', 'username', 'email', 'groups')

class GroupSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Group
        fields = ('url', 'name')

Here we are using hyperlinked relations with HyperlinkedModelSerializer as hyperlinking is good RESTful design.

3. Views

Viewsets are classes that provide the functionality of a set of views. Now create a UserViewSet class based on ModelViewSet in a views.py file of quickstart app.

//views.py
from django.contrib.auth.models import User, Group
from rest_framework import viewsets
from tutorial.quickstart.serializers import UserSerializer, GroupSerializer

class UserViewSet(viewsets.ModelViewSet):
    """
    API endpoint that allows users to be viewed or edited.
    """
    queryset = User.objects.all().order_by('-date_joined')
    serializer_class = UserSerializer

class GroupViewSet(viewsets.ModelViewSet):
    """
    API endpoint that allows groups to be viewed or edited.
    """
    queryset = Group.objects.all()
    serializer_class = GroupSerializer

Rather than writing multiple views, here we are grouping together all the common behavior into classes called ViewSets.

4. URLs

Let us write up the API URLs.

//urls.py
from django.urls import include path
from rest_framework import routers
from tutorial.quickstart import views

router = routers.DefaultRouter()
router.register(r'users', views.UserViewSet)
router.register(r'groups', views.GroupViewSet)

# Wire up our API using automatic URL routing.
# for browsable API,  we include login URLs.
urlpatterns = [
    path('', include(router.urls)),
    path('api-auth/', include('rest_framework.urls', namespace='rest_framework'))
]

Here we are using viewsets instead of views so that we can automatically generate the URL conf for our API by registering viewset with a router class.

Also, we are including a default login and logout view for use with browsable API.

5. Pagination 

Pagination controls how many objects per page to return. Add below lines to settings.py

//settings.py
REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
    'PAGE_SIZE': 10
}

Settings
Now add 'rest_framework' to INSTALLED_APPS in settings module.

//settings.py
INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    #app
    'quickstart',

    #rest_framework
    'rest_framework',
)

Let us test the API we have built. start server from the command line.
$ python manage.py runserver
Now we can access our API from the command-line tool

curlbash: curl -H 'Accept: application/json; indent=4' -u admin:password123 http://127.0.0.1:8000/users/
{
    "count": 2,
    "next": null,
    "previous": null,
    "results": [
        {
            "email": "admin@example.com",
            "groups": [],
            "url": "http://127.0.0.1:8000/users/1/",
            "username": "admin"
        },
        {
            "email": "tim@example.com",
            "groups": [                ],
            "url": "http://127.0.0.1:8000/users/2/",
            "username": "tim"
        }
    ]
}

“Django REST framework is a powerful and flexible toolkit used for building Web APIs”. Django REST Framework application easily a REST API into existing Django functionality and allows you to list all your API endpoints that inherit from Django REST Framework automatically. Django REST Framework is very easy to build model-backed APIs that have authentication policies and are browsable.

The purpose of the Django REST Framework is to work out of the box and it should take the minimum to install it. The REST framework is a funded project. 

Some of the reasons why you should use the REST framework are :

  • For developers, the Web browsable API is huge usability.
  • Authentication policies including packages for OAuth1a and OAuth2.
  • Serialization for both ORM and non-ORM data sources.
  • Customizable - just use regular function-based views.
  • Extensive documentation, along with great community support.
  • Used and trusted by internationally recognized companies.

Below is the REST framework requirement-

Python  - 3.5, 3.6, 3.7
Django  - 1.11, 2.0, 2.1, 2.2

By default there are four main authentication methods are available -

1. SessionAuthentication - This authentication scheme uses Django's default session backend for authentication and it is appropriate for AJAX clients that are running in the same session context as your website.

If authentication is successful, it provides the following credentials -

  • request.user - Django User instance.
  • request.auth - none

Unauthenticated responses will result in an HTTP 403 Forbidden response.

2. BasicAuthentication - Basic authentication scheme uses HTTP Basic Authentication that is signed against a user's username and password. BasicAuthentication is appropriate for testing.

If authentication is successful, it provides the following credentials -

  • request.user - Django User instance.
  • request.auth - None

Unauthenticated responses will result in an HTTP 401 Unauthorized response with an appropriate WWW-Authenticate header. 

3. TokenAuthentication - TokenAuthentication scheme uses a simple token-based HTTP authentication scheme and is suitable for client-server setups like native desktop or mobile client.

If authentication is successful, TokenAuthentication provides the following credentials.

  • request.user - a Django User instance.
  • request.auth - a rest_framework.authtoken.models.Token instance.

Unauthenticated responses will result in an HTTP 401 Unauthorized response with an appropriate WWW-Authenticate header.

4. RemoteUserAuthentication - RemoteUserAuthentication scheme allows you to delegate authentication to your web server which sets the REMOTE_USERenvironment variable.

If authentication is successful, RemoteUserAuthentication providese following credentials -

  • request.user - Django User instance.
  • request.auth - None

In web application storing and retrieving information in the database is a common task. To perform these requirements Django comes with database management features. These features allow two things, one is, design database schema and second is, manage the data in the database that is read, write, update, delete, query, etc.

Django DB toolset is referred to as an object-relational mapper that is ORM.
Using Python classes database tables are created.
It is logical that fields are class attributes since tables are created as classes.
Classes are created in the models.py file. While creating a Django app, by default models.py file is created.

In Django, database tables are called models and these models are created in the models.py file which is located in the Dango app directory. A model is a python class. While defining model you need to give a class name, subclass it from Django's included models. Model class.

from Django.db import models

class Glass(models.Model):

The model is valid only if it has one or more fields. Fields can be created by adding the attribute to the model class.

from django.db import models

class Bottle(models.Model):
    size = models.IntegerField()
    color = models.CharField(max_length=100)

Here field name is 'size' and 'color'. models.IntegerField() is the instance for field class, and you are telling the database what kind of data you want to save in the field.

In the Django template, we can use the request processor to get the URL.

If you want to request a variable in the template, make sure you add 'django.template.context_processors.request' in your 'context_processors' settings. Also, do not forget to add other context processors you used in your application.

Till Django 1.9 version, by default, it comes configured. Default Template configuration is -

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

Use below line of code to get current path :
  {{ request.path }}

Use below line of code to get current path with querystring:
  {{ request.get_full_path }}

Use below line of code get Domain, path and querystring:
  {{ request.build_absolute_uri }}

For example, suppose your URL is  http://127.0.0.1:8000/home/?q=test

request.path will give you output /home/

request.get_full_path will give you output /home/?q=test

request.build_absolute_uri will give you output http://127.0.0.1:8000/home/?q=test

A simple way to create a user sign up is by using the UserCreationForm.  Django provides a form 'UserCreationForm' inherited from ModelForm class to handle new user creation. The user creation form has three fields username, password1, and password2. Password2 is for password confirmation.

First, you have to import UserCreationForm to use it

from django.contrib.auth.forms import UserCreationForm

To handle the creation of users, Django does not provide any view, we have to create our own view.

So proceeding further to create user, here we are using project myproject and application myapp.

To create user fist update urlpattern at the beginning of the urlpatterns list.

Then create a new function in views.py to authenticate and save the user.

The last step is to create an HTML template for the form display(view).

The User created, using 'UserCreationForm will have is_superuser and is_staff flag set to false but is_active flag set to True.

UserCreationForm does not have an email field, so we can't email verification to the user to verify the account.

Session data is stored on the server. Django creates a random unique string called session-id or SID and Django associates that ID or SID with the data. As a value to the browser, the server sends a cookie named session-id containing SID as value. On-page request, the browser sends a request containing a cookie with SID to the server. To retrieve this session data and make it accessible in code, Django uses this SID. Django generated SID is 32 characters long random string. Django support for anonymous sessions. Django session framework allows to store and retrieve arbitrary data on per site visitor basis. 

Seesions are implemented via middleware. To enable session functionality, edit MIDDLEWARE_CLASSES setting and make sure 'django.contrib.sessions.middleware.SessionMiddleware' is added.

Set the SESSION_ENGINE setting to "django.contrib.sessions.backends.file" to use file-based sessions. Also, set the SESSION_FILE_PATH setting to configure where Django store session files.

No, Django is not a Content Management System (CMS), rather it is a Web application framework and a programming tool that helps you to build websites.

DjangoCMS is a web publishing platform built with Django and offers out of the box support for the common features you expect from a CMS. Django CMS can be easily customized and extended by developers to create a site precise to their needs.

Django CMS is a thoroughly tested platform that supports both large and small web sites. Django CMS is robust internationalization support for creating multilingual sites. It can be configured to handle different requirements. Content editing is possible and provides rapid access to the content management interface. Django CMS supports a variety of editors with advanced text editing features. It is a flexible plugins system. Thorough documentation is available for Django CMS. Each published CMS page exists at two instances public and drat. An only draft version exists till you publish it.

A Mixin is a special type of inheritance in Python. It is gaining a big rise in Django / Web Application Development. Mexin can be used to allow classes in Python to share methods between any class that inherits from that Mixin.

A mixin or mix-in is a class that contains methods for use by other classes without having to be the parent class of those other classes.  Sometimes Mixins are described as "included" rather than "inherited".

Django provides a number of mixins that provide more discrete functionality.  Different type of mixins are -

Simple mixins are -

ContextMixin - A dictionary to include in the context and is a convenient way of specifying the simple context in as_view().

TemplateResponseMixin - Given a suitable context, TemplateResponseMixin provides a mechanism to construct a TemplateRespons and the template to use is configurable and can be further customized by a subclass.

SingleObjectMixin - SingleObjetMixin provides a mechanism for looking up an object associated with the current HTTP request.

SingleObjectTemplateMixin - SingleObjetTemplateMixin performs template base response rendering for view that operate upon a single object instance. 

MutlipleObjectMixin - MultipleObjectMixin used to display list of objects

In Django, migrations are a way of propagating changes made in the model into the database schema. Django migrations can be created manually by running certain commands, but migrations automate the task of applying changes to the database. Django Migrations can be used as a version control system for database and Model. Migration keeps track of changes done in application Models/Table like adding a field, deleting a model, etc. Automatically generated migrations are used to apply changes to the database schema and to apply changes in data, you need to manually write the data migrations. Migrations in Django are stored as an on-disk format, referred to as “migration files”. These files are just like normal Python files with an agreed-upon object layout, written in a declarative style. Below is the format of a basic migration file:

from django.db import migrations, models

class Migration(migrations.Migration):

    dependencies = [('migrations', '0001_initial')]

    operations = [
        migrations.DeleteModel('Tribble'),
        migrations.AddField('Author', 'rating', models.IntegerField(default=0)),
    ]

To leverage MongoDB from Django, the following software should be installed and running -

Python
MongoDB
Django-norel - a version of Django designed for use with non-relational database engines
Django toolbox - Django-MongoDB engine depends on this general-purpose utility library
MongoDB-engine - MongoDB driver for Django

1. Create a project named 'testproj' with an application named 'testapp'.
   django-admin.py startproject testproj
   CD testproj/
   django-admin.py startapp testapp

2. Setup - Configure following in settings.py

DATABASES = {  
        'default': {  
            'ENGINE': 'django_mongodb_engine',  
            'NAME': 'testdatabase',  
            'USER': '',  
            'PASSWORD': '',  
            'HOST': 'localhost',  
            'PORT': '27017',  
            'SUPPORTS_TRANSACTIONS': False,  
        },  
    }  

3. Update models.py

   from django.db import models  
    class Article(models.Model):  
    title = models.CharField(max_length = 64)  
    content = models.TextField()

4. Save - Save model data from a Django view.

from django.http import HttpResponse  
from models import *  

  def testview(request):  
  article = Article(title = 'test title',  
  content = 'test content'
  article.save()  

  return HttpResponse("<h1>Saved!</h1>")

5. Execute javascript query like from Django view to check connection-
    db.testapp_article.find()

6. Query MongoDB from Django to retrieve a list
    articles = Article.objects.all()

Intermediate

MVT that is Model, View, Template, and MVC that is Model View, Controller, are design patterns. Programmers may use, extend or not use these ready to use design patterns.

MVC design pattern was built specifically to separate out business logic and data. MVC allows representing the same data in multiple ways. In MVC pattern Model is the “data” part, View is the “presentation” part and the Controller is the “coordination” part.

MVT is Model View Template. Here View acts as “Controller” and has no one to one mapping in case of Django. The major difference between the two patterns is that Django takes care of the Controller part. The Django template is an HTML file mixed with Django Template Language. The developer develops the Model, the view and the template then maps it to a URL and then Django does the magic to serve it to the user.

Below are the supported and tested versions of Django-MySQL’s requirements:

 Python: 3.5, 3.6, 3.7
 Django: 1.11, 2.0, 2.1, 2.2
 MySQL: 5.6, 5.7 / MariaDB: 10.0, 10.1, 10.2, 10.3
 mysqlclient: 1.3

Before setting connection below prerequisite is taken into consideration-

1. MySQL is installed
2. MySQL-python package is installed (python interface to MySQL)
3. Django configured

Now let us see the steps to connect to MySQL -

1. Open settings.py from the directory of the Django project.

2. Update the default key in the DATABASE dictionary. Set ENGINE, NAME, USER and PASSWORD you choose when installing MySQL. 

   # Database

        # https://docs.djangoproject.com/en/2.0/ref/settings/#databases

DATABASES = {
'default': {  
            'ENGINE': 'django.db.backends.mysql',  
        'NAME': 'djangoApp',  
'USER':'root',  
       'PASSWORD':'mysql',  
        'HOST':'localhost',  
      'PORT':'3306'
                },
            }

3. Open a command window and activate a virtual environment and change it to Django project directory.
4. Type python maanage.py syncdb and create the underlying tables required for the Django project.

If there is no error your connection between Python, Django, and MySQL is successful.

Static files may include CSS, JavaScript, and images. Django refers to these images, JavaScript, or CSS files as static files. Django provides django.contrib.staticfiles to manage static files.

You may want to serve these static files alongside your site. 

  • Ensure that django.contrib.staticfiles is included in installed apps.
  • Ensure that in your settings file, define the STATIC_URL to the folder path where static files will be placed and make sure the folder exists.

STATIC_url = '/static/'

  • Use the static template tag to build the URL in your template, for the given relative path using the configured STATICFILES_STORAGE.

{% load static %}
<img src = "{% static "my_app/example.jpg" %}" alt ="My image"/>

  • Store static files in a folder say static in your app. You can define a list of directories (STATICFILE_DIRS) in your settings file where Django will also look for static.

Django supports anonymous sessions. The Session framework allows you to store and retrieve arbitrary data on per site visitor basis. Django stores data on server-side and retrieves it by sending and receiving cookies. These cookies contain session IDs.

Enabling sessions -

Using a piece of middleware, sessions are implemented.

To enable session -

Open and update the MIDDLEWARE setting as below -
'django.contrib.sessions.middleware.SessionMiddleware'

Default settings.py has SessionMiddleware activated.

You can remove SessionMiddleware line from MIDDLEWARE_CLASSES and 'django.contrib.sessions' from your INSTALLED_APPS if you don't want to use sessions.

Configuring session engine

Django store sessions in the database by default. Django can be configured to store session data in two ways.

1. Using database-backed sessions - You need to add 'django.contrib.sessions' to INSTALLED_APPS settings if you want to use database-backed sessions.
    Run manage.py syncdb to install a single database table to store session data.

2. Using cached sessions - For better performance, cache-based session backend can be used. To store session data you need to configure the cache. You can store data in two ways -

  • Set SESSION_ENGINE to "django.contrib.sessions.backends.cache" for simple caching. Data will be stored directly cache. Session data may not be persistent. If the cache fills up or cache server restarted, cache data can be evicted.
  • Set SESSION_ENGINE to "django.contrib.sessions.backends.cached_db". Every write to the cache will be written to database.

Django middleware is a framework of hooks to modify request and response objects. 

If you want to modify the HttpRequest object which is sent to the view, or you want to modify the HttpResponse object returned from the view, you can use middleware.

Django provides some default middleware like AuthenticationMiddleware.

Middleware is used in a number of key pieces of functionality in the Django project and you can use CSRF middlewares to prevent cross-site request forgery attacks or to handle session data. With the use of middleware Authentication and authorization can be accomplished. To shape the flow of data through the application, you can write your own middleware classes.

One of the following methods must have in Django middleware.
process_request, process_response, process_view and process_exception.

These methods will be collected by WSGI Handler and called in the listed order.

Before any view executes, Django wants user attribute to be sent on request and to accomplish this Django takes a middleware approach. So AuthenticationMiddleware can modify the request object like -

https://github.com/django/django/blob/master/django/contrib/auth/middleware.py#L22

The same way to show the user's timezone on the page of the user, you can access the user's timezone in all views. You can use TimezoneMiddleware.

class TimezoneMiddleware(object):
   def process_request(self, request):
         # Assuming user has a OneToOneField to a model called Profile
         # And Profile stores the timezone of the User.
         request.session['timezone'] = request.user.profile.timezone

TimezoneMiddleware is dependent on request.user and request.user is populated in AuthenticationMiddleware. So timezone middleware written must come after AuthenticationMiddleware in the tuple settings.MIDDLEWARE_CLASSES.

The Django Signals is a tactic to notify decoupled applications when certain events occur. The Django Signal is used when many pieces of code may be interested in the same events or when you need to interact with decoupled applications like A Django core model or A model defined by a third-party app.

Two key elements the Senders and the receivers are in the signals machinery. The sender is responsible to dispatch a signal, and the receiver is the one who receives this signal and then performs something.

A receiver can be a function or an instance method to receive signals.

A sender can be a Python object or None to receive events from any sender.

Via the connect method, the connection between the receivers and senders is done through 'Signal Dispatchers', which are instances of Signal.

The Django core defines a ModelSignal, a subclass of Signal that allows the sender to lazily specify as a string of the app_label.ModelName form.

You need to register a receiver function that gets called when the signal is sent by using the Signal.connect() method to receive a signal.

Let us see a post_save built-in signal. The code for post_save is stored in the django.db.models.signals module. This signal is fired right after a model finishes executing its save method.

//models.py
from django.contrib.auth.models import User
from django.db.models.signals import post_save
def save_profile(sender, instance, **kwargs):
   instance.profile.save()
post_save.connect(save_profile, sender=User)

Here save_profile is a receiver, User is the sender and post_save is the signal. Wherever a User instance finalizes the execution of the save method, save_profile function will be executed.

Django template engine is part of the Django framework and it is easy, extendible and handy in developing complex web applications. 

A template is a text document or Python string marked-up using the Django template language. It can generate any text-based format like HTML, XML, CSV, ETC. 

Being a web framework, Django requires a convenient way to generate HTML dynamically. A template is the most common approach to rely on. The template contains static parts of desired HTML output and some special syntax describing how dynamic content can be inserted. 

A Django project can be configured with or without a template. You can configure one or more template engines. Django provides a standard API for loading or rendering templates irrespective of the backend.  Loading template consists of searching the template for a given identifier and processing it and mostly compiling it into in-memory representation. Rendering means interpolating the template with context data and return the resulting string. django.template.Context is a context class and its constructor takes two arguments, one is a dictionary mapping variable name to variable values and second is the name of the current application.

The template contains variables and template is evaluated these variables get replaced with values.

Django has only one user type that is User. Users are differentiated on the basis of permissions you give. Any normal user can be authenticated and any user assigned the staff flat can log in to the contributed admin app. Users can be set active or de-active and only active users are allowed to log in. A superuser is just a convenient method to create a user with all permissions. 

In Django, you easily create a superuser account to access the admin site. 

We are assuming here that the project is created and database connection is set up, and you are in a project folder.

Now create an application by executing the command -

$ python manage.py startapp newapp

Register your newapp with the Django project say 'newproject'. Open settings.py in the code editor and update INSTALLED_APPS tuple and middleware tuple. 

//settings.py
INSTALLED_APPS = (
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'newapp',
)

MIDDLEWARE_CLASSES = (
   'django.contrib.sessions.middleware.SessionMiddleware',
   'django.middleware.common.CommonMiddleware',
   'django.middleware.csrf.CsrfViewMiddleware',
   'django.contrib.auth.middleware.AuthenticationMiddleware',
   'django.contrib.messages.middleware.MessageMiddleware',
   'django.middleware.clickjacking.XFrameOptionsMiddleware',
)

Now to access Admin Interface, initiate database by executing commands -

$ python manage.py makemigrations

$ python manage.py migrate

Now create superuser by executing the command -

$ python manage.py createsuperuser

Wait for the success message and then enter the remaining user information.

We are assuming here that the project is created and database connection is set up, and you are in a project folder.

Your Djong application can be anywhere on your Python path. Here, we’ll create our app right next to your manage.py file so that it can be imported as its own top-level module, rather than a submodule of mysite.

To create an application, make sure you’re in the same directory here manage.py and type this command:

$ python manage.py startapp newapp

It will create a directory newapp, which would look like −

newapp/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    views.py

Application newapp will house in this directory structure.

Now to write view open newapp/views.py file and update with below lines -

from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world")

To call this view, you need to map it to a URL. 

Create URLconf in the newapp directory, create a file called urls.py. Your directory should look like -

newapp/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
    urls.py
    views.py

Update urls.py file with the following code -

//urls.py
from django.urls import path
from.import views

urlpatterns = [
    path('', views.index, name='index'),]

Now point the root_URLconf at the newapps.urls module. In newsite/urls.py, import Django.urls.include and insert an include() in the urlpatterns list.

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('newapps/', include('newapps.urls')),
    path('admin/', admin.site.urls),]

ORM that is Object-Relational Mapping is a programming technique to convert data between the relational database and object-oriented programming languages such as Java, C#, etc. ORM maps database entities to Python code usually classes. You can construct your query in Python and it gets translated to SQL behind the scene.

For example instead of this SQL query - 

SELECT * FROM <TABLE NAME>

you can use -

users = User.objects.all()

In SQL you have to execute that query using a driver, parse the result and then access the columns, but here ORM is doing that for you. That makes things easier and faster to use.

The most powerful feature of Django is its object-Relational Mapper that enables you to interact with the database.  

Let us see the advantages of ORM -

  1. You can write in the language you are familiar with. 
  2. It abstracts away the database system so that switching the backend database easy without any worry.
  3. You get a lot of advanced features such as support for transactions, connection pooling, migrations, seeds, etc. depending on the ORM
  4. Cache management, Entities are cached in memory thus reducing the load on the database.
  5. Key management, Identifiers and surrogate keys automatically propagate and manage.
  6. Multiple users can update the same data simultaneously.
  7. Data loads are configurable and allow you to load appropriate data for each scenario.
  8. You can navigate object relationships transparently, related objects automatically load when required.
  9. ORM tools provide an object-oriented query language that allows developers to focus on the object model without worrying about database structure or SQL semantics.

Beginner

Django follows MVC pattern (Model-View-Controller), also referred to as MTV (Model-Template-View). 

Model – describes database schema 

Views – Controls what user can view. It retrieves data from the table and passes it to the template which is rendered to Browser eventually.

Template – Determines how the user sees it. 

Controller – controls the entire flow of models and data.

  1.  Admin Interface
  2.  Forms
  3.  Templating
  4.  The session, user management
  5.  Object-relational Mapping (ORM)

When a user requests a page, Django determines whether the request URL pattern is mentioned in URLs.py. Once the regex matches, Django calls the corresponding view. HttpRequest is passed as an argument to that view function and the implementation part is executed further.

CSRF – Cross Site Request Forgery. Csrf tokens could also be sent to a client by an attacker due to session fixation or other vulnerabilities or guessed via a brute-force attack, rendered on a malicious page that generates thousands of failed requests.

Django is a high-level Python-based, open-source web framework written in Python to develop a web application to encourage rapid development and clean, pragmatic design. Django follows the model-view-template architectural pattern and developed by a fast-moving online-new operation. Django is designed to handle intensive deadlines of a newsroom and the stringent requirements of the experienced web developers who developed it. It allows you to build a high performing web application quickly. 

Django, a web application framework is a collection of modules that are grouped together to enable you to create an application or a website from an existing source. This collection of modules makes the development of web application or a website fast and easier. 

A single person can design and still can include advanced functionality like authentication support, admin panel, management panel, contact forms, comment boxes, file upload, and many more. To create a website from scratch you would have to develop these components by yourself. These components are already built and you just need to configure them as per your requirement to build your site. You can focus on developing your app as Django offers a big collection of modules that can be easily used in projects and takes care of most of the hassle of web development.

Django is named after one of the best guitarists of all time Django Reinhardt, a gypsy jazz guitarist from the 1930s to early 1950s.

2.2.1 is the latest and stable version now.

We know that all web application uses HTTP/HTTPS protocol. The basic principle of the HTTP protocol is Client sends a request to the server and the data server sends a response back to the client based on request data. We need a web server and WSGIserver while setting up a Django application on the server. Without a web server, WSGI server will result in a more number of requests resulting in gradually slow down the application performance. The web server will help in balancing the requests load on the server. 

The client is a piece of software which sends a request by following HTTP/HTTPS protocol and mostly we consider Web Browser as a client. "Nginx, uWSGI and Django" or "Nginx, gunicorn and Django" or "Apache, mod_wsgi and Nginx" are the three types of combinations in Django application deployment on the server and we can use any one of the combinations. Now let us discuss on how a request is processed and response is created and sent to the client.

When a client sends request it first passed to a web server. The request contains configuration rules to be dispatch to the WSGI server. WSGI server sends the request to the Django application.

For dealing with request-response lifecycle, Django application has the following layers -

  • Request middlewares
  • URL Router
  • Views
  • Context processors
  • Template Renderers
  • Response middleware

Any request that comes in is handled by Request middleware. There can be multiple middlewares and can find it in settings.py (project settings). While processing the request Django Request middlewares follow the order. Django has some default middlewares and we can also write or customize middleware. Middleware process the request and submits it to the URL Router or URL dispatcher.

URL Router receives a request from the middleware and from the request it collects the URL path. From the URL path, the URL router tries to match the request path with available URL patterns. These patterns are in the regular expression form. Once the URL path is matched with URL patterns the request is submitted to the View associated with URL.

Views are the business logic layer, which processes the business logic using request and request data. A request is processed in the view, it is sent to Context processor. Context processor adds context data that helps Template Renders to deliver the template to generate HTTP response and again this request will be sent back to Response middleware to process. Request middleware adds or modifies header information or body information before sending it to the client again.

Django is a free and open-source framework to develop web applications. Web development process becomes very easy and developer can focus only on designing process and boosts performance. Django follows the model-view-template architectural pattern.  Django, a web application framework is a collection of modules that are grouped together to enable you to create an application or a website from an existing source. This collection of modules makes the development of web application or a website faster and easier.

Django is a quick solution for web development. It has become the right platform for a customer for business and developers due to its ability to deliver high-quality code and transparent writing.

Batteries Included - Django comes with a collection of modules also know as Batteries. A lot of out of the box stuff, you may or may not use for your application comes with Django. Instead of writing your own code, just import the package you wish to use.

Wide range of topics are spanned in Django batteries which includes -

  • auth package for authentication
  • admin package for Admin interface
  • Sessions package for Session management
  • Messages package to manage temporary or session-based messages
  • Sitemaps package to generate Google sitemap XML
  • Postgress Package for Postgress special features
  • Content types framework to hook into "types" of content

Django is an amazing framework, still, there are a few cons. The URL specifying with regular expressions is not an easy task.  Template errors fail silently by default, to know that, you may waste a lot of time to figure out what’s wrong, or you might not even know that your application has a problem. Along with the advantages, there are many disadvantages to Django mentioned below.

Template Mistakes Flop Discreetly itself - System developers do not pay attention to mistakes when they undertake a class-based viewpoint and they are extended through inheritance.

Does Not Have The Capacity To Manage Different Requests At The Same Time:

Django does not support individual procedures to deal with many requests at the same time. Developers need to investigate approaches and make singular procedures to control various requests proficiently and rapidly at once.

Django is Excessively Monolithic: Django framework directs you into a given specific pattern.

Regex To Indicate Its URL: Django uses regex to determine its URL routing models, which makes the code bigger and makes convoluted syntaxes. 

While Managing Backwards Compatibility, It’s Moving Extremely Gradually: Django has a tendency to get greater and heavier after some time. Django stresses more on dev profitability and backward compatibility than the speed.

Django uses routing patterns to specify its URL.

Everything is based on Django ORM and the ORM system lacks features.

Components are tightly coupled and get deployed together

To work with Django, knowledge of the full system is required.

There are many pros and cons of Django, still, when a project with a deadline is considered, using Django for the project provides the ultimate solution.

Django architecture is based on the MVC pattern. MVC architecture solved lots of problem in the traditional approach of web development. Components of MVC pattern are Model, Views, and Control and is a product development architecture to solve the drawback of code of traditional approach.

Architecture of Django?

1. Model: Model as a part of the web application, acts as a mediator between website interface and database, in short, it is the object that implements the logic for the application's data domain.  Many times application only takes data in particular dataset, and directly sends data to the view without any database, that dataset is called a model.

In Django architecture, the component model contains business logic. Let us see the example of website sign up, when you sign up, you are sending information to the controller which transfers it to models which apply business logic on it and stores in the database.

2. View: View component of Django architecture contains UI logic. It is a User Interface of the web application and contains HTML, CSS, and other front-end technologies. Contents for the UI comes from the Models component. When interacting with the specific component, a new Web page that is generated say due to click on any link of the website is the specific views that are stored and generated.

3. Controller: Controller component of the Django architecture is the main control component, that handles user interaction and selects view according to the model. The major task of the controller is according to the user interaction select a view component and applying to the model component.

MTV pattern - Django is an MTV (model-Template-View)framework and used template terminology for view and Views for Controller.

In the MVC pattern, a template is related to View and is a presentation layer that manages presentation logic and controls how to display and what content to display for the user.

The Django follows "Batteries included" philosophy which provides almost everything developers want to try "out of the box". Everything you need to develop an application is part of the one product, and it works seamlessly together, and also follows consistent design principles.

Django’s working philosophy breaks into many components - 

Models.py file: Using Python object Django web applications manage and query data and is referred to as models. It defines the structure of stored data along with field types, default values, selection list options, maximum size, label text for forms, etc. Once you select what database you want to use, you just need to write model structure and other code, Django handles all the work of communicating with the database.

Views.py file: Views are the main part of Django and the actual processing happens in view. For searching database, Django model provides simple query API. It can match the number of fields at a time using different criteria and can support complex statements.

Urls.py file: It uses a regular expression to capture URL patterns for processing. Django allows you to design URLs the way you want, with no framework limitation.

When a user sends a request on Django page:
Django runs through each URL pattern in order and stops at first one pattern that matches with, URL you have created and uses the information to retrieve the view.
The view processes the request and queries database if required.
Requested information to your template.
The template renders the data in a format you have created and displays the page.

  • Django is written in Python programming language and hence it becomes easier for programmers to build web applications with clean, readable and maintainable code.
  • Being a matured framework, its design rules focus on reducing web application development time. According to varying business requirements, the features provided by Django enable developers to build custom web applications rapidly.
  • Django adopted the batteries-included approach. 
  • Django is compatible with major operating systems and databases. By supporting major operating systems like Windows, macOS, Linux, Django enhance the accessibility of web applications.
  • Built-in security features provided in Django helps developers to protect the web applications from a variety of security attacks like cross-site scripting, SQL injection and cross-site request forgery. 
  • Django enables programmers to build better and modern web applications. Django developers can easily customize, scale and extend the web framework by making changes to decoupled components.
  • Django provides an Auto-generated web admin to make website administration easy.
  • For common user tasks,  pre-packaged API is also available.
  • Using this framework, business logic can be separated from the HTML.
  • Can divide the code modules into logical groups, to make it flexible for changing.
  • Template system provided to define the HTML template for the web page to avoid code duplication.
  • Django is supported by large and active community developers. The Django developers can easily speed up custom web application development by taking advantage of resources uploaded by members of the Django community.

The most common task in web application development is to write create, read, update and delete functionality (CRUD) for each table. It refers to the set of common operations that are used in web applications to interact with data from the database. It provides a CRUD interface that allows users to create, read, update or delete data in the application database.

Django helps us with its simplified implementation for CRUD operations using Function-Based views and class-based Views.

Function-based views are simple to implement and easy to read but they are hard to customize or extend the functionality. Code reuse is not allowed and so there is repetitiveness.

Class-based views - In no time CRUD operations can be implemented using CBVs. As the model evolves changes would be reflected automatically in CBVs. CBVs are easily extendable and allow code reuse. Django has built-in generic CBVs which makes it easy to use.

Django is set up to communicate with SQlite a lightweight relational database. By default Django automatically creates an SQLite database. Django also supports PostgreSQL, MySQL, and Oracle. 

Along with configuring Django to connect to a database you need to install the required Python packages to communicate with the database.

To connect to the database, Django configuration is done inside settings.py file of Django project in the DATABASES variable.

We will go step by step as follow to set up MySQL - 

1) First Install MySQL Database Connector :
    sudo apt-get install libmysqlclient-dev

2) Then Install the mysqlclient library using the following command :
     pip install mysqlclient

3) Now Install MySQL server :
    sudo apt-get install mysql-server

4) Create the Database :

i) First, verify that the MySQL service is running:

systemctl status mysql.service

ii) Log in with MySQL credentials using the following command where -u flag for declaring your username and -p flag that tells MySQL that this user requires a password :  

mysql -u db_user -p

iii)  Create a database

CREATE DATABASE db_name;

iv) Exit MySQL server, press 

CTRL + D

5) Now add the MySQL Database Connection to Application:

    i) Now edit the config file so that it has MySQL credentials. We will use vi to edit the file and add the following information:

       sudo vi /etc/mysql/my.cnf

      database = db_name

        user = db_user

        password = db_password

        default-character-set = utf8

ii) Go to the settings.py file. Replace the current DATABASES lines with the following:

      # Database
        # https://docs.djangoproject.com/en/2.0/ref/settings/#databases
        DATABASES = {
            'default': {
                'ENGINE': 'django.db.backends.mysql',
                'OPTIONS': {
                    'read_default_file': '/etc/mysql/my.cnf',
                },
             }

i) Go to the settings.py file. Replace the current DATABASES lines with the following:

  # Database
        # https://docs.djangoproject.com/en/2.0/ref/settings/#databases

        DATABASES = {
'default': {  
            'ENGINE': 'django.db.backends.mysql',  
        'NAME': 'djangoApp',  
'USER':'root',  
       'PASSWORD':'mysql',  
        'HOST':'localhost',  
      'PORT':'3306'
                },
            }

6) After file edit, need to restart MySQL for the changes to take effect :

    systemctl daemon-reload
    systemctl restart MySQL

7) Now Test MySQL Connection to Application:
    python manage.py runserver your-server-ip:8000

Django tried to support as many features as possible on all database backends still, not all database backends are the same, and we have to decide on which features to support and which assumption we can make safely.

Django officially supports three other popular relational databases.

Below is the list of relational databases supported by Django -

1. PostgreSQL
2. MySQL and
3. Oracle 

Below is the list of databases to which Django supports connectivity -

4. SQLite - Django automatically creates an SQLite database for your project.
5. SAP (Sybase) SQL Anywhere
6. IBM DB2
7. Firebird
8. ADO- Microsoft SQL Server
9. ODBC - Microsoft SQL Server
10. Azure SQL database or other ODBC compatible database

Configuration to connect to the database is done in the settings.py file of the Django project.

ADO (ActiveX Data Objects) and ODBC (Open Database Connectivity) interfaces are standard for connecting to Microsoft SQL Server and is supported by most relational database brands.

Description

Django is a free, open-source web framework written in Python programming language. This framework is based on Model-View-Template (MVT) architectural pattern. Django is a high-level framework that motivates fast and clean development and pragmatic design. Django is popular due to the friendly features it offers to both the beginners and advanced developers. Django makes it easier to build web applications with less code complexity. The framework is robust and can be used for building any kind of websites in the world. 
 
Django is designed to handle the challenges like-

  • the intensive deadlines of a newsroom and
  • the stringent requirements of the experienced web developers

Today, Django is being used to develop the top website categories like Business & Industry, Arts & Entertainment, Shopping Internet & Telecom and so on.
 
If you are seeking for making a career in Django, you may encounter plenty of Django interview questions and answers during the interview. Preparing for Django interview can be difficult. It can, however, be made easier with these expert-authored Django interview questions and answers. 
 
These top interview questions and answers in Django can be beneficial for the freshers and experienced individuals alike. Also, Django interview questions will not only make your concepts clear but also help you in cracking the interview and land your dream job. 
 

Read More
Levels