Interview Questions

The MTV architecture in Django is similar to the MVC (Model-View-Controller) pattern but with different terminology:

• Model: Represents the data layer, defining the structure of the database and interactions with it.
• Template: Represents the presentation layer, defining how data is displayed to the user. Templates are HTML files with placeholders for dynamic content.
• View: Represents the business logic layer, handling requests from the user, querying the model for data, and returning the appropriate template.

To create a new Django project and app, follow these steps:

• Install Django: Ensure Django is installed using pip install django.
• Create a Project: Run django-admin startproject projectname to create a new project.
• Navigate to Project Directory: cd projectname.
• Create an App: Run python manage.py startapp appname to create a new app within the project.
• Include the App: Add the app to the INSTALLED_APPS list in the project's settings.py file.

A Django model is a class that represents a database table. Each attribute of the model class represents a database field.

Example:
from django.db import models

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

    def __str__(self):
        return self.title

In this example, the Book model has three fields: title, author, and publication_date

Django provides a forms framework for handling forms. Here's how you can handle forms:

• Create a Form Class
: Define a form class in forms.py.
• Render the Form
: Render the form in a template.
• Process Form Data
: Handle form submission and validation in a view.

        
Example:
1.Define Form Class:
from django import forms

class ContactForm(forms.Form):
    name = forms.CharField(max_length=100)
    email = forms.EmailField()
    message = forms.CharField(widget=forms.Textarea)



2. Render Form in Template (contact.html):

    {% csrf_token %}
    {{ form.as_p }}
    Submit


3. Process Form Data in View:
from django.shortcuts import render
from .forms import ContactForm

def contact_view(request):
    if request.method == 'POST':
        form = ContactForm(request.POST)
        if form.is_valid():
            # Process form data
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            message = form.cleaned_data['message']
            # Handle data (e.g., save to database, send email)
    else:
        form = ContactForm()

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

To create a new record, you instantiate a model object and call the save() method.

Example:
from myapp.models import Book

# Creating a new book record
new_book = Book(title="The Great Gatsby", author="F. Scott Fitzgerald", publication_date="1925-04-10")
new_book.save()

In this example, a new Book object is created and saved to the database.   

You can retrieve records using the model's objects manager.

Example:
from myapp.models import Book

# Retrieve all books
all_books = Book.objects.all()

# Filter books by a specific author
books_by_author = Book.objects.filter(author="F. Scott Fitzgerald")

In this example, all_books contains all records from the Book model, and books_by_author contains books written by "F. Scott Fitzgerald".
    

To update a record, you retrieve the object, modify its attributes, and then call the save() method.

Example:

from myapp.models import Book
# Retrieve the book to update
book_to_update = Book.objects.get(id=1)

# Update the title
book_to_update.title = "The Great Gatsby (Revised Edition)"

# Save the changes
book_to_update.save()

In this example, the title of the Book with id=1 is updated and saved.    

To delete a record, you retrieve the object and call its delete() method.

Example:
from myapp.models import Book

# Retrieve the book to delete
book_to_delete = Book.objects.get(id=1)

# Delete the book
book_to_delete.delete()

In this example, the Book with id=1 is deleted from the database.

You can use Django's built-in generic class-based views to implement CRUD operations.

Example:
from django.urls import path
from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView
from myapp.models import Book
from myapp.forms import BookForm

class BookListView(ListView):
    model = Book
    template_name = 'book_list.html'

class BookDetailView(DetailView):
    model = Book
    template_name = 'book_detail.html'

class BookCreateView(CreateView):
    model = Book
    form_class = BookForm
    template_name = 'book_form.html'
    success_url = '/books/'

class BookUpdateView(UpdateView):
    model = Book
    form_class = BookForm
    template_name = 'book_form.html'
    success_url = '/books/'

class BookDeleteView(DeleteView):
    model = Book
    template_name = 'book_confirm_delete.html'
    success_url = '/books/'

