Python Django Interview Questions & Answers 2026

Signals allow certain senders to notify a set of receivers that some action has taken place. They’re especially useful when many pieces of code may be interested in the same events.

The iterator is used when processing results that take up a large amount of available memory (lots of small objects or fewer large objects).

When the user makes a request of your application, a WSGI handler is instantiated, which: imports your settings.py file and Django’s exception classes. loads all the middleware classes it finds in the MIDDLEWARE_CLASSES or MIDDLEWARES(depending on Django version) tuple located in settings.py builds four lists of methods which handle processing of request, view, response, and exception. loops through the request methods, running them in order resolves the requested URL loops through each of the view processing methods calls the view function (usually rendering a template) processes any exception methods loops through each of the response methods, (from the inside out, reverse order from request middlewares) finally builds a return value and calls the callback function to the web server

Different types of caching strategies include Filesystem caching, in-memory caching, using memcached and database caching.

A mixin is a special kind of multiple inheritance. There are two main situations where mixins are used: to provide a lot of optional features for a class and to use one particular feature in a lot of different classes

Please refer to training materials for the detailed answer.

A token based authentication system is a security system that authenticates the users who attempt to log in to a server, a network, or some other secure system , using a security token provided by the server

Token based authentication and Session based authentication.

Authentication is the process or action of verifying the identity of a user or process.

We update data by sending PUT requests. Add a new path in the data model urlpatterns from which the update will be sent to. We then add an update method to the serializer that will do the update.

We use the Fetch API and SessionAuthentication by adding it to the settings.py file on the server and on the client, include the getCookie method. Finally, use the fetch method to call your endpoint.

Django Rest Framework (DRF) is a powerful module for building web APIs. It’s very easy to build model-backed APIs that have authentication policies and are browsable.

Create a project directory, create python virtual environment, and activate it, install Django and djangorestframework using the pip install command . In the same project directory, create project using the command django-admin.py startproject api. Start the app. Add the rest_framework and the Djano app to INSTALLED_APPS to settings. Open the api/urls.py and add urls for the Django app. We can then create models and make migrations, create serializers, and finally wiring up the views.

A REST API is an application program interface that uses HTTP requests to GET, PUT, POST and DELETE data.

To clear cache, run the clear() method from django.core.cache in a python script.

To do migrations , create or update a model and in the app directory, run the command ./manage.py makemigrations && ./manage.py migrate

Migrations are a way of propagating changes made in the model into the database schema (adding a field, deleting a model, etc.)

Add the model object in the models.py file, updated settings for the newly created app by adding it to the INSTALLED_APPS section in settings.py , make migrations, and verify the database schema.

ORM (Object-relational mapping) is a programming technique for converting data between incompatible type systems using object-oriented programming languages. Advantages include: Concurrency support Cache management

To create a simple application use the command django-admin startproject followed by the application’s name.

To create a super user,, Create project using the django-admin startproject command. Move into the project location and run python manage.py makemigrations && python manage.py migrate && python manage.py createsuperuser

Ans: Django templates contains the static parts of the desired HTML output as well as some special syntax describing how dynamic content will be inserted.

The receiver is the callback function which will be connected to a signal The sender specifies a particular sender to receive signals from

Ans: Middlewares are used go to modify the request i.e. HttpRequest object which is sent to the view, to modify the HttpResponse object returned from the view and to perform an operation before the view executes.

Ans: To check for the version of Django installed on your system, you can open the command prompt and enter the following command: python -m django –version You can also try to import Django and use the get_version() method as follows: 12 import django print (django.get_version())

Comparison Factor Django Flask Project Type Supports large projects Built for smaller projects Templates, Admin and ORM Built-in Requires installation Ease of Learning Requires more learning and practice Easy to learn Flexibility Allows complete web development without the need for third-party tools More flexible as the user can select any third-party tools according to their choice and requirements Visual Debugging Does not support Visual Debug Supports Visual Debug Type of framework Batteries included Simple, lightweight Bootstrapping-tool Built-it Not available

