How are URLs mapped to views in Django?

In Django, the mapping of URLs to views is done through the URLconf (URL
configuration) system. The URLconf serves as a mechanism for defining the
mappings between URL patterns and the corresponding views or handlers that
should be invoked when a matching URL is requested.
The URLconf is typically defined in a Python module, often named urls.py,
within your Django project or application. This module contains a set of URL
patterns represented as regular expressions or simple strings, along with
references to the corresponding view functions or classes.
When a request is made to a Django application, the URL dispatcher examines
the requested URL and tries to match it against the patterns defined in the
URLconf. It checks the patterns in the order they are defined until it finds a
match. Once a match is found, the associated view function or class is called to
handle the request.
Here's a basic example to illustrate the URL mapping process in Django:
# urls.py
from django.urls import path
from . import views
urlpatterns = [
path('home/', views.home_view, name='home'),
path('products/', views.product_list_view, name='products'),
path('products/<int:pk>/', views.product_detail_view,
name='product_detail'),
]

Why is Django called a loosely coupled framework?

Django is often referred to as a loosely coupled framework due to its design
principles and architectural choices, which promote modular and independent
components. Here are a few reasons why Django is considered loosely
coupled:
• Separation of concerns: Django follows the Model-View-Controller
(MVC) architectural pattern, which emphasizes the separation of
1
 concerns. In Django's case, it uses a variation known as Model-View-
Template (MVT). This separation allows for decoupling the business logic
(models), presentation logic (views), and user interface (templates) into
distinct components. Each component can be developed, tested, and
maintained independently, promoting loose coupling between them.
• Pluggable applications: Django encourages the creation of reusable and
pluggable applications. These applications are self-contained modules
that can be easily integrated into a Django project. They encapsulate
specific functionality and can be added or removed without affecting the
overall structure of the project. This modular approach allows
developers to swap or add components as needed, promoting loose
coupling between different parts of the application.
• URL routing: Django's URL routing system, implemented through the
URLconf, allows for flexible and decoupled URL mappings. URL patterns
and corresponding views are defined in the URLconf, which means you
can easily change the URL structure without affecting the underlying
view logic. This decoupling between URLs and views promotes flexibility
and loose coupling.
• Middleware: Django's middleware system provides a way to process
requests and responses globally before they reach the view functions.
Middleware components can be added or removed as needed, allowing
for independent functionality to be applied across multiple views. This
promotes loose coupling between different middleware components
and the views they interact with.
• Database abstraction: Django provides a high-level database abstraction
layer called the Object-Relational Mapping (ORM). The ORM allows
developers to interact with the database without writing raw SQL
queries. By abstracting the database operations, Django decouples the
application logic from the specific database backend, enabling
developers to switch databases without significant code changes.

What is the Django template system?

The Django template system is a powerful component of the Django web
framework that allows developers to build dynamic web pages by separating
the design (HTML) from the logic (Python code). It provides a convenient way
to generate HTML dynamically by combining templates with data from views
or models.
2
The Django template system follows the philosophy of keeping the business
logic separate from the presentation logic. It helps developers adhere to the
Don't Repeat Yourself (DRY) principle by promoting code reuse and
maintainability.
Key features of the Django template system include:
• Template syntax: Django templates use a simple and intuitive syntax
that blends seamlessly with HTML. It includes tags, variables, and filters.
Tags are enclosed in {% %} and control the flow and logic within
templates. Variables are denoted by {{ }} and represent dynamic data
from the context. Filters modify the output of variables.
• Template inheritance: Django templates support inheritance, allowing
developers to define a base template with common elements and inherit
from it in child templates. This facilitates code reuse and helps maintain
a consistent design across multiple pages.
• Template tags and filters: Django provides a wide range of built-in
template tags and filters that extend the template language's
capabilities. Tags allow for loops, conditional statements, including other
templates, and more. Filters manipulate variables by applying
transformations or formatting.
• Template context: When rendering a template, developers pass a
context that contains data to be used in the template. The context can
be a dictionary or an object that supports attribute access. The template
system retrieves data from the context to populate variables and
generate dynamic content.
• Template loaders: Django supports various template loaders that can
load templates from different sources, such as the filesystem, a
database, or a remote server. This flexibility allows templates to be
stored and fetched from multiple locations.

What is the usage of "Django-admin.py" and "manage.py"?

Both django-admin.py and manage.py are command-line tools provided by
Django for various administrative tasks. While they serve similar purposes,
they are used in different contexts:
• django-admin.py: This is a command-line tool that is installed globally
when Django is installed on your system. It provides access to various

3
 Django administrative commands. You can use django-admin.py to
perform tasks such as creating a new Django project, starting a new app
within a project, running management commands, and more.
• For example, to create a new Django project, you can run the following
command:
django-admin.py startproject myproject
manage.py: This is a command-line tool automatically generated in the root
directory of every Django project when you create a new project using django-
admin.py startproject. It acts as a wrapper around django-admin.py but
provides additional functionalities specific to the project.
manage.py simplifies the management of your project by automatically setting
the required environment variables and using the correct settings module. It
allows you to run various management commands, such as starting the
development server, running database migrations, creating superusers,
running tests, and more.
For example, to start the development server, you can run the following
command:
python manage.py runserver

What is the use of Middlewares in Django?

In Django, middlewares are a key component of the request/response
processing pipeline. They provide a way to process HTTP requests and
responses globally, allowing you to add extra functionality or perform specific
operations at various stages of the request/response cycle.
Middlewares sit between the web server and the view functions, intercepting
and processing requests and responses. When a request is received, Django
sequentially passes it through each middleware component before reaching
the view function that handles the request. Similarly, when a response is
generated by the view function, it passes through each middleware in reverse
order before being sent back to the web server and ultimately to the client.
Here are some common use cases for middlewares in Django:
• Authentication and Authorization: Middlewares can handle
authentication and authorization tasks. For example, you can create a
middleware that checks if a user is authenticated and redirects them to

4
 a login page if not. Similarly, you can create a middleware that verifies if
