Questions et reponses d'entretien

Most developers prefer Django due to its dominance in the market, as it shows high computational and statistical capabilities. The following are some of the advantages of Django:

• Django follows Python’s ‘batteries included’ trait. Python is generally referred to as ‘batteries included’ because it has a unified standard library, helping developers use readymade packages to add features to a web project. 
• Most of the packages in Python’s standard library are open-source. With these packages, you can even implement authentication, admin interfacing, session management, and other advanced functionalities. 
• Python and Django are core technologies in IT giants, the Internet of Things (IoT), and blue chip companies. Therefore, learning it would help you establish a lucrative career. 

   

• Security is yet another advantage of using the Django framework. Applications developed on Django are protected against SQL injection, clickjacking, XSS and CSRF attacks, etc.
• The built-in template language of Django promotes the process of building applications. 
• Django enables developers to create applications and configure frameworks on the go. Also, it offers support for external libraries and packages. Django focuses on explicit programming, allowing the developers to create applications that require frequent changes.
• It helps in faster development and is thus used by most companies. If the configuration is correct, then you can use Django for optimizing web applications.
• Django has a REST framework, a python library, that helps develop APIs for many applications. Using these APIs, you can add advanced functionalities to your applications.
• Django comes with ML capabilities and libraries such as PyTorch, NumPy, etc.

Despite many advantages, developers still find it challenging to make the transition. The following are some disadvantages of using the Django framework:

• Django lacks conventions that can be followed by developers for web development.
• It is not ideal for smaller projects having fewer requirements because it has a vast structure and heavy functionalities 
• The Django framework is monolithic, i.e., developers have to work on the given patterns

The following are the best features of the Django framework:

• Compared to other Python frameworks, Django has the best documentation available in the market
• It is a Python-based framework that offers all Python libraries for use in an application to add extra functionality
• Django primarily maintains a website using URLs rather than its IP address on the server, making it easier for SEO engineers to add the website to the servers
• It is highly versatile and scalable
• Django is highly secure and thoroughly tested
• It also ensures rapid development

Django follows the Model-View-Template(MVT) architecture based on a popular Model-View-Controller(MVC) architectural pattern, which is followed by popular web-frameworks like Ruby on Rails, Laravel etc.

Django’s Model-View-Template architecture divides the complete application into three major logical components:

1. Model 
2. View
3. Template

All these three components are responsible for handling the different aspects of the web application.

Model: The models handle the database schema for the web applications. It maintains and represents the complete application data into the database. The default relational database used by the model is SQLite which is generally used in development, but in production we can use the MySQL and Postgres.

View: The view component manages all the logic of the application that we want to render on the user’s browser. In Django, the view acts as a bridge between the models and the templates. In the views, we can fetch the data from the models and render it on the template.

Template: The template component is the collection of static parts of the application such as the HTML, CSS, JavaScript, and Image files. The view uses the template as the base on which the data should be presented, because at the end, the web-application uses the static files to represent the content on the user browser.

The following is the project directory structure in Django:

• manage.py: It is a command-line utility, allowing users to interact with their Django project
• __init__.py: An empty file specifying Python to consider the current directory as a Python package
• settings.py: It contains the necessary configurations of the project, such as DB connections
• urls.py: It holds all the URLs of a project
• wsgi.py: It is an application’s entry point used by web servers to serve the project 

The architecture of Django consists of the following components:

• Models: It specifies the database schema and the data structure
• Views: It controls what a user will see, the view used to retrieve the data from appropriate models, implement calculation on the data, and pass it to the desired template
• Templates: It specifies how the user sees it. It describes how the data received from the views should be formatted to display on a page
• Controller: The Django framework and URL parsing

Django is based on the MVT architecture, and since Django is the controller of the architecture, it has defined some rules that all developers need to follow to execute appropriate files at the right time.

In Django, you get great customizability with implementation. But you are not allowed to make changes to the file names, the predefined lists, and variable names. You have to create the new ones, but you can’t make changes to the predefined variables.

The monolithic behavior helps the developers to understand the project easily. Even if the company changes, the project layout will remain the same. Therefore, developers take less time to understand the code, increasing productivity.

In Django, the packages website is the place where all the third-party applications are uploaded. You can install them in your system.

Django is a compelling framework and is used by various renowned organizations. Some of the highly trafficked websites using Django are:

• Instagram
• Pinterest
• Disqus
• Mozilla
• Bitbucket
• YouTube
• Spotify
• NASA
• Eventbrite

The following are the exception classes available in Django:

Field class types specify the following:

• The database column type.
• The default HTML widget for availing while rendering a form field.
• The minimal validation requirements used in Django admin that helps in automatically generated forms.

The following is a list of some companies that use Django:

• PBS
• Instagram
• Mozilla
• The Washington Times
• Disqus, Bitbucket
• NextDoor
• YouTube
• Pinterest
• DISCUS

The admin interface is the interface already available in Django. It helps web developers save their time by eliminating the need to create another admin panel. Django admin is an application that can be easily imported from the package named django.contrib. It comes with user authentication and other features, such as management of various models and CMS, among other things.