Ans. Cookie is nothing but a small piece of information which is stored in the client browser. Cookies are used to store user’s data in a file permanently (or for the specified time). There is an expiry date and time for each cookie and removes automatically when gets expire. There are built-in methods to set and fetch cookie provided by Django. set_cookie() method is used to set a cookie and get() method is used to get the cookie. request.COOKIES[‘key’] is an array which canbe used to get cookie values. from django.shortcuts import render from django.http import HttpResponse def setcookie(request): response = HttpResponse(“Cookie Set”) response.set_cookie(‘java-tutorial’, ‘javatpoint.com’) return response def getcookie(request): tutorial = request.COOKIES[‘java-tutorial’] return HttpResponse(“java tutorials @: “+ tutorial);

Ans. In Django session is a mechanism to store information on the server side during the interaction with the web application. Session stores in the database and also allows file-based and cache based sessions, by default,

In order to handle URL in Django, django.urls module is used by the Django framework. Given below is the urls.py file of the project, lets see how it looks: // urls.py from django.contrib import admin from django.urls import path urlpatterns = [ path(‘admin/’, admin.site.urls), ] We can see that, Django has already mentioned a URL here for the admin. Function path takes the first argument as a route of string or regex type. Argument view is a view function which is used to return a response (template) to the user. Module django.urls contains various functions, path(route,view,kwargs,name) is one of those which is used to map the URL and call the specified view.

Ans. Two important parameters in signals are: Receiver: It specifies the callback function which connected to the signal. Sender: It specifies a particular sender from where a signal is received.

Ans. Signals in Django are pieces of code which contain information about what is happening. A dispatcher is used to sending the signals and listen for those signals.

Ans. admin.py: This is Django’s command line utility for administrative tasks. Manage.py: This file is created automatically in each Django project. It is a thin wrapper around the Django-admin.py. It has the following usage: It puts your project’s package on sys.path. DJANGO_SETTING_MODULE is the environment variable used to points to your project’s setting.py file.

Ans. Django field class type specifies: The database column type. Default HTML widget used to avail while rendering a form field. The minimal validation requirements used in Django admin. Automatic generated forms.

Ans. Some usage of middlewares in Django is: Session management, Use authentication Cross-site request forgery protection Content Gzipping

Ans. Yes we can. We need to set three main things to set up static files in Django: 1) Set STATIC_ROOT in settings.py 2) run manage.py collect static 3) Static Files entry on the PythonAnywhere web tab

Ans. No, Django is not a CMS. But, it is a Web framework and a programming tool that makes you able to build websites.

Ans. There are three possible inheritance styles in Django: 1) Abstract base class: In this only parent’s class to hold information that you don’t want to type out for each child model then this style is used. 2) Multi-table Inheritance: This inheritance style is used if you are sub-classing an existing model and need each model to have its database table. 3) Proxy models: Proxy models is used, if you only want to modify the Python level behavior of the model, without changing the model’s fields.

Ans. Following is the list of disadvantages of Django: Django’ modules are bulky. It is completely based on Django ORM. Components are deployed together. You must know the full system to work with it.

Ans. Advantages of Django: Web development framework Django is a Python’s framework which is easy to learn. It is clear and readable. It is versatile. It is fast to write. No loopholes in design. It is secure. It is scalable. It is versatile.

Ans. Features available in Django web framework are: Admin Interface (CRUD) Templating Form handling Internationalization A Session, user management, role-based permissions Object-relational mapping (ORM) Testing Framework Fantastic Documentation

Ans. Django is quite stable web development framework.There are many companies like Disqus, Instagram, Pinterest, and Mozilla that are using Django for many years.

Ans. Django is managed and maintained by an independent and non-profit organization named . Goal of foundation is to promote, support, and advance the Django Web framework.

Ans. Django can be broken into following components: Models.py : Models.py file will define your data model by extending your single line of code into full database tables and add a pre-built administration section to manage content. Urls.py : Uses a regular expression to capture URL patterns for processing. Views.py : This is main part of Django. The presentation logic is defined in this. When a visitor visits Django page, first Django checks the URLs pattern you have created and use this information to retrieve the view. Then it is the responsibility of view to processes the request, querying your database if necessary, and passes the requested information to a template. Then template renders the data in a layout you have created and displayed the page.

Ans. Django follows MVT (Model View Template) pattern. It is slightly different from MVC. Model: It is the data access layer. It contains everything about the data, i.e., how to access it, how to validate it, its behaviors and the relationships between the data. Let’s see an example. We are creating Employee model who has two fields first_name and last_name. from django.db import models class Employee(models.Model): first_name = models.CharField(max_length=30) last_name = models.CharField(max_length=30) View: It is the business logic layer. This layer contains the logic that accesses the model and defers to the appropriate template. It is like a bridge between the model and the template. import datetime # Create your views here. from django.http import HttpResponse def index(request): now = datetime.datetime.now() html = “<html><body> Now time is %s. </body></html>” % n