the user has the necessary permissions to access certain views or
perform specific actions.
• Request/response processing: Middlewares can modify or enhance the
request or response objects. For example, you can create a middleware
that adds additional request headers, modifies request parameters, or
performs input validation. On the response side, you can use a
middleware to add headers, compress response content, or modify the
response body.
• Error handling: Middlewares can catch exceptions and handle errors
globally. You can create a middleware that captures specific types of
exceptions and provides custom error pages or redirects. This helps in
centralizing error handling logic and making your application more
robust.
• Request/response logging: Middlewares can log information about
incoming requests and outgoing responses. You can create a middleware
that logs request details, such as the URL, HTTP method, user agent, and
IP address, or log response information like the status code and
response time. Logging middleware can help in debugging, monitoring,
and performance analysis.
• Maintenance mode: Middlewares can implement a maintenance mode
feature. You can create a middleware that checks a configuration setting
or a database flag to determine if the application is in maintenance
mode. If enabled, the middleware can display a custom maintenance
page for all requests.

What are the features of Django?

Django is a powerful web framework for building web applications in Python. It
provides a wide range of features that make web development efficient,
secure, and scalable. Here are some key features of Django:
• Object-Relational Mapping (ORM): Django includes a high-level ORM
that abstracts database operations, allowing developers to work with
databases using Python objects and queries instead of writing raw SQL.
The ORM supports multiple database backends and provides features
like model relationships, database migrations, and transaction
management.

5
 • URL routing and view system: Django has a flexible URL routing system
that maps URLs to views or view functions. It allows you to define URL
patterns using regular expressions or simple strings and specify the
corresponding view or view function that handles the request. This
separation of URL routing and view logic promotes modular and
reusable code.
• Template system: Django provides a template system that separates the
design (HTML) from the logic (Python code). It allows developers to
generate dynamic web pages by combining templates with data from
views or models. The template system supports template inheritance,
template tags, filters, and caching.
• Form handling: Django offers a powerful form handling mechanism that
simplifies the process of working with HTML forms and handling user
input. The form system provides automatic validation, sanitization, and
error handling. It also supports form rendering, form widgets, and
formsets for working with multiple forms.
• Authentication and authorization: Django provides a robust
authentication system that includes features like user registration, login,
logout, password management, and session handling. It also supports
permission-based authorization, allowing you to control access to
specific views or actions based on user roles and permissions.

What is URL configuration and how is it used in Django?

URL configuration, also known as URL routing or URL mapping, is the process
of defining the mappings between URLs and the corresponding views or
handlers in a web application. In Django, URL configuration is done using a
module called the URLconf (URL configuration file).
The URLconf file is typically named urls.py and is located in the root directory
of a Django project or within individual Django applications. It contains a set of
URL patterns along with references to the corresponding view functions or
classes that should be invoked when a matching URL is requested.
Here's an example to illustrate how URL configuration works in Django:
# urls.py
from django.urls import path
from . import views
6
urlpatterns = [
path('home/', views.home_view, name='home'),
path('products/', views.product_list_view, name='products'),
path('products/<int:pk>/', views.product_detail_view,
name='product_detail'),
]

Why loose coupling is important in Django?

Loose coupling is an important principle in software development, including in
Django, for several reasons:
• Modularity and reusability: Loose coupling allows you to break down
your application into modular and independent components. Each
component can be developed, tested, and maintained separately,
making it easier to understand, reuse, and modify. In Django, loose
coupling enables you to create reusable apps, where an app can be
plugged into multiple projects without tightly coupling it to a specific
project.
• Flexibility and extensibility: Loose coupling enables flexibility and
extensibility in your Django project. When components are loosely
coupled, it becomes easier to modify or replace them with alternative
implementations without affecting other parts of the system. This
promotes flexibility in adapting to changing requirements and allows for
easier integration of new features or technologies.
• Testability: Loose coupling makes it easier to test individual components
in isolation. With loosely coupled components, you can write unit tests
for each component without the need to set up complex dependencies.
Mocking or substituting dependencies becomes simpler, leading to more
focused and effective testing.
• Maintainability and ease of maintenance: In a loosely coupled system,
the dependencies between components are minimized. This reduces the
impact of changes made to one component on the others. It makes
maintenance tasks such as bug fixing, refactoring, and adding new
features less error-prone and more manageable.
• Scalability: Loose coupling enables scalability in your Django application.
It allows you to scale specific components or modules independently

7
 based on their specific needs. For example, you can scale the database
layer separately from the application layer by utilizing techniques like
database sharding or replication.

How does Django process a request?

When a request is received by a Django application, it goes through a series of
steps to process and respond to the request. Here's a high-level overview of
how Django processes a request:
• Web server receives the request: The web server (e.g., Apache or Nginx)
receives the HTTP request from the client and forwards it to the Django
application.
• URL routing: Django's URL dispatcher examines the URL provided in the
request and tries to match it against the URL patterns defined in the
URLconf (URL configuration) file. The URL patterns are checked in the
order they are defined until a match is found.
• View function or class selection: Once a URL pattern is matched, Django
identifies the associated view function or class that should handle the
request based on the URLconf. This view can be a function-based view or
a class-based view.
• Middleware processing: Before the request reaches the view function, it
passes through the middleware components. Middleware functions can
perform operations such as authentication, request preprocessing,
response postprocessing, and more. Middleware components are
executed in the order they are defined.
• View processing: The view function or class is called, and it processes the
request. The view function or class can interact with models, retrieve or
update data from a database, perform business logic, and prepare the
response.
• Template rendering (if applicable): If the view requires rendering a
template, the template engine is invoked. The template engine
combines the view's data context with the template file, resulting in a
rendered HTML response.
• Response generation: Once the view has processed the request and
potentially rendered a template, it returns an HTTP response object. This
response object contains the content, status code, headers, and other
metadata associated with the response.

8
 • Middleware processing (response phase): The response object passes
through the middleware components again, but this time in reverse
order. Middleware functions can perform operations such as response
postprocessing, setting headers, modifying the response content, and
more.
• Response sent to the client: Finally, the web server sends the generated
HTTP response back to the client, completing the request-response
cycle.

What are the basics of CSS? How is it used in web development?

