ATRIA INSTITUTE OF TECHNOLOGY

Anandanagar, Bengaluru – 560 024

Module I & 2- Question Bank

Subject: Full Stack Development Sem: VI Subject code : 21CS62

1. What is Django Framework? Explain with MVT & MVC?

ANS: Django is a high-level web framework for Python that follows the MVC pattern. It provides a robust set of
features for building web applications, including an ORM, URL routing, form handling, session management, and a
built-in admin interface.

MVT:
 2. Discuss Evolution of Django with documentary?
ANS:
 3. Explain about Django Core Exceptions?
ANS:
4. Define Following Terms:
Web framework
Views
Patterns
URL’s
Path
5. Write steps of Python Installation &Django Installation with Commands?
6. Discuss Features of Django in detail?
7. Develop a Django Program to display current Date & Time?
8. Explain in detail about MVT Structure with example?
9. Explain different types of Django Errors?
10. Develop a Django app that displays date and time four hours ahead and four hours before as an offset of
current date and time in server.
 11. How Django Processes a Request? Explain with a neat diagram
How Django Processes a Request
Before continuing to our second view function, let’s pause to learn a little more about how Django
works. Specifically, when you view your “Hello world” message by visiting http://127.0.0.1:8000/hello/ in
your web browser, what does Django do behind the scenes?
It all starts with the settings file. When you run python manage.py runserver, the script looks for a file
called settings.py in the inner mysite directory. This file contains all sorts of configuration for this
particular Django project, all in uppercase: TEMPLATES, DATABASES, etc.

The most important setting is called ROOT_URLCONF. ROOT_URLCONF tells Django which Python
module should be used as the URLconf for this web site. Remember when django-admin startproject
created the files settings.py and urls.py? The auto-generated settings.py contains a ROOT_URLCONF
setting that points to the auto-generated urls.py. Open the settings.py file and see for yourself; it
should look like this:

ROOT_URLCONF = 'mysite.urls'

This corresponds to the file mysite/urls.py. When a request comes in for a particular URL – say, a
request for /hello/ – Django loads the URLconf pointed to by the ROOT_URLCONF setting. Then it
checks each of the URLpatterns in that URLconf, in order, comparing the requested URL with the
patterns one at a time, until it finds one that matches.

When it finds one that matches, it calls the view function associated with that pattern, passing it an
HttpRequest object as the first parameter. (We’ll cover the specifics of HttpRequest later.) As we saw in
our first view example, a view function must return an HttpResponse.

Once it does this, Django does the rest, converting the Python object to a proper web response with
the appropriate HTTP headers and body (i.e., the content of the web page). In summary:

• A request comes in to /hello/.

• Django determines the root URLconf by looking at the ROOT_URLCONF setting.
• Django looks at all of the URLpatterns in the URLconf for the first one that matches /hello/.
• If it finds a match, it calls the associated view function.
• The view function returns an HttpResponse.
• Django converts the HttpResponse to the proper HTTP response, which results in a web page.

You now know the basics of how to make Django-powered pages. It’s quite simple, really – just write
view functions and map them to URLs via URLconfs.

How Django Processes a Request – In addition to the straightforward URL-to-view mapping just
described, Django provides quite a bit of flexibility in processing requests.

The typical flow—URLconf resolution to a view function which returns an HttpResponse—can be short-
circuited or augmented via middleware.
Figure : The complete flow of a Django request and response.

When an HTTP request comes in from the browser, a server-specific handler constructs the
HttpRequest passed to later components and handles the flow of the response processing.

The handler then calls any available Request or View middleware. These types of middleware are
useful for augmenting incoming HttpRequest objects as well as providing special handling for specific
types of requests. If either returns an HttpResponse, processing bypasses the view.

Bugs slip by even the best programmers, but exception middleware can help squash them. If a view
function raises an exception, control passes to the Exception middleware. If this middleware does not
return an HttpResponse, the exception is re-raised. Even then, all is not lost. Django includes default
views that create a friendly 404 and 500 response. Finally, response middleware is good for post-
processing an HttpResponse just before it’s sent to the browser or doing cleanup of request-specific
resources.

12. How Django setting up a database.

