Interview Questions and Answers

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',    }}