CSS, which stands for Cascading Style Sheets, is a styling language used to
define the appearance and layout of web pages. It is a fundamental technology
in web development and is used to enhance the presentation and visual appeal
of HTML elements. Here are the basics of CSS:
• Selectors: CSS selectors target specific HTML elements to apply styles.
Selectors can be based on element names, class names, IDs, attributes,
or relationships between elements. For example, h1 targets all <h1>
elements, .class targets elements with a specific class, and #id targets
elements with a specific ID.
• Properties and values: CSS properties define the characteristics of HTML
elements, such as color, font size, margin, padding, and more. Each
property is assigned a value to determine its specific behavior. For
example, color: red sets the text color to red, and font-size: 16px sets
the font size to 16 pixels.
• Stylesheets: CSS styles can be applied inline directly within HTML
elements, internally within <style> tags in the <head> section of an
HTML file, or externally in separate CSS files linked to HTML documents.
External stylesheets are commonly used to keep styles separate from
HTML and enable reusability across multiple pages.
• Selectors specificity: CSS applies styles based on the specificity of
selectors. When multiple conflicting styles target the same element, the
style with higher specificity takes precedence. Specificity is determined
by the combination of element type, class, ID, and inline styles.
• Cascading and inheritance: CSS styles cascade from the top of the
document to the bottom, with later styles overriding earlier ones.
Inheritance allows certain styles applied to parent elements to be

9
 inherited by their child elements, reducing the need to repeat styles for
nested elements.

CSS is a critical tool in web development as it enables developers to control the

visual aspects of a website or web application. By separating the content
(HTML) from the presentation (CSS), it promotes maintainability, reusability,
and consistent styling across multiple pages. CSS plays a crucial role in creating
attractive, accessible, and responsive web interfaces.

Explain the basics of dynamic web pages.

Dynamic web pages are web pages that can change their content or behavior
in response to user interactions or other factors. Unlike static web pages,
which display the same content to all users, dynamic web pages allow for
personalized and interactive experiences. Here are the basics of dynamic web
pages:
• Client-side scripting: Dynamic web pages often involve client-side
scripting languages like JavaScript. JavaScript allows you to manipulate
the HTML structure, modify the content, handle user events, and
perform calculations or validations on the client-side. It enables
interactive elements, real-time updates, and dynamic behavior without
requiring a round trip to the server.
• Server-side scripting: Dynamic web pages also utilize server-side
scripting languages like PHP, Python, Ruby, or ASP.NET. These languages
run on the web server and generate dynamic HTML content based on
the requested data or user input. Server-side scripting allows you to
retrieve and process data from databases, perform complex calculations,
generate dynamic HTML templates, and customize the response based
on user context or preferences.
• Data-driven content: Dynamic web pages often rely on data sources
such as databases, APIs, or external services. These data sources provide
the information needed to populate the web page dynamically. Server-
side scripting languages are used to retrieve and process this data and
generate HTML content accordingly. This allows for dynamic content
generation, such as displaying user-specific information, generating
product listings, or retrieving and presenting real-time data.
• User interactions and forms: Dynamic web pages enable user
interactions through forms and input fields. Users can submit data via
10
 forms, and server-side scripts can process the submitted data, validate
it, and store it in a database or perform further actions. Dynamic web
pages allow for real-time form validation, feedback messages, and
immediate responses to user actions.
• Content updates and real-time communication: Dynamic web pages can
update their content dynamically without requiring a full page refresh.
This is achieved through techniques like AJAX (Asynchronous JavaScript
and XML) or newer technologies like WebSockets. These technologies
allow for partial updates of web page content, real-time data retrieval,
and server-client communication, enabling dynamic and interactive
experiences.
Dynamic web pages offer richer and more engaging experiences compared to
static web pages. They enable real-time updates, interactivity, personalized
content, and responsive behavior. By combining client-side and server-side
scripting, dynamic web pages empower developers to create applications that
adapt to user input, retrieve and process data, and provide interactive and
personalized functionality.

Describe the basics of JavaScript and how it is used in web

development.
JavaScript is a widely used programming language that allows developers to
add interactivity and dynamic behavior to web pages. It is a client-side scripting
language, meaning it runs directly in the web browser on the user's device.
JavaScript enables a wide range of functionalities, including DOM
manipulation, event handling, AJAX, form validation, animations, and more.
Here are the basics of JavaScript and its usage in web development:
• Syntax and Variables: JavaScript has a C-like syntax and supports
variables, data types (such as numbers, strings, booleans), and
operators. Variables are declared using the var, let, or const keyword.
JavaScript also supports control structures like conditional statements
(if, else) and loops (for, while).
• DOM Manipulation: One of the key features of JavaScript is its ability to
manipulate the Document Object Model (DOM). The DOM represents
the structure of an HTML document as a tree of objects, and JavaScript
allows you to access and modify these objects to dynamically update the
content, styles, and behavior of web pages. You can select HTML

11
 elements, modify their attributes, change CSS styles, create new
elements, and add or remove elements from the DOM.
• Event Handling: JavaScript allows you to respond to user interactions,
such as clicks, mouse movements, keyboard input, and form
submissions, through event handling. You can attach event listeners to
HTML elements and define functions that are executed when the
specified events occur. This enables interactivity and allows you to
trigger actions or update the page in response to user actions.
• AJAX and Asynchronous Programming: JavaScript enables asynchronous
programming through techniques like AJAX (Asynchronous JavaScript
and XML) and the newer Fetch API. AJAX allows you to make HTTP
requests to a server in the background without refreshing the entire web
page. It enables fetching data, submitting forms, and updating parts of
the page dynamically, enhancing the user experience.
• Form Validation: JavaScript is often used for client-side form validation.
By attaching event listeners to form elements or submit buttons, you
can validate user input before submitting the form to the server.
JavaScript allows you to check for required fields, validate input
patterns, perform calculations, and display error messages dynamically.

What is Bootstrap? How is it used in web development?

Bootstrap is a popular front-end framework for building responsive and
mobile-first websites and web applications. It provides a collection of CSS and
JavaScript components, styles, and utilities that simplify and streamline web
development. Bootstrap is widely used for its robustness, flexibility, and ease
of use. Here's an overview of Bootstrap and its usage in web development:
• Responsive Grid System: Bootstrap includes a responsive grid system
that allows you to create flexible layouts that adapt to different screen
sizes and devices. The grid system uses a 12-column layout, making it
easy to organize content and create responsive designs. Grid classes
define how content should be positioned and distributed across various
screen sizes.
• Pre-styled Components: Bootstrap offers a wide range of pre-styled
components, such as navigation bars, buttons, forms, cards, modals,
carousels, and more. These components are designed with consistent
styles, making it quick and efficient to build UI elements with a

12
 professional look and feel. Components can be easily customized and
