Django & Flask
Interview Questions

In Django, the Model represents the data structure, the View handles presentation and user interaction, and the Controller processes user input and communicates between the Model and View. In Django's context, it is often referred to as the Model-View-Template (MVT) pattern, where the Template is responsible for the presentation.

Django ORM is an Object-Relational Mapping system that allows developers to interact with databases using Python objects. Models in Django represent database tables, and fields in models map to columns in the tables. Django ORM abstracts the SQL queries, making it easier to perform database operations using Python code.

Django migrations are a system for handling database schema changes over time. They allow developers to define changes to the database schema in a versioned and incremental way. Migrations are automatically created when changes are made to models, and they can be applied to the database to keep it in sync with the code.

Django views handle user requests, process data, and return responses. A view receives input from the user, interacts with the Model (if needed), and renders a Template to generate an HTML response. Views are Python functions or classes responsible for the application's logic.

Django Templates are used to generate dynamic HTML pages in a Django web application. They allow embedding Python-like expressions and statements within HTML code. Templates separate the presentation logic from the business logic, enabling the creation of reusable and maintainable HTML files.

URL routing in Django refers to the mapping of URLs to views. It is implemented using the urls.py file in each Django app. URL patterns are defined using regular expressions or simple strings, and they are associated with specific view functions or classes.

The urls.py file in Django contains the URL patterns for a particular app within a project. It defines how URLs are mapped to views. URL patterns are specified using regular expressions or simple strings, and they are associated with view functions or classes.

Django Forms are used to handle HTML forms and user input. They simplify the process of validating, processing, and rendering forms in a web application. Django Forms can be created manually or generated from models, and they provide built-in validation and error handling.

Django Formsets are a way to manage multiple forms on the same page. They allow working with a collection of forms, such as formsets for multiple instances of a model. Formsets simplify the handling of multiple forms in a single view and provide a consistent interface for validation and saving data.

Django Middleware is a set of hooks that process requests and responses globally before reaching the view or after leaving the view. Middleware can perform tasks such as authentication, logging, or modifying the request or response. Middleware components are defined in the MIDDLEWARE setting.

Django Rest Framework is a powerful and flexible toolkit for building Web APIs in Django applications. DRF provides features like serialization, authentication, permissions, and viewsets to simplify the creation of RESTful APIs. It is widely used for building APIs that serve as backends for mobile apps or frontend frameworks.

The Django Admin interface is a built-in feature that provides a graphical user interface for managing the database records. It allows administrators to perform CRUD (Create, Read, Update, Delete) operations on the data. To enable the Admin interface, the app's models need to be registered in the admin.py file.

Django Admin can be customized by creating a custom admin.py file in the app and using features like list_display, list_filter, and search_fields to control the display of fields. Additional customizations can be made by overriding templates or creating custom admin views.

Django's testing framework allows developers to write unit tests, integration tests, and functional tests for their applications. It provides tools for testing models, views, forms, and other components. The testing framework helps ensure that changes to the codebase do not introduce regressions and that the application behaves as expected.

The django.test.TestCase class is a subclass of Python's unittest.TestCase that provides additional functionality for testing Django applications. It sets up a test database and provides methods for testing models, views, and forms. Test cases created with TestCase are transactional and ensure a clean database state for each test.