Ans. Django follows Model-View-Template (MVT) architectural pattern. The graph below shows the MVT based control flow. Request is made by the user for a resource to the Django, Django works as a controller and check to the available resource in URL. When the mapping of URL is found , a view is called that interact with model and template, it renders a template. After that Django responds back to the user and sends a template as a response.

Ans. Django Reinhardt, was a gypsy jazz guitarist from the 1930s to early 1950s who is known as one of the best guitarists of all time. The name was given Django after this person.

Ans. Django is web application framework which is a free and open source. Django is written in Python. It is a server-side web framework that provides rapid development of secure and maintainable websites.

Ans. The Django Admin interface is predefined interface made to fulfill the need of web developers as they won’t need to make another admin panel which is time-consuming and expensive. Django Admin is application imported from django.contrib packages. It is operated by the organization itself and thus doesn’t need the extensive frontend. Admin interface of Django has its own user authentication and most of the general features. It also offers lots of advanced features like authorization access, managing different models, CMS (Content Management System), etc.

Ans : The session framework facilitates you to store and retrieve arbitrary data on a per-site visitor basis. It stores data on the server side and abstracts the receiving and sending of cookies. Session can be implemented through a piece of middleware. FREE Counselling & DEMO | Python | Data Science with Python | Online Register Now !

Ans: No, Django is not a CMS. Instead, it is a Web framework and a programming tool that makes you able to build websites.

Ans: A template is a simple text file. It can create any text-based format like XML, CSV, HTML, etc. A template contains variables that get replaced with values when the template is evaluated and tags (%tag%) that controls the logic of the template.

Ans: A: To set up a database in Django, you can use the command edit mysite/setting.py , it is a normal python module with module level representing Django settings. By default, Django uses SQLite database. It is easy for Django users because it doesn’t require any other type of installation. In the case of other database you have to the following keys in the DATABASE ‘default’ item to match your database connection settings. Engines: you can change database by using ‘django.db.backends.sqlite3’ , ‘django.db.backeneds.mysql’, ‘django.db.backends.postgresql_psycopg2’, ‘django.db.backends.oracle’ and so on Name: The name of your database. In the case if you are using SQLite as your database, in that case database will be a file on your computer, Name should be a full absolute path, including file name of that file. Note: You have to add setting likes setting like Password, Host, User, etc.

Ans: There are three possible inheritance styles in Django: 1) Abstract base classes: This style is used when you only want parent’s class to hold information that you don’t want to type out for each child model. 2) Multi-table Inheritance: This style is used if you are sub-classing an existing model and need each model to have its own database table. 3) Proxy models: This style is used, if you only want to modify the Python level behavior of the model, without changing the model’s fields.

Ans: To start a project in Django, use the command $django-admin.py and then use the following command: Project _init_.py manage.py settings.py urls.py

Ans: It facilitates you to divide code modules into logical groups to make it flexible to change. It provides auto-generated web admin to make website administration easy. It provides pre-packaged API for common user tasks. It provides template system to define HTML template for your web page to avoid code duplication. It enables you to define what URL is for a given function. It enables you to separate business logic from the HTML.

Ans: Features available in Django web framework are: Admin Interface (CRUD) Templating Form handling Internationalization Session, user management, role-based permissions Object-relational mapping (ORM) Testing Framework Fantastic Documentation

Ans: Yes, Django is quite stable. Many companies like Disqus, Instagram, Pinterest, and Mozilla have been using Django for many years.

Ans: Django web framework is managed and maintained by an independent and non-profit organization named Django Software Foundation (DSF).

Ans: Django can be broken into many components: Models.py file: This file defines your data model by extending your single line of code into full database tables and add a pre-built administration section to manage content. Urls.py file: It uses regular expression to capture URL patterns for processing. Views.py file: It is the main part of Django. The actual processing happens in view. When a visitor lands on Django page, first Django checks the URLs pattern you have created and uses information to retrieve the view. After that view processes the request, querying your database if necessary, and passes the requested information to template. After that the template renders the data in a layout you have created and displays the page.

Ans: Django is pronounced JANG-oh. Here D is silent.