The Django admin interface has two default models, Groups and Users, which are included in the admin interface after migrating the project and creating a new superuser.

To login to the default admin space, we need to route the URL to the admin panel, which is http://127.0.0.1:8000/admin/ by default.

Django offers better reusability of code than other available Python-based web frameworks. It is a collection of various applications, such as login applications, signup, etc. You can copy such applications from one directory to another by making the required changes to the settings.py file. Thus, there is no need to write the entire code for the signup application from scratch. This is why Django helps in the rapid development of web applications.

Django is a batteries-included web framework, which means it comes with some built-in common components such as login, signup, session, and authentication features.

We can easily use those prewritten components code in our web applications by importing them into the script.

Whenever a user enters the URL in the browser, the Django server receives the request. The server looks for the URL in its URL-config. If the server finds the match there, it will return the corresponding view function.

Then the request is made to the model of an application to get the data. If there is any data to be passed, pass it to the corresponding template. After, the template renders in the browser. If the process does not work as expected, the user will get a “404” error page.

With the help of Django's REST framework, you can create RESTful APIs quickly and efficiently. This framework gets funding from various big shot companies and is popular due to its multiple commendable features such as serialization, authentication policies, etc.

RESTful APIs are well-suited for creating web applications since they use low bandwidth and can communicate over the internet via GET, POST and PUT methods.

When the webpage is returned as the HttpResponse instead of the simple string by a view function, use the render() function. This function will allow the developers to pass the data dictionary using a template. Then this function will use the templating engine for combining the template along with the data dictionary.

After that, this function will return the HttpResponse with the rendered text that is being returned by the models. In this way, this function will save a lot of time for developers and allow them to use different templating engines.

The basic render Syntax:

The following are the two methods for adding view functions to the urls.py file:

• By adding the function view: Using this method, you need to import the view as a function. You import the function from the specific view and then add the URL to the urlpattern list.
• By adding the class-based view: This is an object-oriented approach where you import the class from the views.py file and later add the URL to the urlpattern lists. For this, you will require an inbuilt method for calling the class as a view.

Django has a built-in user authentication system capable of handling different objects, such as users, groups, user-permissions, and some cookie-based user sessions.

Django’s User authentication not only helps in authenticating, but also in authorizing a user and checking what permissions that user has.

The system operates on the following objects:

• Users
• Permissions
• Groups
• Password Hashing System
• Forms Validation
• A pluggable backend system

Third-party web applications can be used instead of the default system as you have much more control over user authentication and many other features.

You can edit mysite/setting.py, a module representing Django settings. By default, Django uses SQLite, which is easy to use and does not require any type of installation.

If your database choice is different, you have to do the following keys in the DATABASE ‘default’ item for matching your database connection settings:

• Engines: You can make the changes to the database using ‘django.db.backends.sqlite3’, ‘django.db.backeneds.mysql’, ‘django.db.backends.postgresql_psycopg2’, ‘django.db.backends.oracle’, and so on.
• Name: If you use SQLite as your database, the database file will be on your computer. The name should be a full absolute path, including the file name of that file.

But, if you do not choose SQLite, you need to add the settings such as Password, Host, User, etc.

For setting up the static files in Django, you need to consider the below steps:

• Firstly, set the STATIC_ROOT in the settings.py file
• Run the manage.py collectsatic file
• Finally, set up a Static Files entry on the PythonAnywhere web tab

Django has three inheritance styles, as mentioned below.

• Abstract base classes: You can use this style when you want a parent’s class to only store the information you don’t want to use for each child model
• Multi-table Inheritance: You can use this style If you are subclassing an existing model and need each model to have its database table.
• Proxy models: You can use this model if you only want to change the Python level behavior of the model without the need to change the model’s fields

Signals are pieces of code that hold information regarding what is happening. You can use a dispatcher for sending the signals and listening to those signals. 

The signals become very useful when we want to do something with the data, before or after a certain event occurs.

Here is the list of events on which we can use the Django signals:

• pre_save() trigger before save().
• post_save() trigger after save().
• pre_delete() trigger before delete().
• post_delete() trigger after delete().
• m2m_changed() triggers when there is a change in ManyToMany Field.
• request_started() trigger when the django starts the HTTP request.
• request_finished() trigger when the django finishes the HTTP request.

The following are the two important parameters of signals:

• Receiver: It specifies the callback function connected to the signal
• Sender: It specifies a particular sender from where a signal is received

By default the Djagno connected to the SQLite database, with the following setting:

DATABASES = {    'default': {        'ENGINE': 'django.db.backends.sqlite3',        'NAME': BASE_DIR / 'db.sqlite3',    }}

Yes, you can customize Django’s admin interface. Django’s admin is another entirely customizable application. It enables you to download another third-party application for a different view. You can create your own admin application to have complete control over it. Also, for customizing the Django admin site, you can change the settings of the admin site object.

Also, you can make the desired changes to your models and then apply them in the Django admin for adding specific applications, such as the search bar. You can customize even a smaller detail of your Django admin interface. Still, it is advisable to create a new admin rather than making so many changes at a lower level.

