[Python]_Django Web Development Practice (Detailed Tutorial)

A comprehensive introduction to Python Django

Django is a very powerful Python Web development framework designed for “rapid development” and “clean, functional design”. This article will start with the basic concepts of Django and lead you to understand how to use Django to build complex web applications.

Django Basic Concepts and Principles

First, let’s start with Django’s core components. Django follows the MVC Model-View-Controller design pattern and has a special manifestation in Python called MTV Model-Template-View. This is because the controller part of Django is handled internally by the framework itself, while the developer primarily interacts with models, templates, and views.

# Sample code：CreateDjangoModel  
from django.db import models  

class Blog(models.Model):  
    title = models.CharField(max_length=200)  
    content = models.TextField()  

    def __str__(self):  
        return self.title 

In the above code, we defined a simple blog model with two fields, title and content. Where CharField and TextField are the database field types provided by Django.

View and URL configuration for Django

In Django, views are Python functions that receive Web requests and return Web responses. Each view function takes an HttpRequest object as a parameter and returns an HttpResponse object. The view is associated with the URLs of the Web application, and this is done through the URL configuration.

# Sample code：Create a view  
from django.http import HttpResponse  
from .models import Blog  

def blog_index(request):  
    blogs = Blog.objects.all()  
    output = ', '.join([blog.title for blog in blogs])  
    return HttpResponse(output)  

# Sample code：URLConfiguration  
from django.urls import path  

from . import views  

urlpatterns = [  
    path('blogs/', views.blog_index, name='blog_index'),  
] 

In the above code, we first define a view blog_index that fetches all blog entries from the database and displays their titles. We then create a new URL path’blogs/ ‘in the URL configuration to associate it with the blog_index view.

Django templates

Django’s template system allows us to create dynamic HTML pages. Django templates use their own language and are a small subset of Python.

<!-- Sample code：Create a template -->  
{% for blog in blogs %}  
    <h2>{{ blog.title }}</h2>  
    <p>{{ blog.content }}</p>  
{% endfor %} 

In the above code, we created a template that receives a list of blog objects and generates an HTML paragraph for each object.

Django Middleware

Django also has a very powerful feature called middleware. Django’s middleware is a lightweight, low-level “plug-in” system for globally changing Django’s input or output.

The following is an example showing how to create a simple middleware that records the processing time of each request.

# Sample code：Create a middleware  
import time  
from django.http import HttpResponse  

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

    def __call__(self, request):  
        start_time = time.time()  
        response = self.get_response(request)  
        end_time = time.time()  
        response['X-Elapsed-Time'] = str(end_time - start_time)  
        return response 

In the above code, we created a TimingMiddleware middleware that calculates the processing time of the request on each request and adds a X-Elapsed-Time field in the HTTP response header to display this time.

Database Migration for Django

Database migration is a very powerful feature in Django that allows us to change the structure of the database without losing data. Let’s look at an example.

# existmodels.pymiddle，we willBlogThe model is modified as follows：  
class Blog(models.Model):  
    title = models.CharField(max_length=200)  
    content = models.TextField()  
    author = models.CharField(max_length=100) #New fields  

    def __str__(self):  
        return self.title 

In the above code, we added a author new field to the Blog model. To apply this change to the database, we need to do a database migration.

# Run the following command to generate the migration file  
python manage.py makemigrations  

# Run the following command to apply the migration  
python manage.py migrate 

With the above command, Django automatically adds a new field to the database for the Blog model, rather than requiring us to manually modify the database.

Django Forms and Validation

Django’s form functionality makes it easier for us to receive and process user data. At the same time, Django also provides a variety of verification functions to help us verify the validity of user data.

# Sample code：Create a form  
from django import forms  
from .models import Blog  

class BlogForm(forms.ModelForm):  
    class Meta:  
        model = Blog  
        fields = ['title', 'content', 'author']  

# Use forms in views  
def new_blog(request):  
    if request.method == 'POST':  
        form = BlogForm(request.POST)  
        if form.is_valid():  
            form.save()  
            return HttpResponse('Blog saved.')  
    else:  
        form = BlogForm()  

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

In the above code, we created a form based on the Blog model and then used the form in the new_blog view. When the view receives a POST request, it validates the form data and, if the data is valid, saves the new blog and returns a response.

Django Rest Framework (DRF)

The Django Rest Framework is a powerful tool for building Web APIs. Using DRF, we can quickly create RESTful APIs.

# Sample code：CreateAPIview  
from rest_framework import generics  
from .models import Blog  
from .serializers import BlogSerializer  

class BlogListCreate(generic.ListCreateAPIView):  
    queryset = Blog.objects.all()  
    serializer_class = BlogSerializer 

In the above code, we use the DRF’s ListCreateAPIView view, which handles GET and POST requests. We need to provide one queryset and one serializer_class, and the DRF automatically handles the request and the response.

One More Thing

Finally, we’ll cover Django’s Signals. Signals are an event-driven mechanism in Django that sends a signal when something happens, and we can write receivers to listen for these signals.

# Sample code：Create a signal receiver  
from django.db.models.signals import post_save  
from django.dispatch import receiver  
from .models import Blog  

@receiver(post_save, sender=Blog)  
def notify_admin(sender, instance, created, **kwargs):  
    if created:  
        print(f'New blog created: {instance.title}') 

In the above code, we have created a receiver notify_admin that will be called each time a new Blog object is created. Signals allow us to write decoupled code, making our applications easier to maintain and extend.