extended to match the specific design requirements.
• CSS Styles and Utilities: Bootstrap provides a comprehensive set of CSS
styles and utilities that simplify common tasks in web development. It
includes styles for typography, headings, tables, images, alerts, badges,
and more. Utilities help with spacing, alignment, responsiveness,
visibility, and other layout-related tasks.
• JavaScript Plugins: Bootstrap includes a collection of JavaScript plugins
that enhance the functionality and interactivity of web pages. These
plugins cover areas such as dropdowns, modals, tooltips, carousels,
scrollspy, form validation, and more. The plugins are designed to work
seamlessly with Bootstrap's CSS and can be easily integrated into your
web applications.
• Customization and Theming: Bootstrap allows for customization and
theming to match the design and branding requirements of your project.
You can customize various aspects of Bootstrap, such as colors,
typography, spacing, and component styles, by overriding the default
variables or using the provided customization options. Bootstrap also
provides a theming system that allows you to generate custom CSS files
based on your chosen theme settings.

Explain the client-server architecture and its role in web

development.
The client-server architecture is a fundamental model in web development
that defines the relationship and interaction between clients (user devices) and
servers (computers or systems that host and provide resources). It is the
underlying structure that enables communication, data exchange, and the
delivery of web-based applications and content. Here's an explanation of the
client-server architecture and its role in web development:
• Client: The client refers to the user's device, typically a web browser,
that makes requests for resources or services from a server. The client
sends HTTP requests to the server, receives the responses, and renders
the content for the user to interact with. Clients can be desktop
computers, laptops, smartphones, or any device capable of accessing the
web.

13
 • Server: The server is a powerful computer or system that hosts web
applications, websites, or services and responds to client requests. It
listens for incoming requests, processes them, and sends back the
appropriate responses. Servers are responsible for storing and managing
data, performing computations, and executing the business logic behind
web applications. They can be physical machines or cloud-based virtual
servers.
• Request-Response Cycle: The client-server architecture is based on a
request-response model. The client sends a request to the server,
specifying the desired resource or action, using protocols such as HTTP
or HTTPS. The server receives the request, processes it, and generates
an appropriate response. The response contains the requested data,
HTML content, JSON data, or other resources. The client then receives
the response and renders it for the user.
• Data Exchange: Client-server architecture enables data exchange
between clients and servers. Clients can send data to servers through
various methods, such as form submissions, AJAX requests, or file
uploads. Servers process the received data, perform validations, and
store it in databases or other storage systems. Servers can also send
data to clients in response to requests or for real-time updates using
techniques like server-sent events or WebSockets.
• Scalability and Load Distribution: The client-server architecture allows
for scalability and load distribution. As web applications handle more
users and requests, multiple servers can be set up to distribute the load
and improve performance. Load balancers can be employed to evenly
distribute requests among server instances, ensuring efficient resource
utilization and high availability.

Explain the MVC and MTV design patterns in Django. What is the
difference between them?
In Django, the MVC (Model-View-Controller) design pattern is often referred to
as the MTV (Model-Template-View) pattern. While the concepts are similar,
there are some differences in terminology and implementation. Here's an
explanation of both patterns in the context of Django:
• MVC (Model-View-Controller) Design Pattern:

14
 • Model: The model represents the data and business logic of the
application. It encapsulates the data structures, database interactions,
and validation rules. In Django, models are defined using Python classes
that inherit from django.db.models.Model and interact with the
database.
• View: The view handles the presentation logic and user interactions. It
receives input from the user, interacts with the model to retrieve or
modify data, and decides how to present the data to the user. In Django,
views are Python functions or class-based views that receive HTTP
requests, interact with models, and return HTTP responses.
• Controller: The controller acts as the intermediary between the model
and the view. It receives user input from the view, invokes the
appropriate methods on the model to handle data operations, and
updates the view with the results. In Django, the controller's
responsibilities are typically handled by the view itself, which interacts
directly with the model.
• MTV (Model-Template-View) Design Pattern:
• Model: The model remains the same as in the MVC pattern and
represents the data and business logic.
• Template: The template is responsible for the presentation logic. It
defines how the data is rendered and displayed to the user. Templates in
Django use HTML combined with template tags and filters to
dynamically generate the content. Templates can access data from the
model via the view.
• View: In the MTV pattern, the view acts as the controller as well. It
receives HTTP requests, interacts with the model to retrieve or modify
data, and then passes that data to the template for rendering. The view
handles the logic of deciding which template to use and how to present
the data to the user.
Key Differences:
• In the MVC pattern, the controller is responsible for handling user input
and updating the view, while in the MTV pattern, the view handles these
responsibilities.
• In the MTV pattern, the template is a separate component dedicated to
handling the presentation logic, while in the MVC pattern, the view
handles both presentation logic and user interactions.

15
 • The terminology used in Django is MTV to align with the way Django's
architecture is organized, but the underlying concepts are similar to the
MVC pattern.

What is Django? Explain importance of virtual environment setup

for Django.
Django is a high-level web framework written in Python that follows the
model-view-controller (MVC) architectural pattern, or more specifically, the
model-template-view (MTV) pattern. It provides a set of tools and libraries for
building web applications rapidly and efficiently. Django is known for its
emphasis on simplicity, reusability, and scalability, making it popular among
developers for a wide range of web projects.
The importance of setting up a virtual environment for Django can be
understood by considering the following points:
• Isolation of Dependencies: A virtual environment allows you to create a
self-contained environment for your Django project. It separates the
Python packages and libraries required by your project from the system-
level Python installation. This isolation ensures that the dependencies
specific to your project do not interfere with other Python projects or
the global system environment. It helps avoid conflicts and versioning
issues when working on multiple projects simultaneously.
• Dependency Management: Django projects typically rely on various
third-party packages and libraries. These dependencies may have
specific version requirements or compatibility issues. With a virtual
environment, you can easily manage the specific versions of packages
that your Django project needs. You can install, upgrade, or remove
packages without affecting the global Python installation or other
projects on your system. This makes it easier to maintain consistency
across different development environments and deployments.
• Reproducible Environments: Virtual environments ensure that your
Django project can be reproduced in different environments. By
specifying the exact package versions in your project's requirements file,
you can recreate the same environment on different machines or
servers. This helps ensure consistent behavior and avoids unexpected
issues caused by different package versions or configurations.

16
 • Collaboration and Deployment: Virtual environments simplify
collaboration and deployment of Django projects. When working with a
team, each developer can set up their own virtual environment with the
required dependencies. This ensures that everyone is working with the
same versions of packages and reduces the chances of compatibility
issues. When deploying a Django project to a production server, you can
create a virtual environment specific to that environment, making it
easier to manage and maintain the project's dependencies in the
production environment.

