Django for Intermediate Users: Django Forms and Class-Based Views

Introduction
Prerequisites
Setup
Django Forms
Creating a Form
Rendering a Form
Handling Form Submission
Class-Based Views
Creating a Class-Based View
Using Class-Based Views
Recap

Introduction

In this tutorial, we will explore Django’s forms and class-based views for intermediate users. We will start by understanding the purpose of Django forms and how to create and render them. Then, we will delve into class-based views, their benefits, and how to create and use them effectively. By the end of this tutorial, you will have a solid understanding of Django forms and class-based views, enabling you to build more advanced web applications with Django.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Python and Django. It is recommended to have Django installed on your machine. If you haven’t installed Django yet, you can do so by running the following command: shell pip install django

Setup

Before we dive into Django forms and class-based views, let’s set up a basic Django project to work with. Open your terminal and follow these steps:

Create a new Django project:
```
 django-admin startproject myproject
```
Navigate to the project directory:
```
 cd myproject
```
Create a new Django app:
```
 python manage.py startapp myapp
```
Register the app in the project’s settings:

Open myproject/settings.py and add 'myapp' to the INSTALLED_APPS list.

Now we are ready to proceed with Django forms.

Django Forms

Django forms provide a convenient way to handle user input, validate it, and interact with databases. They allow you to easily create and render HTML forms with built-in validation and error handling. Django forms can be created using Python classes and can be customized to meet your specific requirements.

Creating a Form

To create a form in Django, you need to define a class that inherits from the django.forms.Form class. This class serves as a blueprint for your form, defining the fields and their properties.

Let’s create a simple form for capturing user information: ```python from django import forms

class UserForm(forms.Form):
    name = forms.CharField(max_length=100)
    email = forms.EmailField()
``` In the example above, we define a `UserForm` class with two fields: `name` and `email`. The `CharField` is used for text input, while the `EmailField` is used for email addresses. You can also specify various attributes for each field, such as `max_length` in the case of `CharField`.

Rendering a Form

To render a form in a template, you can use the `` template tag provided by Django. This tag automatically generates the necessary HTML markup for the form fields based on the form definition.

To render our UserForm in a template, follow these steps:

Open myapp/views.py and import the form:
```
 from myapp.forms import UserForm
```

Create a view function and pass the form to the context:

 def user_form(request):
     form = UserForm()
     return render(request, 'myapp/user_form.html', {'form': form})

Create a template file myapp/user_form.html:
```
	
 <form method="post">
     {% csrf_token %}
     {{ form }}
     <button type="submit">Submit</button>
 </form>
	
```
In the template above, we use the {{ form }} template tag to render the form fields. The {% csrf_token %} tag is used to protect against Cross-Site Request Forgery attacks.

Handling Form Submission

To handle form submission, we need to update our view function. In Django, form data is sent to the server through an HTTP POST request. We can check if the request is a POST request and process the form data accordingly.

Add the following code to your user_form view function: ```python def user_form(request): form = UserForm()

    if request.method == 'POST':
        form = UserForm(request.POST)
        if form.is_valid():
            # Process the form data
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            # Save to the database or perform any other actions
        
    return render(request, 'myapp/user_form.html', {'form': form})
``` In the updated code, we check if the request method is POST. If it is, we pass the `request.POST` data to the form and validate it using the `is_valid()` method. If the form is valid, we can access the cleaned data and perform any necessary actions, such as saving it to the database.

Class-Based Views

Class-based views (CBVs) are an alternative approach to function-based views in Django. CBVs provide a way to organize and reuse code by using class inheritance. They offer various advantages over function-based views, including code reusability, separation of concerns, and easy integration with mixins.

Creating a Class-Based View

To create a class-based view, you need to define a subclass of the appropriate Django class-based view. The subclass should override certain methods to define the desired behavior.

Let’s create a simple class-based view that displays a user form: ```python from django.views import View from django.shortcuts import render

class UserFormView(View):
    template_name = 'myapp/user_form.html'
    form_class = UserForm

    def get(self, request):
        form = self.form_class()
        return render(request, self.template_name, {'form': form})
``` In the example above, we define a `UserFormView` class that extends the `View` class provided by Django. We specify the template and form class to be used. In the `get()` method, we create an instance of the form and pass it to the template context for rendering.

Using Class-Based Views

To use class-based views, we need to map them to URLs in myapp/urls.py. We can do this by using the as_view() method provided by class-based views.

Open myapp/urls.py and update the URL configuration as follows: ```python from django.urls import path from myapp.views import UserFormView

urlpatterns = [
    path('user/form/', UserFormView.as_view(), name='user_form'),
]
``` Now, when you navigate to `/user/form/`, the `UserFormView` class-based view will be instantiated and its `get()` method will be called.

Recap

In this tutorial, we covered Django forms and class-based views. We learned how to create a form using the django.forms.Form class, render it in a template, and handle form submission. We also explored class-based views as an alternative approach to function-based views and saw how to create and use them effectively.

By mastering Django forms and class-based views, you can build more advanced web applications with Django, handling user input and processing it in a structured and efficient manner.

Remember to practice what you have learned and refer to the Django documentation and examples to further improve your understanding and skills in Django development.

Happy coding!

Published: 20 April 2020