Ans: Django is a high level Python’s web framework which was designed for rapid development and clean realistic design.

Ans: Django follows Model-View Controller (MVC) architectural pattern.

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

Ans: Assume Bellow model for storing messages with timelines class Message(models.Model): from = models.ForeignKey(User,related_name = “%(class)s_from”) to = models.ForeignKey(User, related_name = “%(class)s_to”) msg = models.CharField(max_length=255) rating = models.IntegerField(blank=’True’,default=0) created_on = models.DateTimeField(auto_now_add=True) updated_on = models.DateTimeField(auto_now=True) Filter messages with specified Date and Time today = date.today().strftime(‘%Y-%m-%d’) yesterday = date.today() – timedelta(days=1) yesterday = yesterday.strftime(‘%Y-%m-%d’) this_month = date.today().strftime(‘%m’) last_month = date.today() – timedelta(days=32) last_month = last_month.strftime(‘%m’) this_year = date.today().strftime(‘%Y’) last_year = date.today() – timedelta(days=367) last_year = last_year.strftime(‘%Y’) today_msgs = Message.objects.filter(created_on__gte=today).count()

Ans: Messages(models.Model): message_from = models.ForeignKey(User,related_name=”%(class)s_from”) message_to = models.ForeignKey(User,related_name=”%(class)s_to”) message=models.CharField(max_length=140,help_text=”Your message”) created_on = models.DateTimeField(auto_now_add=True) class Meta: db_table = ‘messages’ Query :messages = Messages.objects.filter(message_to = user).order_by(‘-created_on’)[0] Output: message_from | message_to | message | created_on ——————|—————–|——————–|——————– Stephen | Anto | Hi, How are you? | 2012-10-09 14:27:48

Ans: When a user requests a page from your Django-powered site, this is the algorithm the system follows to determine which Python code to execute: Django determines the root URLconf module to use. Ordinarily, this is the value of the ROOT_URLCONF setting, but if the incoming HttpRequest object has an attribute called urlconf (set by middleware request processing), its value will be used in place of the ROOT_URLCONF setting. Django loads that Python module and looks for the variable urlpatterns. This should be a Python list, in the format returned by the function django.conf.urls.patterns() Django runs through each URL pattern, in order, and stops at the first one that matches the requested URL. Once one of the regexes matches, Django imports and calls the given view, which is a simple Python function (or a class based view). The view gets passed an HttpRequest as its first argument and

Ans: Use bellow sample method to login with email or username. from django.conf import settings from django.contrib.auth import authenticate, login, REDIRECT_FIELD_NAME from django.shortcuts import render_to_response from django.contrib.sites.models import Site from django.template import Context, RequestContext from django.views.decorators.cache import never_cache from django.views.decorators.csrf import csrf_protect @csrf_protect @never_cache def signin(request,redirect_field_name=REDIRECT_FIELD_NAME,authentication_form=LoginForm): redirect_to = request.REQUEST.get(redirect_field_name, settings.LOGIN_REDIRECT_URL) form = authentication_form() current_site = Site.objects.get_current() if request.method == “POST”: pDict =request.POST.copy() form = authentication_form(data=request.POST) if form.is_valid(): username = form.cleaned_data[‘username’] password = form.cleaned_data[‘password’] t

Ans: There are 7 steps ahead to start Django project. Step 1: Create project in terminal/shell f2finterview:~$ django-admin.py startproject sampleproject Step 2: Create application f2finterview:~$ cd sampleproject/ f2finterview:~/sampleproject$ python manage.py startapp sampleapp Step 3: Make template directory and index.html file f2finterview:~/sampleproject$ mkdir templates f2finterview:~/sampleproject$ cd templates/ f2finterview:~/sampleproject/templates$ touch index.html Step 4: Configure initial configuration in settings.py Add PROJECT_PATH and PROJECT_NAME import os PROJECT_PATH = os.path.dirname(os.path.abspath(__file__)) PROJECT_NAME = ‘sampleproject’ Add Template directories path TEMPLATE_DIRS = ( os.path.join(PROJECT_PATH, ‘templates’), ) Add Your app to INSTALLED_APPS INSTALLED_APPS = ( ‘sampleapp’, ) Step 5: Urls configuration in urls.py from django.conf.urls.defaults import