Describe the basics of the Django template system.

The Django template system is a powerful component of the Django web
framework that allows developers to generate dynamic web content using
HTML templates. It separates the presentation logic from the application logic,
providing a clean and readable way to build user interfaces. Here are the basics
of the Django template system:
• Template Syntax: Django templates use a simple syntax that combines
HTML with template tags, template variables, and template filters.
Template tags are enclosed in {% %} and control the flow of logic and
iteration, while template variables are enclosed in {{ }} and represent
dynamic values. Template filters are appended to variables using the
pipe (|) character and modify the displayed value.
• Context and Variables: When rendering a template, a context is
provided, which is a dictionary-like object containing the data to be
displayed. Template variables access data from the context and allow
dynamic content generation. You can access variables directly or use dot
notation to navigate through nested objects or dictionaries.
• Template Tags: Template tags provide control flow, logic, and iteration
within the template. They allow you to perform actions such as
conditional rendering, looping, including other templates, and more.
Django provides a variety of built-in template tags, including {% if %}, {%
for %}, {% include %}, {% block %}, and more. You can also create
custom template tags to extend the functionality of the template
system.
• Template Filters: Template filters allow you to modify or format
template variables. Filters are appended to variables using the pipe (|)

17
 character and provide a way to transform values before displaying them.
Django provides a range of built-in filters, including date, length, lower,
capfirst, join, slice, and more. You can also create custom template
filters to suit your specific needs.
• Template Inheritance: Template inheritance allows you to create a base
template that defines the overall structure and layout of a page, and
then inherit from that template to create child templates with specific
content. This promotes code reusability and reduces duplication. Child
templates can override specific blocks defined in the parent template
and fill them with unique content.

Explain Django’s architecture.

Django follows a well-defined architecture known as the Model-View-
Controller (MVC) architectural pattern, or more specifically, the Model-View-
Template (MVT) pattern. This architecture separates the concerns of data
management, user interface, and business logic in a Django web application.
Here's an overview of Django's architecture:
• Model: The model represents the data structure and business logic of
the application. It defines the data schema, relationships between
entities, and operations to manipulate and query the data. In Django,
models are implemented as Python classes that inherit from
django.db.models.Model. They interact with the database through an
Object-Relational Mapping (ORM) layer, which abstracts the database
operations and provides a high-level interface for working with the data.
• View: In the Django architecture, the view handles the logic for
processing user requests and generating responses. The view receives
HTTP requests from clients, interacts with the model layer to fetch or
modify data, and prepares the data to be rendered. Views can be
implemented as Python functions or class-based views. They contain the
application logic and make decisions about what data to retrieve, how to
process it, and which templates to use for rendering.
• Template: Templates in Django are responsible for the presentation and
rendering of data. They provide a way to define the structure, layout,
and appearance of the user interface. Templates combine HTML with
Django's template language, which allows for the inclusion of dynamic
content, looping, conditional statements, and more. Templates access

18
 data passed from views and use it to generate the final HTML output.
Django's template system follows the principle of separating the
presentation logic from the application logic.
• URL Dispatcher: The URL dispatcher maps URLs to appropriate views in
Django. It acts as the central router that receives incoming requests and
directs them to the corresponding views based on the URL patterns
defined in the application's URL configuration. The URL dispatcher uses
regular expressions or simple strings to match incoming URLs and route
them to the appropriate view functions or class-based views.
• Middleware: Middleware plays a crucial role in Django's architecture. It
sits between the web server and the Django application, intercepting
requests and responses. Middleware can perform various tasks such as
authentication, session management, request/response modification,
caching, logging, and more. Django provides a range of built-in
middleware classes and allows you to create custom middleware to add
functionality to the request/response processing pipeline.

Give a brief about the Django admin.

The Django admin is a built-in feature of the Django web framework that
provides a user-friendly interface for managing and administering a Django
project's data. It is a powerful and customizable tool that allows developers
and authorized users to perform various administrative tasks without having to
write additional code. Here's a brief overview of Django admin:
• Automatic CRUD Operations: Django admin automatically generates an
interface for performing Create, Read, Update, and Delete (CRUD)
operations on the project's models. It creates default forms and views
based on the model definitions, allowing administrators to add, edit, and
delete data records easily.
• Model Administration: The Django admin interface provides an
administration panel for each registered model. Administrators can
access and manage model data through these panels. The admin
interface displays the model's fields and allows for sorting, filtering, and
searching capabilities to quickly locate specific records.
• Customization and Configuration: Django admin allows for extensive
customization and configuration to tailor the administrative interface to
the specific needs of the project. Developers can customize the

19
 appearance by providing custom CSS, modify the layout by rearranging
fields, and control the display of fields by specifying fieldsets. They can
also add custom actions, override default templates, and define custom
validation and form handling logic.
• User and Group Permissions: Django admin integrates with Django's
authentication and authorization system, allowing fine-grained control
over user permissions. Developers can define which users or groups
have access to specific models or actions within the admin interface.
Permissions can be set to control read-only access, editing capabilities,
and administrative privileges.
• Inline Editing: Django admin supports inline editing, which allows for
editing related models directly within the parent model's admin page.
Inline editing simplifies the process of managing related records and
allows administrators to make changes more efficiently.

What are the advantages of Django?

Django offers several advantages that make it a popular choice for web
development. Here are some of the key advantages of using Django:
• High-level Web Framework: Django is a high-level web framework that
provides a comprehensive set of tools and libraries for building web
applications. It offers built-in solutions for common web development
tasks such as URL routing, form handling, database integration,
authentication, and more. This high-level nature of Django allows
developers to focus on application logic and business requirements
rather than low-level implementation details.
• Rapid Development: Django's design philosophy emphasizes code
reusability and productivity. It provides a clear and consistent structure
for building web applications, which allows developers to quickly start a
project and iterate on it efficiently. Django's built-in features, such as an
ORM (Object-Relational Mapping), automatic admin interface, and
template system, speed up development by eliminating the need for
repetitive tasks.
• Scalability and Performance: Django is built to handle high-traffic and
high-load environments. It incorporates features like database
connection pooling, query optimization, and efficient caching
mechanisms, which help improve performance and scalability. Django

20
 also supports horizontal scalability by enabling the distribution of