urlpatterns = [
    path('books/', BookListView.as_view(), name='book-list'),
    path('books//', BookDetailView.as_view(), name='book-detail'),
    path('books/new/', BookCreateView.as_view(), name='book-create'),
    path('books//edit/', BookUpdateView.as_view(), name='book-update'),
    path('books//delete/', BookDeleteView.as_view(), name='book-delete'),
]
In this example:
BookListView displays a list of all books.
BookDetailView displays details of a specific book.
BookCreateView allows creating a new book.
BookUpdateView allows updating an existing book.
BookDeleteView allows deleting a book.
This setup provides a complete CRUD interface for the Book model using class-based views.

Sessions are server-side storage that keep track of user data across requests, while cookies are client-side storage used to store small amounts of data directly on the user's browser. Sessions can store more secure data since it is not exposed to the client, whereas cookies can be accessed and potentially modified by the client.

You can set a cookie using the HttpResponse object’s set_cookie() method.

Example:
from django.http import HttpResponse

def set_cookie_view(request):
    response = HttpResponse("Setting a cookie")
    response.set_cookie('key', 'value', max_age=3600)  # expires in 1 hour
    return response

You can read a cookie from the request object using request.COOKIES.

Example:
def read_cookie_view(request):
    value = request.COOKIES.get('key')
    return HttpResponse(f"The value of the cookie is {value}")

You can delete a cookie by setting its expiration date in the past using delete_cookie().

Example:
def delete_cookie_view(request):
    response = HttpResponse("Deleting a cookie")
    response.delete_cookie('key')
    return response

To make a cookie secure, you can set the secure and httponly flags.

Example:

response.set_cookie('key', 'value', max_age=3600, secure=True, httponly=True)

FBVs are defined as Python functions that accept a request object and return a response object.
CBVs are defined as Python classes, allowing for better reuse and organization through inheritance and mixins.

Example:
from django.shortcuts import render, redirect
from .forms import MyForm

def my_view(request):
    if request.method == 'POST':
        form = MyForm(request.POST)
        if form.is_valid():
            # Process the data
            return redirect('success')
    else:
        form = MyForm()
    return render(request, 'my_template.html', {'form': form})

RedirectView is a CBV that provides a simple way to redirect to a specified URL.

Example:
from django.urls import path
from django.views.generic.base import RedirectView

urlpatterns = [
    path('old-url/', RedirectView.as_view(url='/new-url/', permanent=True)),
]

You can use Django’s Paginator class to implement pagination.

Example:
from django.core.paginator import Paginator
from django.shortcuts import render

def my_view(request):
    object_list = MyModel.objects.all()
    paginator = Paginator(object_list, 10)  # Show 10 items per page
    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    return render(request, 'my_template.html', {'page_obj': page_obj})

Mixins are used to add reusable functionality to CBVs. For example, the LoginRequiredMixin ensures that only authenticated users can access the view.

Example:

from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import ListView
from .models import MyModel

class MyListView(LoginRequiredMixin, ListView):
    model = MyModel
    template_name = 'my_template.html'

URL patterns are defined in the urls.py file using the path() or re_path() functions.

>
Example:

from django.urls import path
from .views import my_view

urlpatterns = [
    path('my-url/', my_view, name='my-view'),
]

Parameters can be passed to a view by defining them in the URL pattern.

Example:

from django.urls import path
from .views import my_view

urlpatterns = [
    path('my-url//', my_view, name='my-view'),
]

The include() function allows you to reference other URL configurations, which helps in organizing URLs in large projects.

Example:

from django.urls import path, include

urlpatterns = [
    path('app/', include('app.urls')),
]

You name URL patterns using the name parameter in the path() function. It is useful for reversing URLs and maintaining consistency when URLs change.
path('my-url/', my_view, name='my-view')

You can reverse a URL using the reverse() function or the {% url %} template tag.

Example:

from django.urls import reverse

url = reverse('my-view')

DTL is a simple yet powerful language for defining the presentation layer in Django applications. It provides syntax for variable interpolation, filters, and control structures.

You display a variable using double curly braces.

Example:

{{ variable_name }}

Filters are applied to variables using the pipe (|) symbol.

Example:

{{ variable_name|lower }}

You use the {% include %} tag to include one template within another.