13. How to Create Project and App in Django
14. How to map URLs to View.
15. Explain Template Tags with an example. ?
16. Develop a layout.html with a suitable header (containing navigation menu) and footer with copyright and
developer information. Inherit this layout.html and create 3 additional pages: contact us, About Us and
Home page of any website.
17. Explain Filters with an example.
 18. Develop a simple Django app that displays an unordered list of cars and ordered list of participants for an
event
Sure, here's a simple Django app that displays an unordered list of cars and an ordered list of participants for an
event:

```python
# models.py
from django.db import models

class Car(models.Model):
name = models.CharField(max_length=200)

def __str__(self):
return self.name

class Participant(models.Model):
name = models.CharField(max_length=200)

def __str__(self):
return self.name
```

```html
<!-- cars_list.html -->
<!DOCTYPE html>
<html>
<head>
<title>Cars List</title>
</head>
<body>
<h1>Cars List</h1>
<ul>
{% for car in cars %}
<li>{{ car.name }}</li>
{% endfor %}
</ul>
</body>
</html>
```

```html
<!-- participants_list.html -->
<!DOCTYPE html>
<html>
<head>
<title>Participants List</title>
</head>
<body>
<h1>Participants List</h1>
<ol>
{% for participant in participants %}
<li>{{ participant.name }}</li>
{% endfor %}
</ol>
</body>
</html>
```

```python
# views.py
from django.shortcuts import render
from .models import Car, Participant

def cars_list(request):
cars = Car.objects.all()
return render(request, 'cars_list.html', {'cars': cars})

def participants_list(request):
participants = Participant.objects.all()
return render(request, 'participants_list.html', {'participants': participants})
```

```python
# urls.py
from django.urls import path
from . import views

urlpatterns = [
path('cars/', views.cars_list, name='cars_list'),
path('participants/', views.participants_list, name='participants_list'),
]
19. Develop a Django program to welcome the participant to ‘Saptharang 2024’ with date and time, and print
excellent if student attending at least four events and student phone number and the list of the events of
‘Sapthrang’
Sure, here's a Django program that welcomes the participant to 'Saptharang 2024' with the date and time, prints
'excellent' if the student is attending at least four events, displays the student's phone number, and lists the
events of 'Saptharang':

```python
# models.py
from django.db import models
from django.utils import timezone

class Event(models.Model):
name = models.CharField(max_length=200)

def __str__(self):
return self.name

class Student(models.Model):
name = models.CharField(max_length=200)
phone_number = models.CharField(max_length=20)
events = models.ManyToManyField(Event, related_name='students')

def __str__(self):
return self.name
```

```html
<!-- student_detail.html -->
<!DOCTYPE html>
<html>
<head>
<title>Student Details</title>
</head>
<body>
<h1>Welcome to Saptharang 2024</h1>
<p>Date and Time: {{ now }}</p>

<h2>Student Details</h2>
<p>Name: {{ student.name }}</p>
<p>Phone Number: {{ student.phone_number }}</p>

{% if student.events.count >= 4 %}
<p>Excellent! You are attending at least four events.</p>
{% endif %}
 <h2>Events of Saptharang</h2>
<ul>
{% for event in events %}
<li>{{ event.name }}</li>
{% endfor %}
</ul>
</body>
</html>
```

```python
# views.py
from django.shortcuts import render, get_object_or_404
from django.utils import timezone
from .models import Student, Event

def student_detail(request, student_id):

student = get_object_or_404(Student, pk=student_id)
events = Event.objects.all()
now = timezone.now()
return render(request, 'student_detail.html', {'student': student, 'events': events, 'now': now})
```

```python
# urls.py
from django.urls import path
from . import views

urlpatterns = [
path('student/<int:student_id>/', views.student_detail, name='student_detail'),
]
20. Discuss the role of regular expressions in the framing of URLs
Regular expressions play a crucial role in the framing and matching of URLs in web frameworks like Django. They
provide a powerful and flexible way to define URL patterns, allowing developers to create dynamic and complex
routes that can handle various input formats. Here’s a detailed discussion of their role:

### Role of Regular Expressions in URL Framing

1. **Pattern Matching**:
- Regular expressions (regex) allow precise matching of URL patterns, enabling the routing system to identify
which view should handle a particular URL.
- For example, a regex can differentiate between URLs like `/article/123/` and `/article/archive/2024/`.