Ans: If the data is complex and consists of multiple joins using the SQL will be clearer. If Performance is a concern for your, ORM aren’t your choice. Genrally. Object-relation-mapping are considered good option to construct an optimized query, SQL has an upper hand when compared to ORM.

Ans: There are 3 inheritance types in Django Abstract base classes Multi-table Inheritance Proxy models

Ans: Few caching strategies that are available in Django are as follows: File sytem caching In-memory caching Using Memcached Database caching FREE Counselling & DEMO | Python | Data Science with Python | Online Register Now !

Ans: Yes, you can create singleton object. Here’s how you do it : Default 12 3 4 5 class Singleton(object):def __new__(cls,*args,**kwargs): if not hasattr(cls,’_inst’): cls._inst = super(Singleton,cls).__new__(cls,*args,**kwargs) return cls._inst

Ans: Session framework in django will store data on server side and interact with end-users. Session is generally used with a middle-ware. It also helps in receiving and sending cookies for authentication of a user.

Ans: Django runs on MVC architecture. Following are the components that make up django architecture: Models: Models elaborate back-end stuffs like database schema.(relationships) Views: Views control what is to be shown to end-user. Templates: Templates deal with formatting of view. Controller: Takes entire control of Models.A MVC framework can be compared to a Cable TV with remote. A Television set is View(that interacts with end user), cable provider is model(that works in back-end) and Controller is remote that controls which channel to select and display it through view.

This will reload the site making changes obvious. Ans: Keep in mind that it should take an index number and output the sequence. Additionally, there should be a page that shows the most recent generated sequences. Following is one of the solution for generating fibonacci series: Default def fib(n): “Complexity: O(log(n))” if n return 0 i = n – 1 (a, b) = (1, 0) (c, d) = (0, 1) while i > 0: if i % 2: (a, b) = (d * b + c * a, d * (b + a) + c * b) (c, d) = (c * c + d * d, d * (2 * c + d)) i = i / 2 return a + b Default Below is a model that would keep track of latest numbers: from django.db import models class Fibonacci(models.Model): parameter = models.IntegerField(primary_key=True) result = models.CharField(max_length=200) time = models.DateTimeField() DefaultFor view, you can simply use the following code: from models import Fibonacci def index(request): result = None if request.method==

Ans: Views will take request to return response. Let’s write a view in Django : “example” using template example.html , using the date-time module to tell us exact time of reloading the page. Let’s edit a file called view.py, and it will be inside randomsite/randomapp/ To do this save and copy following into a file: Default from datatime import datetime from django.shortcuts import render def home (request): return render(request, ‘Guru99_home.html’, {‘right_now’: datetime.utcnow()}) Default You have to determine the VIEW first, and then uncomment this line located in file urls.py # url ( r ‘^$’ , ‘randomsite.randomapp.views.home’ , name ‘example’),

Ans: Some of the typical usage of middlewares in Django are: Session management, user authentication, cross-site request forgery protection, content Gzipping, etc.

Ans : Template can create formats like XML,HTML and CSV(which are text based formats). In general terms template is a simple text file. It is made up of variables that will later be replaced by values after the template is evaluated and has tags which will control template’s logic.

A. created = models.CreationTimeField() B. created = models.DateTimeField(default=datetime.datetime.now()) C. created = models.DateTimeField(auto_now_add=True, auto_now=True) D. created = models.DateTimeField(auto_now=True) E. created = models.DateTimeField(auto_now_add=True) Ans: E FREE Counselling & DEMO | Python | Data Science with Python | Online Register Now ! 51. What is the difference between a project and an app in Django? Ans: In Django, a project is the entire application and an app is a module inside the project that deals with one specific requirement. E.g., if the entire project is an ecommerce site, then inside the project we will have several apps, such as the retail site app, the buyer site app, the shipment site app, etc. 52. What is Django Admin Interface? Ans: Django comes with a fully customizable in-built admin interface, which lets us see and make changes to all the

A. Defines the URL prefix where static files will be served from . B. Defines the location where all static files will be copied by the ‘collectstatic’ management command, to be served by the production webserver. C. A project’s static assets should be stored here to be served by the development server. D. Defines the location for serving user uploaded files. Ans: B

A. {% for d in mydata %} {% d.1 %} {% endfor %} B. {% for d in mydata -%} {{ d.1 }} {% end -%} C. {% for d in mydata %} {{ d.1 }} {% endfor %} D. {{ for d in mydata }} {{ d[1] }} {{ endfor }} E. {% mydata.each |d| %} {{ d.2 }} {% end %} Ans: C