Example:

{% include 'header.html' %}   

Template inheritance is achieved using the {% extends %} and {% block %} tags.

Example:

<!-- base.html -->
<html>
<head>
<title>{% block title %}My Site{% endblock %}</title>
</head>
<body>
    {% block content %}{% endblock %}
    </body>
    </html>

    <!-- child.html -->
{% extends 'base.html' %}

{% block title %}Home{% endblock %}

{% block content %}
<p>Welcome to my site!</p>
{% endblock %}

You configure email settings in settings.py.

Example:

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = 'smtp.example.com'
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = 'your-email@example.com'
EMAIL_HOST_PASSWORD = 'your-password'

You use the send_mail() function from django.core.mail.

Example:
from django.core.mail import send_mail

send_mail(
    'Subject here',
    'Here is the message.',
    'from@example.com',
    ['to@example.com'],
    fail_silently=False,
)

You use the EmailMessage class and render the HTML template.

Example:
from django.core.mail import EmailMessage
from django.template.loader import render_to_string

subject = 'Subject here'
to = ['to@example.com']
from_email = 'from@example.com'
html_content = render_to_string('email_template.html', {'context': 'value'})
msg = EmailMessage(subject, html_content, from_email, to)
msg.content_subtype = 'html'
msg.send()

You can handle email sending errors using a try-except block.

Example:

from django.core.mail import send_mail
from django.core.mail import BadHeaderError

try:
    send_mail('Subject here', 'Here is the message.', 'from@example.com', ['to@example.com'])
except BadHeaderError:
    return HttpResponse('Invalid header found.')

You can use a task queue like Celery to send emails asynchronously.

Example:

from celery import shared_task
from django.core.mail import send_mail

@shared_task
def send_email_task(subject, message, from_email, recipient_list):
    send_mail(subject, message, from_email, recipient_list)

You handle file uploads using a form with a FileField and process the file in the view.

Example:
Code1
from django import forms

class UploadFileForm(forms.Form):
    file = forms.FileField()

Code2
from django.shortcuts import render
from .forms import UploadFileForm

def upload_file_view(request):
    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        if form.is_valid():
            handle_uploaded_file(request.FILES['file'])
            return HttpResponse('File uploaded successfully')
    else:
        form = UploadFileForm()
    return render(request, 'upload.html', {'form': form})

def handle_uploaded_file(f):
    with open('some/file/name.txt', 'wb+') as destination:
        for chunk in f.chunks():
            destination.write(chunk)

You can add validation logic in the form’s clean_file method.

Example:

from django import forms

class UploadFileForm(forms.Form):
    file = forms.FileField()

    def clean_file(self):
        file = self.cleaned_data.get('file')
        if file.size > 5*1024*1024:
            raise forms.ValidationError('File size must be under 5MB.')
        return file

You use MultipleFileField and handle multiple files in the view.

Example:
Code1
from django import forms

class UploadFileForm(forms.Form):
    files = forms.FileField(widget=forms.ClearableFileInput(attrs={'multiple': True}))

Code2
from django.shortcuts import render
from .forms import UploadFileForm

def upload_files_view(request):
    if request.method == 'POST':
        form = UploadFileForm(request.POST, request.FILES)
        files = request.FILES.getlist('files')
        if form.is_valid():
            for f in files:
                handle_uploaded_file(f)
            return HttpResponse('Files uploaded successfully')
    else:
        form = UploadFileForm()
    return render(request, 'upload.html', {'form': form})

You can customize the upload path using the upload_to parameter in the model field.

Example:

from django.db import models

class Document(models.Model):
    file = models.FileField(upload_to='documents/')

You can create a view to serve the file and use a template link to call the view.

Example:
Python
from django.http import FileResponse
from django.shortcuts import get_object_or_404
from .models import Document

def download_file_view(request, pk):
    document = get_object_or_404(Document, pk=pk)
    return FileResponse(document.file.open(), as_attachment=True)

HTML
Download

You customize the admin interface by creating a model admin class and registering it.

Example:

from django.contrib import admin
from .models import MyModel