2. **Dynamic Segments**:
- Regular expressions can capture parts of the URL as variables that can be passed to the view. This allows for
dynamic URL segments, such as user IDs or article slugs.
- Example: In Django, a URL pattern like `r'^article/(?P<article_id>[0-9]+)/$'` uses regex to capture the article ID
and pass it to the view.

3. **Validation**:
- Regular expressions can ensure that URL parameters meet specific criteria before passing them to the view. For
example, you can ensure that a date in the URL is in the correct format.
 - Example: `r'^date/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$'` ensures that the URL
contains a valid year, month, and day.

4. **Flexibility**:
- Regex provides flexibility to match a wide variety of URL patterns without having to write multiple explicit
rules. This reduces redundancy and simplifies the URL configuration.
- Example: `r'^blog/(?P<slug>[-\w]+)/$'` can match slugs with letters, numbers, hyphens, and underscores.

5. **Optional Parameters**:
- Regular expressions can be used to define optional URL parameters, allowing for more flexible URL structures.
- Example: `r'^page/(?P<page_number>[0-9]+)?/$'` can match both `/page/` and `/page/1/`.

6. **Grouping and Alternation**:

- Regex supports grouping and alternation, making it possible to match multiple patterns with a single regex. This
is useful for creating concise and powerful URL patterns.
- Example: `r'^(?P<username>[\w-]+)/(?P<action>follow|unfollow)/$'` matches both follow and unfollow actions
for a username.

### Example in Django

Here’s an example illustrating the use of regular expressions in Django URL routing:

1. **Define URL Patterns Using Regex**:

- In Django, you can use the `re_path` function to define URL patterns with regular expressions.

```python
from django.urls import re_path
from . import views

urlpatterns = [
re_path(r'^article/(?P<article_id>[0-9]+)/$', views.article_detail, name='article_detail'),
re_path(r'^user/(?P<username>[\w-]+)/(?P<action>follow|unfollow)/$', views.user_action, name='user_action'),
]
```

2. **Views Handling the URLs**:

- In your views, you can handle the captured parameters.

```python
from django.http import HttpResponse

def article_detail(request, article_id):

return HttpResponse(f"Article ID: {article_id}")

def user_action(request, username, action):

return HttpResponse(f"User: {username} Action: {action}")
```
21. Explain Filters and variable with an example program to print the details of staff like ID, Name, Username,
email, today’s date and time.
In Django, templates use filters and variables to process and display data. Filters allow you to modify the value of
variables before rendering them. Here, I'll explain filters and variables, and provide an example program to print
the details of staff members, including ID, Name, Username, email, and today's date and time.

### Filters in Django Templates

Filters are used to modify variables for display. They are applied using the pipe (`|`) character. Some common
filters include `date`, `time`, `lower`, `upper`, and `length`.

### Variables in Django Templates

Variables in Django templates are placeholders that get replaced with actual values when the template is rendered.
They are enclosed within double curly braces `{{ }}`.

### Example Program

Let's create a Django app that displays the details of staff members.

#### Step 1: Set Up the Project and App

1. **Create a Django Project**:

```sh
django-admin startproject myproject
cd myproject
```

2. **Create a Django App**:

```sh
python manage.py startapp staff
```

3. **Add the App to `INSTALLED_APPS` in `settings.py`**:

```python
# myproject/settings.py
INSTALLED_APPS = [
...,
'staff',
]
```

#### Step 2: Define Models

**`staff/models.py`**:
```python
from django.db import models
from django.contrib.auth.models import User

class Staff(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE)
staff_id = models.AutoField(primary_key=True)

def __str__(self):
return self.user.username
```

#### Step 3: Register Models in Admin

**`staff/admin.py`**:
```python
from django.contrib import admin
from .models import Staff

admin.site.register(Staff)
```

#### Step 4: Create Views

**`staff/views.py`**:
```python
from django.shortcuts import render
from .models import Staff
from datetime import datetime

def staff_details(request):
staff_list = Staff.objects.all()
current_datetime = datetime.now()
return render(request, 'staff_details.html', {'staff_list': staff_list, 'current_datetime': current_datetime})
```

#### Step 5: Add URL Patterns

**`staff/urls.py`**:
```python
from django.urls import path
from .views import staff_details

urlpatterns = [
path('details/', staff_details, name='staff_details'),
]
```