workload across multiple servers.
• Security: Django has built-in security features to protect web
applications from common vulnerabilities. It includes protection against
cross-site scripting (XSS) attacks, cross-site request forgery (CSRF), SQL
injection, and more. Django follows best practices for secure
development, and its security features are regularly updated to address
emerging threats.
• Versatile Database Support: Django supports multiple databases out of
the box, including PostgreSQL, MySQL, SQLite, and Oracle. Its ORM
provides an abstraction layer that allows developers to work with
databases using Python objects and methods. This makes it easier to
switch between different databases and manage database operations
efficiently.

What is the purpose of filtering data in Django?

The purpose of filtering data in Django is to retrieve specific subsets of data
from a database based on certain conditions or criteria. Filtering allows you to
query the database and retrieve only the records that meet the specified
criteria, reducing the amount of data returned and improving efficiency.
Django provides a powerful and flexible filtering system through its Object-
Relational Mapping (ORM) layer. You can filter data using various criteria such
as equality, comparison operators, logical operators, and more. This allows you
to define complex queries and retrieve the data that matches specific
conditions.
Here are some common use cases and benefits of filtering data in Django:
• Retrieve Specific Records: Filtering enables you to retrieve specific
records from a database based on conditions. For example, you can filter
books by their publication year, filter users by their age, or filter orders
by their status. By narrowing down the data to a specific subset, you can
focus on the relevant information and perform further operations on
that subset.
• Efficient Data Retrieval: Filtering reduces the amount of data retrieved
from the database, which improves performance and reduces network
overhead. Instead of fetching all records and filtering them in your

21
 application code, you can let the database handle the filtering operation,
retrieving only the data that matches the specified criteria.
• Dynamic Querying: Filtering in Django allows you to build dynamic
queries based on user input or application requirements. You can
construct queries programmatically by applying filters based on different
conditions. This flexibility allows you to handle various scenarios where
the filtering criteria may change dynamically.
• Complex Querying: Django's filtering system supports complex querying
capabilities. You can combine multiple filter conditions using logical
operators (AND, OR) to create complex queries. This enables you to
express sophisticated requirements and retrieve data that satisfies
multiple criteria.
• Data Integrity and Consistency: By filtering data at the database level,
you ensure that the retrieved data meets specific criteria and adheres to
the defined constraints. This helps maintain data integrity and
consistency in your application.
Explain the following and their role in building the front-end of a
Django project.
To build the front-end of a Django project, you'll typically work with the
following components:
• HTML (Hypertext Markup Language): HTML is the standard markup
language used to structure the content of web pages. It defines the
elements and layout of the web page, such as headings, paragraphs,
lists, tables, forms, and more. Django uses HTML templates to generate
dynamic HTML content that is served to the client.
• CSS (Cascading Style Sheets): CSS is a stylesheet language used to
describe the presentation and styling of HTML elements. It controls the
visual appearance of web pages, including the layout, colors, fonts, and
other visual properties. CSS is used in Django projects to customize the
look and feel of HTML templates.
• JavaScript: JavaScript is a programming language that enables
interactivity and dynamic behavior on web pages. It allows you to
manipulate the HTML structure, handle user events, make asynchronous
requests to the server, and perform other client-side operations.
JavaScript is often used in Django projects to enhance the user
experience by adding interactivity and dynamic features.

22
 • Template Engine: Django provides a powerful template engine that
allows you to create dynamic HTML templates. Templates in Django are
HTML files with embedded template tags and filters that control the
logic and dynamic content rendering. The template engine processes
these templates, substitutes variables with values, executes template
tags and filters, and generates the final HTML that is sent to the client.
• Front-end Frameworks and Libraries: Django can be integrated with
popular front-end frameworks and libraries like Bootstrap, Vue.js, React,
and others. These frameworks provide pre-designed UI components, CSS
styling, and JavaScript functionality that can be used to build the front-
end of a Django project more efficiently. They offer a range of ready-to-
use components, responsive layouts, and interactive features that can
be easily integrated with Django's templates.

Explain the concept of hard-coding the connection parameters

when using database queries in views. What are the potential
drawbacks of this approach?
Hard-coding the connection parameters when using database queries in views
means directly specifying the database connection details (such as hostname,
port, username, password, etc.) within the view code itself. This approach
involves manually embedding the connection parameters within the view's
database query logic without utilizing Django's built-in database configuration
settings.
However, this approach has several potential drawbacks:
• Lack of Flexibility: Hard-coding connection parameters limits the
flexibility and scalability of the application. If the database configuration
needs to be changed (e.g., different database host or credentials), every
occurrence of the hard-coded parameters in the views would have to be
modified manually.
• Code Duplication: Hard-coding connection parameters can lead to code
duplication if the same database connection details are used in multiple
views or across different parts of the application. Any change to the
connection parameters would require updating all the relevant places
where they are hard-coded, resulting in additional effort and potential
errors.

23
 • Security Risks: Embedding sensitive database credentials directly in the
view code can pose security risks. If the codebase is accessible to
unauthorized individuals, they can easily view and misuse the
credentials. It's generally best practice to keep sensitive information
separate from the codebase and utilize secure methods, such as
environment variables or configuration files, to store and retrieve such
information.
• Lack of Portability: Hard-coding connection parameters makes the code
less portable and reusable. If the application needs to be deployed in
different environments (e.g., development, staging, production), each
environment may require different database connection settings. Hard-
coding connection parameters restricts the application's portability and
requires modifying the codebase for each environment.

How to customize the admin templates.

To customize the Django admin templates, you can follow these steps:
• Override the admin template: Django allows you to override specific
admin templates by creating template files with the same name and
relative path in your project's templates directory.
• For example, if you want to customize the change form for a specific
model, you can create a template file named change_form.html inside
the templates/admin/ directory.
• Determine the template to override: To customize a specific admin page,
you need to know the template name that corresponds to that page.
Django's documentation provides a list of default admin templates and
their names. Refer to the documentation to find the template name you
want to customize.
• Create the custom template file: Create a template file in your project's
templates/admin/ directory with the same name as the template you
want to customize.
• For example, to customize the change form for the Book model, create a
file named change_form.html inside templates/admin/. The path
should be templates/admin/change_form.html.
• Customize the template: Open the custom template file and modify its
contents according to your needs. You can add, remove, or modify HTML
elements, template tags, and template variables as required.

24
 • Note: When customizing the templates, be cautious not to remove any