class MyModelAdmin(admin.ModelAdmin):
    list_display = ('field1', 'field2')
    search_fields = ('field1',)
    list_filter = ('field2',)

admin.site.register(MyModel, MyModelAdmin)

YYou add a custom action by defining a method in the model admin class and adding it to the actions list.

Example:
from django.contrib import admin
from .models import MyModel

def make_published(modeladmin, request, queryset):
    queryset.update(status='published')

make_published.short_description = "Mark selected items as published"

class MyModelAdmin(admin.ModelAdmin):
    actions = [make_published]

admin.site.register(MyModel, MyModelAdmin)

You create a custom admin view by defining a view function and adding it to the urls property of the admin class.

Example:
from django.contrib import admin
from django.urls import path
from django.http import HttpResponse

class MyAdminSite(admin.AdminSite):
    def get_urls(self):
        urls = super().get_urls()
        custom_urls = [
            path('my-view/', self.admin_view(self.my_view))
        ]
        return custom_urls + urls

    def my_view(self, request):
        return HttpResponse("Hello, this is a custom admin view")

admin_site = MyAdminSite(name='myadmin')

You can add read-only fields by specifying them in the readonly_fields property of the model admin class.

Example:
from django.contrib import admin
from .models import MyModel

class MyModelAdmin(admin.ModelAdmin):
    readonly_fields = ('field1',)

admin.site.register(MyModel, MyModelAdmin)

You can restrict access to the admin interface by ensuring that only staff members or users with specific permissions can log in

Example:

from django.contrib import admin
from django.contrib.auth.models import User

class UserAdmin(admin.ModelAdmin):
    def has_module_permission(self, request):
        return request.user.is_staff

admin.site.unregister(User)
admin.site.register(User, UserAdmin)

Middleware is a way to process requests globally before they reach the view or after the view has processed them.

Example:
# myapp/middleware.py
class CustomMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Code to execute for each request before the view (and later middleware) are called.
        request.custom_attr = 'Custom Value'
        
        response = self.get_response(request)
        
        # Code to execute for each request/response after the view is called.
        
        return response

# settings.py
MIDDLEWARE = [
    # other middleware classes
    'myapp.middleware.CustomMiddleware',
] 

A custom model manager allows you to add extra manager methods to your Django models.

Example:
# myapp/models.py
from django.db import models

class PublishedManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(status='published')

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    status = models.CharField(max_length=10)

    objects = models.Manager()  # The default manager.
    published = PublishedManager()  # Our custom manager.

# Usage in views or shell
published_articles = Article.published.all()

Some strategies include:

• Using select_related and prefetch_related: These methods help reduce the number of database queries by fetching related objects in a single query.
• Avoiding the N+1 query problem: By using the above methods.
• Using database indexing: Adding indexes to fields that are frequently queried can improve performance.
• QuerySet caching: Avoid evaluating the same QuerySet multiple times.
• Raw SQL queries: For complex queries, you can use raw SQL for optimization.

Example:

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

# Usage
books = Book.objects.select_related('author').all()  # Reduces the number of queries.

Django signals allow certain senders to notify a set of receivers when certain actions have taken place.

Example:
# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth.models import User
from .models import Profile

@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.create(user=instance)

# myapp/apps.py
from django.apps import AppConfig

class MyAppConfig(AppConfig):
    name = 'myapp'

    def ready(self):
        import myapp.signals

To handle concurrent writes, Django provides:

• Transactions: Using atomic blocks to ensure that a series of operations are executed as a single transaction.
• Optimistic locking: By manually checking conditions before saving objects.
• Pessimistic locking: By using database-level locks.

Example:

from django.db import transaction
from myapp.models import Account

def transfer_funds(account_from, account_to, amount):
    with transaction.atomic():
        from_account = Account.objects.select_for_update().get(id=account_from)
        to_account = Account.objects.select_for_update().get(id=account_to)

        from_account.balance -= amount
        to_account.balance += amount

        from_account.save()
        to_account.save()

In this example, select_for_update ensures that the accounts are locked until the transaction is complete, preventing concurrent modifications.