**`myproject/urls.py`**:
```python
from django.contrib import admin
from django.urls import include, path

urlpatterns = [
path('admin/', admin.site.urls),
path('staff/', include('staff.urls')),
]
```

#### Step 6: Create Template

**`staff/templates/staff_details.html`**:
```html
<!DOCTYPE html>
<html>
<head>
<title>Staff Details</title>
</head>
<body>
<h1>Staff Details</h1>
<p>Today's Date and Time: {{ current_datetime|date:"Y-m-d H:i:s" }}</p>
<table border="1">
<thead>
<tr>
<th>ID</th>
<th>Name</th>
<th>Username</th>
<th>Email</th>
</tr>
</thead>
<tbody>
{% for staff in staff_list %}
<tr>
<td>{{ staff.staff_id }}</td>
<td>{{ staff.user.get_full_name }}</td>
<td>{{ staff.user.username }}</td>
<td>{{ staff.user.email }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</body>
</html>
```

#### Step 7: Add Sample Data

1. **Run Migrations**:
```sh
python manage.py makemigrations
python manage.py migrate
```

2. **Create a Superuser and Add Staff Members via Admin Interface**:

```sh
python manage.py createsuperuser
```

- Log in to the admin interface at `http://127.0.0.1:8000/admin/` and add staff members.

#### Step 8: Run the Development Server

1. **Start the Server**:

```sh
 python manage.py runserver
```

2. **Access the App**:

- Open your web browser and navigate to `http://127.0.0.1:8000/staff/details/`.
- You should see the details of staff members, including ID, Name, Username, email, and today's date and time.

### Summary

- **Variables**: Used in templates to display data, enclosed in `{{ }}`.

- **Filters**: Modify the display of variables, applied using `|`.

The provided code sets up a Django project to display staff details, demonstrating the use of variables and filters in
Django templates.
22. Contrast the URL Mapping and Views
URL mapping and views are essential components of a web framework like Django. They work together to handle
incoming requests and generate appropriate responses, but they serve different purposes and have distinct roles.

### URL Mapping

URL mapping, often handled through URL patterns, is responsible for mapping incoming URLs to the appropriate
views or handlers. It defines the structure of your application's URLs and determines which view function should be
invoked to handle a particular URL.

- **Definition**: URL mapping involves defining URL patterns in a configuration file (e.g., `urls.py` in Django).
- **Responsibility**: URL mapping decides how incoming requests are routed within the application.
- **Usage**: URLs are matched against patterns defined in the URL configuration, and if a match is found, the
corresponding view function is called.
- **Example (Django)**: In Django, URL mapping is typically done in the `urls.py` file of each app. For example:

```python
from django.urls import path
from . import views

urlpatterns = [
path('home/', views.home_view, name='home'),
path('about/', views.about_view, name='about'),
]
```

### Views

Views are Python functions or classes that process incoming requests and return appropriate responses. They contain
the business logic of your application, fetching data from the database, processing it, and rendering templates to
generate the final output.

- **Definition**: Views are functions or classes that handle requests and generate responses.
- **Responsibility**: Views encapsulate the application logic, including data retrieval, processing, and rendering.
- **Usage**: Views are invoked by the URL mapper when a matching URL pattern is found. They perform the
necessary actions and return an HTTP response.
- **Example (Django)**: In Django, views are Python functions or classes defined in `views.py`. For example:

```python
from django.shortcuts import render
from django.http import HttpResponse
 def home_view(request):
return HttpResponse("Welcome to the home page")

def about_view(request):
return render(request, 'about.html')
```

### Contrast

1. **Responsibility**:
- URL mapping determines how URLs are mapped to views, handling the routing of requests within the
application.
- Views contain the application logic, processing requests, fetching data, and generating responses.

2. **Implementation**:
- URL mapping involves defining URL patterns in configuration files (e.g., `urls.py`).
- Views are implemented as Python functions or classes in `views.py`.

3. **Usage**:
- URL mapping is used to define the structure of URLs and route requests to the appropriate views.
- Views are invoked by the URL mapper to handle requests and generate responses.

4. **Abstraction Level**:
- URL mapping deals with the routing and organization of URLs at a higher level.
- Views handle the application-specific logic and processing at a lower level.
23. Define Loose coupling. Explain how it is achieved ?