A. from django.db.models import pre_save B. from django.db.models.signals import pre_save C. There is no pre_save signal D. from django.db.models.signal import pre_save Ans: B

A. url(r’^admin/’, admin.as_view(), name=’admin ), B. url(r’^admin/’, include(admin) ), C. url(r’^admin/’, include(admin.site.urls) ), D. url(r’^admin/’, admin.urls ), E. admin.autodiscover() Ans: C

A. Checks for errors in your views. B. Checks for errors in your templates. C. Checks for errors in your controllers. D. Checks for errors in your models. E. Checks for errors in your settings.py file. Ans: D

A. render_to_html B. render_to_response C. response_render D. render Ans: B

A. def setUp(): B. class Meta: C. class __init__: D. def Meta(): E. def __init__(): Ans: B

A. User.objects.all() B. Users.objects.all() C. User.all_records() D. User.object.all() E. User.objects Ans: A

A. In settings.py: USE_L10N=True B. in views.py, import timezone C. in views.py, import tz D. in urls.py, import timezone E. In settings.py: USE_TZ=True Ans: E

A. django-admin.py startproject myproject B. django-admin.py –start myproject C. django.py startproject myproject D. django.py –new myproject E. django.py new myproject Ans: A

A. (r’^pattern/$’, YourView.as_view()), B. (r’^pattern/$’, YourView.init()), C. (r’^pattern/$’, YourView), D. (r’^pattern/$’, YourView()), Ans: A

A. django.extras B. django.helpers C. django.utilities D. django.ponies E. django.contrib Ans: E

A. The Http404 exception is raised. B. The DatabaseError exception is raised. C. The MyObject.DoesNotExist exception is raised. D. The object is created and returned. Ans: C

A. To model an input form for a template B. To specify rules for correct form when writing Django code C. To define a form based on an existing model Ans: C

A. __unicode__ B. to_s( self ) C. __translate__ D. __utf_8__ Ans: A

A. model = new ForeignKey(User) B. user = models.IntegerKey(User) C. user = models.ForeignKey(User) D. models.ForeignKey( self, User ) Ans: C

A. Create a new Form, don’t use a ModelForm B. Use the exclude parameter in the Meta class in your form C. Set the field to hidden D. You can not do this Ans: B

A. FastCGI B. mod_wsgi C. SCGI D. AJP Ans: B

A. A good Django app provides a small, specific piece of functionality that can be used in any number of Django projects. B. A good Django app is a fully functioning website that has 100% test coverage. C. A good Django app is highly customized and cannot be used in multiple projects. Ans: A

A. name = models.CharField(max_len=255) B. model.CharField(max_length=255) C. name = models.CharField(max_length=255) D. model = CharField(max_length=255) E. name = model.StringField(max_length=auto) Ans: C

A. To configure settings for the Django project B. To configure settings for an app C. To set the date and time on the server D. To sync the database schema Ans: A

A. No additional action is required, Django notices new apps automatically. B. Run the `manage.py validate` command, and then start a new shell. C. Run the `manage.py syncdb` command. D. In settings.py, add the app to the PROJECT_APPS variable. E. In settings.py, add the new app to the INSTALLED_APPS variable. Ans: E

A. PHP B. Ruby C. Javascript D. Java E. Python Ans: E

A. manage.py –run 12.34.56.78 8080 B. manage.py –dev 12.34.56.78:8080 C. manage.py runserver 12.34.56.78:8000 D. manage.py run 12.34.56.78:8080 E. manage.py runserver 12.34.56.78:8080 Ans: E

A. This file contains site deployment data such as server names and ports. B. It contains a site map of Django-approved URLs. C. It contains URL matching patterns and their corresponding view methods. D. You run this file when you get obscure 404 Not Found errors in your server logs. E. This file provides an up to date list of how-to URLs for learning Django more easily. Ans: C

A. manage.py –newapp users B. manage.py newapp users C. manage.py –startapp users D. manage.py startapp users E. manage.py start users Ans: D

A. admin.register( Users ) B. admin.site( self, User ) C. user.site.register( Admin ) D. users.site.register( Admin ) E. admin.site.register( User ) Ans: E

