Python Django Interview Questions

Django's admin interface provides a web interface for managing your site's data. To use it:

1. Ensure your app is included in INSTALLED_APPS in settings.py.
2. Run

   python manage.py createsuperuser

   to create an admin user.
3. Run your server with

   python manage.py runserver

   .
4. Access /admin/ in your browser and log in with the superuser credentials.

Once logged in, you can manage models registered in the admin interface. For instance, if you have a Blog model, it will show up in the admin dashboard for easy management.

Django Rest Framework (DRF) is a powerful toolkit for building Web APIs in Django. It simplifies the process of creating RESTful APIs by providing features like serialization, authentication, and viewsets. Here's how to get started:

1. Install DRF using

   pip install djangorestframework

   .
2. Add 'rest_framework' to your INSTALLED_APPS in settings.py.
3. Create serializers for your models to convert querysets into JSON.

For example, if you have a Post model, your serializer might look like this:

from rest_framework import serializers
class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = '__all__'

DRF allows you to quickly expose your Django models as APIs.

Custom middleware in Django is a way to process requests globally before they reach the view or after the view has processed them. To create custom middleware:

1. Create a new Python file for your middleware.
2. Define a class with __init__ and __call__ methods or specific middleware methods like process_request.
3. Add your middleware class to the MIDDLEWARE setting in settings.py.

Example:

class SimpleMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Code to execute for each request before the view
        response = self.get_response(request)
        return response

This middleware can be used for logging or modifying requests/responses.

Django signals allow certain senders to notify a set of receivers when certain actions have taken place. This is useful for decoupling applications. Here’s how to use signals:

1. Import the necessary modules from django.dispatch.
2. Define a receiver function to handle the signal.
3. Connect the receiver to a signal using the connect method.

Example:

from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=MyModel)
def my_handler(sender, instance, **kwargs):
    print('Model saved!')

This function runs every time an instance of MyModel is saved.

Deploying a Django application involves several steps to ensure it runs smoothly in a production environment. Here’s a basic guide:

1. Choose a hosting service (e.g., Heroku, AWS).
2. Set up a production database (e.g., PostgreSQL).
3. Update settings.py for production (e.g., DEBUG = False).
4. Use a WSGI server like Gunicorn to serve your app.

For instance, to deploy on Heroku, you would:

heroku create
heroku addons:create heroku-postgresql
git push heroku master

This pushes your code to Heroku and sets up the database.

Django models are Python classes that define the structure of your database tables. They serve as the bridge between your application and the database, allowing you to create, retrieve, update, and delete records easily.

To define a model, you create a Python class that inherits from django.db.models.Model. Each attribute of the class represents a database field. For example:

from django.db import models

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

In this example, the Book model has three fields: title, author, and published_date. After defining your model, you can create a migration with python manage.py makemigrations and apply it with python manage.py migrate.

Custom template filters in Django allow you to modify template variables before rendering them. This feature enhances the presentation of data in templates.

To create a custom filter, follow these steps:

1. Create a new file in your app directory, typically named templatetags/my_filters.py.
2. Define a function that takes the input and returns the modified output.
3. Register the function as a template filter using @register.filter.

Here’s an example of a custom filter that converts text to uppercase:

from django import template

register = template.Library()

@register.filter
def to_uppercase(value):
    return value.upper()

After defining the filter, you can use it in your templates like this: {{ my_text|to_uppercase }}.