necessary template tags or blocks, as they are essential for the
functionality of the Django admin.
• Repeat for other templates: If you want to customize multiple admin
templates, repeat steps 2 to 4 for each template you wish to modify.

Describe the key components required to deploy a Django project

in a real-time environment.
To deploy a Django project in a real-time environment, you need to consider
several key components. Here's an overview of the important components
required for Django project deployment:
• Web Server: You need a web server to handle incoming HTTP requests
and serve your Django project. Common choices include Apache HTTP
Server, Nginx, or Gunicorn (a Python-based web server). The web server
acts as a reverse proxy, forwarding requests to the appropriate Django
application server.
• Application Server: The application server is responsible for running the
Django project. It handles the execution of Django code, manages
database connections, and serves the application to the web server.
Popular options include Gunicorn, uWSGI, or mod_wsgi (for Apache).
• Database Server: Django supports multiple database backends, including
PostgreSQL, MySQL, SQLite, and others. You'll need to choose a suitable
database server based on your project's requirements and install and
configure it properly. Ensure that the database server is accessible to
your Django application.
• Static and Media Files Storage: In a production environment, it's
recommended to serve static files (CSS, JavaScript, images, etc.) and
media files (user-uploaded files) separately from the Django application
for better performance and scalability. Consider using a dedicated static
file server (e.g., Nginx) or a content delivery network (CDN) to serve
static files efficiently.
• Configuration Management: Use configuration files to manage various
settings specific to your deployment environment. This includes
database connection details, secret keys, debug mode, allowed hosts,
static and media file settings, and more. These configurations should be
kept separate from the codebase and securely managed.

25
What are the considerations for an E-commerce domain
application?
When developing an e-commerce domain application, there are several
important considerations to keep in mind. Here are some key considerations:
• Security: E-commerce applications deal with sensitive user data,
including personal information, payment details, and order history.
Implement robust security measures, such as encryption, secure
authentication, and secure payment gateways, to protect user data from
unauthorized access or breaches.
• Payment Gateway Integration: E-commerce applications require
integration with reliable and secure payment gateways to process
transactions. Research and choose popular payment gateways that
support the required payment methods and comply with industry
standards.
• Inventory Management: An e-commerce application needs to manage
product inventory effectively. Implement features to track stock levels,
handle product variations (sizes, colors), manage product availability,
and update inventory in real-time to prevent overselling.
• Product Catalog and Search: Develop a user-friendly and efficient
product catalog that allows users to browse and search for products
easily. Implement features such as filtering, sorting, categories, and
search functionality to help users find products quickly.
• User Experience and Responsive Design: Focus on creating a seamless
and intuitive user experience. Ensure your application is responsive and
optimized for various devices (desktop, mobile, tablet) to provide a
consistent and user-friendly experience across platforms.

Explain the concept of Cross-Site Request Forgery (CSRF) protection

in Django.
Cross-Site Request Forgery (CSRF) is a type of attack where an attacker tricks a
user's browser into performing an unwanted action on a trusted website
without the user's knowledge or consent. Django provides built-in protection
against CSRF attacks to ensure the security of web applications.

26
Django's CSRF protection works by including a unique token, called the CSRF
token, in every form rendered by the framework. This token is associated with
the user's session and is validated upon form submission. The CSRF token
prevents unauthorized requests by ensuring that the request originated from
the same website and was not forged by a malicious third party.
Here's how Django's CSRF protection works:
• CSRF Token Generation: When a user visits a Django-powered website,
the server generates a unique CSRF token and stores it in the user's
session. This token is typically a random and unpredictable string.
• Token Inclusion in Forms: Django automatically includes the CSRF token
in all forms rendered using the {% csrf_token %} template tag. This
token is added as a hidden input field in the form.

Explain the process of creating a superuser in Django for accessing

the backend admin app. What command is used, and what
information is required?
To create a superuser in Django for accessing the backend admin app, you can
follow these steps:
• Open a terminal or command prompt and navigate to the root directory
of your Django project.
• Activate the virtual environment associated with your Django project if
you're using one.
• Run the following command to create a superuser:
python manage.py createsuperuser
• The command will prompt you to enter the following information:
• Username: Enter the desired username for the superuser. This will be
used to log in to the admin app.
• Email (optional): Provide an email address for the superuser. This is not
required but can be useful for password reset or administrative
purposes.
• Password: Set a strong password for the superuser. The password will be
securely hashed before storage.
• Note: When entering the password, it won't be displayed on the screen
for security reasons. Type it carefully and press Enter.

27
 • After entering the required information, the superuser will be created,