A. Starts a command line in whatever $SHELL your environment uses. B. Starts a Django command prompt with your Python environment pre-loaded. C. Starts a Python command prompt with your Django environment pre-loaded. D. Loads a special Pythonic version of the Bash shell. E. Loads a Python command prompt you can use to sync your database schema remotely. Ans: C

A. User.objects.filter( last_login=Null ) B. User.objects.filter( last_login__null=True ) C. User.objects.filter( last_login__isnull=False ) D. User.objects.filter( last_login__isnull=True ) E. User.objects.filter( last_login=Never ) Ans: D

A. manage.py runserver B. manage.py –start C. manage.py run D. manage.py startserver –dev E. manage.py –run Ans: A

Ans: The Django field class types specify: The database column type. The default HTML widget to avail while rendering a form field. The minimal validation requirements used in Django admin. Automatic generated forms.

Ans: Some usage of middlewares in Django is: Session management, Use authentication Cross-site request forgery protection Content Gzipping, etc.

Ans: You have to set the SESSION_ENGINE settings to “django.contrib.sessions.backends.file” to use file based session.

Ans: There are three main things required to set up static files in Django: 1. Set STATIC_ROOT in settings.py 2. run manage.py collectsatic 3. set up a Static Files entry on the PythonAnywhere web tab

Ans: The session framework facilitates you to store and retrieve arbitrary data on a per-site visitor basis. It stores data on the server side and abstracts the receiving and sending of cookies. Session can be implemented through a piece of middleware.

Ans: No, Django is not a CMS. Instead, it is a Web framework and a programming tool that makes you able to build websites.

Ans: A template is a simple text file. It can create any text-based format like XML, CSV, HTML, etc. A template contains variables that get replaced with values when the template is evaluated and tags (%tag%) that controls the logic of the template.

Ans: To set up a database in Django, you can use the command edit mysite/setting.py , it is a normal python module with module level representing Django settings. By default, Django uses SQLite database. It is easy for Django users because it doesn’t require any other type of installation. In the case of other database you have to the following keys in the DATABASE ‘default’ item to match your database connection settings. Engines: you can change database by using ‘django.db.backends.sqlite3’ , ‘django.db.backeneds.mysql’, ‘django.db.backends.postgresql_psycopg2’, ‘django.db.backends.oracle’ and so on Name: The name of your database. In the case if you are using SQLite as your database, in that case database will be a file on your computer, Name should be a full absolute path, including file name of that file. Note: You have to add setting likes setting like Password, Host, User, etc. in

Ans: There are three possible inheritance styles in Django: 1. Abstract base classes: This style is used when you only want parent?s class to hold information that you don’t want to type out for each child model. 2. Multi-table Inheritance: This style is used if you are sub-classing an existing model and need each model to have its own database table. 3. Proxy models: This style is used, if you only want to modify the Python level behavior of the model, without changing the model’s fields.

Ans: To start a project in Django, use the command $django-admin.py and then use the following command: Project _init_.py manage.py settings.py urls.py

Ans: It facilitates you to divide code modules into logical groups to make it flexible to change. It provides auto-generated web admin to make website administration easy. It provides pre-packaged API for common user tasks. It provides template system to define HTML template for your web page to avoid code duplication. It enables you to define what URL is for a given function. It enables you to separate business logic from the HTML.

Ans: Features available in Django web framework are: Admin Interface (CRUD) Templating Form handling Internationalization Session, user management, role-based permissions Object-relational mapping (ORM) Testing Framework Fantastic Documentation

Ans: Yes, Django is quite stable. Many companies like Disqus, Instagram, Pinterest, and Mozilla have been using Django for many years.

Ans: Django web framework is managed and maintained by an independent and non-profit organization named Django Software Foundation (DSF).

Ans: Django is based on MVT architecture. It contains the following layers: Models: It describes the database schema and data structure. Views: The view layer is a user interface. It controls what a user sees, the view retrieves data from appropriate models and execute any calculation made to the data and pass it to the template. Templates: It determines how the user sees it. It describes how the data received from the views should be changed or formatted for display on the page. Controller: Controller is the heart of the system. It handles requests and responses, setting up database connections and loading add-ons. It specifies the Django framework and URL parsing.

Ans: Django follows Model-View Template (MVT) architectural pattern.

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

Ans: Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design. Built by experienced developers, it takes care of much of the hassle of Web development, so you can focus on writing your app without needing to reinvent the wheel. It’s free and open source..