Django%20Interview%20Questions%20and%20Answers

Ques 1. What are models in Django?

In Django, a model is a class that maps to a database table or database collection. Models class contains attributes representing a database field, defined within the app/models.py file. These models act as the abstraction layer, helping in structuring and manipulating data. The models are the subclass of the django.db.models.Model class.

from django.db import models#product modelclass Product(models.Model):    name= models.CharField(max_length=30)    price= models.models.IntegerField()    description = models.TextField()    def __str__(self):        return f'{self.name}'

Ques 2. Explain the admin interface in Django.

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.

Ques 3. How is the code reusability of Django better than other frameworks?

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.

Ques 4. What happens when the Django website receives a request?

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.

Ques 5. Explain the Django REST framework.

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.

Ques 6. What is the django.shortcuts.render function?

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:

Ques 7. How can you add view functions to the urls.py file?

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.

Ques 8. What is user authentication in Django?

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.

Ques 9. How can you set up the database in Django?

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.

Ques 10. How can you set up static files in Django?

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

Ques 11. What is the session framework in Django?

Django comes with the session framework helping to store and retrieve the arbitrary data on a per-site-visitor basis. It saves all data on the server-side and abstracts the receiving and sending of cookies. You can implement the session via middleware.

Ques 12. How many types of inheritance styles are in Django?

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

Ques 13. What are signals in Django?

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.

Ques 14. What are some important parameters of signals?

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

Ques 15. How can you connect the Django project with the database?

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