Django is considered a loosely coupled framework, as it is based on the MVT architecture, a variant of the MVC architecture. The MVT architecture is useful because it entirely separates the server code from the client’s machine.

Models and views are available on a client machine. However, the client only receives the template — the HTML and CSS code — along with the data from the models.

Since these components are different, the front-end and back-end developers can work together on the same project. Making changes to a project by both the teams will not impact each other, thus making Django a loosely coupled framework.

Whenever you start the Django server, initially, it looks for the settings.py file, containing the main settings regarding a web application. Also, it contains everything related to your web application, such as databases, a backend engine, templating engines, static file addresses, servers, security keys, middlewares, URL configs, and other essential data.

So, when you start the Django server, it will first execute the settings.py file and, later, load the required engines and databases.

Django has a powerful way of storing the URLs that are regular expressions. You can easily use the regular expression format for string searching algorithms, making the search process faster.

However, after the release of Django 2.2 and later versions there is no need to use the regular expression for defining the URL. Instead, you can use normal strings. The regular expression is used whenever you want to pass some data from the user via the URL. But whatever you use, the Django server needs to match them.

ORM stands for Object-relational mapper, a special feature tool of Django. This tool helps developers to interact with the database in a more Python-esque way. It acts as the abstraction between the models and the database, where the main data is stored.

Using ORM, you can retrieve, save, and delete the data from a database without the need to write any SQL code for it. This tool will help eliminate many loopholes since it lets you maintain control over your code, and is developed in Python.

It does not matter whether the Database is a SQLite, MySQL, Postgre or Oracle the ORM makes sure that the developer writes the same code for all databases.

Django uses the ORM known as Django ORM, it uses classes inherited from models.Modle, to create tables under any database.

The only thing we need to tweak is the database settings in the setting.py file.

DATABASES = {    'default': {        'ENGINE': 'django.db.backends.postgresql',         'NAME': 'DB_NAME',        'USER': 'DB_USER',        'PASSWORD': 'DB_PASSWORD',        'HOST': 'localhost',          'PORT': '5432',    }}

Templates are the reason behind Django’s ability to create dynamic web pages. These templates are HTML code returned as an HTTP response. Furthermore, Django has a templating engine capable of handling templating. You can use some of the template syntaxes while declaring the variables, control logic, and comments.

Once you provide all the template syntax within the HTML structure, the web page is requested and called by the view function. Later, the Django template engine will get the HTML structure with variables and the data to replace these variables. The templating engine will replace these while executing the control logic and generating filters. It will then render the required HTML and send it to the browser.

A view is a middle layer between a model and a template, and it will take the data from the model and pass it to a template. Every application in Django has the view.py file that stores view functions, and these functions take the argument and return the browser-renderable format.

You can easily import view functions in the URL file. To do so, you need to import the view function in the urls.py file and add the desired path required by the browser to call that function.

This config file stores all the URL lists and mapping to their respective view functions. These URLs can be mapped to view functions, class-based views, and url-config of another application.

The default URL list name is urlpatterns, and it contains all the path() or re_path() URL patterns. The project URL comes with the root urls.py file, and with every application, we can also make an isolated urls.py file for that application.

Example:

from django.contrib import adminfrom django.urls import path, includeurlpatterns = [    path('admin/', admin.site.urls),    path(blog/', include('blog.urls')),]

Django comes with the support for many popular templating engines, and by default, it comes with one very powerful templating engine, called Jinja Templating. The latest version is Jinja 2.

Below are some features of the Jinja templating, making it a better option than another templating engine available.

• Sandbox Execution: It is a protected framework useful for automating the testing process
• HTML Escaping: Jinja 2 comes with an automatic HTML Escaping, as <, >, & characters that have special values in templates. If you use it as regular text, these symbols can lead to XSS Attacks, handled by Jinja automatically.
• It shows template inheritance and generates HTML templates much faster than the default engine
• It is easier to debug with Jina compared to the default engine

Mixin is a type of multiple inheritances that combines the behaviors and attributes of more than one parent class. It provides an excellent way of reusing the code from multiple classes.

For example, generic class-based views have a mixin called TemplateResponseMixin. This mixin is used for defining the render_to_response() method. When you combine it with a class present in the View, it results in a TemplateView class.

The only drawback of mixin is that it becomes difficult to analyze what a child class is doing and which methods to override if its code scatters between multiple classes.

In Django, migrations are used for propagating the changes made to models. You can use the migrate command to apply and remove the migration changes made to models.

This command helps synchronize the current set of models and migrations with the database state. You can also use this command with or without passing the parameters. If you do not specify any parameters, all apps will have all their migrations running.

A Model is specified as a Python class derived from the Model class. This model class is imported from the django.db.models library. The main concept of Django Models is to create objects for storing data from a user in a user-defined format.

The model class is a pre-defined class with lots of benefits. You can define the field with specific attributes as you can do in SQL, but the same can also be achieved in Python.

This class is parsed by Django ORM or backend engine, and there is no need to do anything related to a database, such as creating tables and defining fields afterward mapping the fields with the attribute of the class.