and you will see a message confirming the successful creation.
• Example output:
• Superuser created successfully.
• You can now access the admin app by running your Django development
server (python manage.py runserver) and navigating to the admin URL
(http://localhost:8000/admin/ by default).
• Enter the superuser's username and password to log in and access the
admin app's backend interface.
What is Django's session framework. How do you enable sessions in
Django, and how can you use them in views?
Django's session framework is a built-in feature that allows you to store and
retrieve arbitrary data associated with a specific user across multiple HTTP
requests. It enables stateful behavior in a stateless protocol like HTTP by
utilizing server-side sessions.
To enable sessions in Django, follow these steps:
• Update the Django settings: Open your project's settings file
(settings.py) and ensure the following settings are configured:
• INSTALLED_APPS should include 'django.contrib.sessions' in the list of
installed apps.
• MIDDLEWARE should include
'django.contrib.sessions.middleware.SessionMiddleware' in the list of
middleware classes.
• Save and migrate: Save your changes to the settings file, and if you
haven't already done so, run the following command to apply the
necessary database migrations for sessions:

how can you destroy a session in Django? Describe the process of

destroying a session using the flush method.
In Django, you can destroy a session and remove all associated session data
using the flush() method. The flush() method is available on the
request.session object and allows you to clear the session data and generate a
new session key. Here's the process of destroying a session using the flush()
method:

28
Create a Django model called "Book" with fields for title, author, publication
date and ISBN. Write the necessary code to migrate the model to the database
and ensure it is correctly reflected in the database schema.
from django.db import models

class Book(models.Model):
title = models.CharField(max_length=100)
author = models.CharField(max_length=100)
publication_date = models.DateField()
isbn = models.CharField(max_length=13)

def __str__(self):
return self.title
To migrate the model to the database and ensure it is correctly reflected in the
database schema, follow these steps:
• Make sure you have Django installed and configured in your project.
• In your project's terminal or command prompt, navigate to the project's
root directory (where the manage.py file is located).
• Run the following command to create the initial migration for the
"books" app (assuming you have an app named "books" where the
model resides):
python manage.py makemigrations books
Once the initial migration is created, you can apply it to the database using the
following command:
python manage.py migrate

Create a view that requires authentication, such as a user profile

page. Ensure that only authenticated users can access the
protected view and redirect unauthenticated users to the login
page.
To create a view that requires authentication and redirect unauthenticated
users to the login page, you can use Django's built-in authentication system
and the login_required decorator. Here's an example of how you can
implement a user profile page:
First, make sure you have Django's authentication middleware configured in
your project's settings.py file. Add the following line to the MIDDLEWARE list:
'django.contrib.auth.middleware.AuthenticationMiddleware',

29
Create a new Django view function for the user profile page in one of your
app's views.py file. Here's an example:
from django.contrib.auth.decorators import login_required
from django.shortcuts import render

@login_required(login_url='login') # Redirects unauthenticated users to 'login'

URL
def profile(request):
user = request.user
return render(request, 'profile.html', {'user': user})
In the example above, the login_required decorator is used to wrap the profile
function. This ensures that only authenticated users can access the view. If an
unauthenticated user tries to access the page, they will be redirected to the
login page, which you can specify using the login_url parameter.
Create a template file named profile.html in your app's template directory.
Customize this template to display the user's profile information or any other
desired content.
Finally, define a URL pattern in your app's urls.py file to associate the view
function with a URL. For example:
from django.urls import path
from .views import profile
urlpatterns = [
path('profile/', profile, name='profile'),
]
Now, when a user visits the /profile/ URL, they will be redirected to the login
page if they are not authenticated. After logging in, they will be redirected
back to the profile page, and the request.user object will be available in the
profile view to retrieve the authenticated user's information.

How do you define a URL pattern in Django and associate it

with a view function?
30
In Django, URL patterns are defined in the project's urls.py file, which acts as a
routing configuration for the web application. To associate a URL pattern with
a view function, you need to follow these steps:
• Import the view function you want to associate with the URL pattern.
This function could be defined in your project's views.py file or in any
other module you choose.
from . import views
Define the URL pattern using Django's URL patterns syntax. This involves using
the urlpatterns list and the path() or re_path() function.
urlpatterns = [
path('example/', views.example_view),]
In this example, the URL pattern is defined as example/. Whenever a user visits
a URL that matches this pattern (e.g., http://yourdomain.com/example/),
Django will invoke the example_view function from the views.py module.
Optionally, you can include additional parameters in the URL pattern by using
angle brackets (< >) to capture parts of the URL and pass them as arguments to
the associated view function.
urlpatterns = [
path('example/<int:id>/', views.example_view),]
In this case, the captured id value will be passed as an argument to the
example_view function. For example, visiting
http://yourdomain.com/example/123/ will pass 123 as the id argument to the
view function.

How do you handle form validation and display validation errors in

Django?
In Django, form validation is handled through the use of Django's built-in form
classes. When a user submits a form, Django automatically performs validation
on the submitted data. To handle form validation and display validation errors,
you can follow these steps:
• Define a form class that inherits from django.forms.Form or
django.forms.ModelForm. This class represents the structure and
validation rules for your form.

31
from django import forms
class MyForm(forms.Form):
name = forms.CharField(max_length=100)
email = forms.EmailField()
password = forms.CharField(widget=forms.PasswordInput())
In your view function, instantiate the form class and pass it to the template
context from django.shortcuts import render
def my_view(request):
if request.method == 'POST':
form = MyForm(request.POST)
if form.is_valid():
else:
form = MyForm()
return render(request, 'my_template.html', {'form': form})
Here, the form is instantiated with the submitted data (request.POST) when
the request method is POST. If the form is not valid, the validation errors will
be stored in the form.errors attribute.
In your template, you can access the form and display the validation errors if a
<form method="POST" action="{% url 'my_view' %}">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Submit</button>
</form>
{% if form.errors %}
<div class="error-message">
<ul>
{% for field_errors in form.errors.values %}

32
 {% for error in field_errors %}
<li>{{ error }}</li>
{% endfor %}
{% endfor %}
</ul>
</div>
{% endif %}
The form.as_p template tag renders the form fields as paragraphs. If there are
validation errors (form.errors is not empty), they will be displayed in the <ul>
list within the error-message div.

Implement form validation using Django's built-in form validation

and validation constraints. Add custom validation logic to the form
fields to ensure that certain conditions are met when users submit
the form.
To implement form validation using Django's built-in form validation and add
custom validation logic to form fields, you can follow these steps:
Define a form class that inherits from django.forms.Form or
django.forms.ModelForm and declare the form fields.
from django import forms

class MyForm(forms.Form):
name = forms.CharField(max_length=100)
email = forms.EmailField()
password = forms.CharField(widget=forms.PasswordInput())

def clean_name(self):
# Custom validation logic for the 'name' field
name = self.cleaned_data['name']

33
 # Add your validation logic here
if len(name) < 3:
raise forms.ValidationError("Name must be at least 3 characters long.")
return name
In this example, a custom validation method clean_name() is defined to
validate the 'name' field. If the condition is not met, a ValidationError is raised,
and the error message will be displayed.
In your view function, instantiate the form class and check its validity.
from django.shortcuts import render

def my_view(request):
if request.method == 'POST':
form = MyForm(request.POST)
if form.is_valid():
# Process the valid form data
# ...
else:
form = MyForm()

return render(request, 'my_template.html', {'form': form})

The form.is_valid() method performs the validation on the submitted data. It
automatically triggers the built-in field validations and the custom validation
methods defined in the form class. If the form is not valid, the validation errors
will be available in the form.errors attribute.
In your template, display the form and validation errors.
<form method="POST" action="{% url 'my_view' %}">
{% csrf_token %}
{{ form.as_p }}

34
 <button type="submit">Submit</button>
</form>

{% if form.errors %}
<div class="error-message">
<ul>
{% for field_errors in form.errors.values %}
{% for error in field_errors %}
<li>{{ error }}</li>
{% endfor %}
{% endfor %}
</ul>
</div>
{% endif %}
If the form is not valid, the validation errors will be displayed as before.
By implementing these steps, you can utilize Django's built-in form validation
while adding custom validation logic to specific form fields. The
clean_<field_name>() methods in the form class allow you to perform custom
validations, raising ValidationError when necessary.

35