Django’s Forms - Python Django Tutorials

Django’s Forms

HTML forms are a core component of modern websites. From Google’s simple search box to large, multi-page submissions, HTML forms are the primary means of collecting information from website visitors and users.

The code for a basic HTML form is simple, for example:

<form>
    <p>First Name: <input type="text" name="firstname"></p>
    <p>Last Name: <input type="text" name="lastname"></p>
    <p><input type="submit" value="Submit"></p>
</form>

The <form></form> HTML tags define the form element, and each of the form fields are contained within the form element. In this form, I have defined two text fields and a submit button. In HTML5, there are many other field element types, including email fields, date and time fields, checkboxes, radio buttons and more. I have rendered the form elements as paragraphs in this example, but it’s also common to render forms as an ordered or unordered list, or as a table with the fields filling out the rows of the table. If you were to render this form in a webpage, it would look like Figure 8-1.

Figure 8-1: A simple HTML form.

While creating a basic form is simple, things get more complicated once you need to use the form in a real-life situation. In a live website, you must validate the data submitted with the form. If the field is required, you must check that the field isn’t blank. If the field isn’t blank, you need to check if the data submitted is the valid data type. For example, if you are requesting an email address, you must check that a valid email address is entered.

You must also ensure your form deals with entered data safely. A common way hackers target a website is to submit malicious program code via forms to attempt to hack into the site.

To complicate matters further, website users expect feedback when they haven’t filled out a form correctly. So, you must also have some way of displaying errors on the form for the user to correct before allowing them to submit the form.

Creating forms, validating data and providing feedback is a tedious process if you code it all by hand. Django is flexible in its approach to form creation and management—if you want to design your forms from scratch like this, Django doesn’t do a lot to get in your way.

However, I don’t recommend you do this. Unless you have a special application in mind, Django has many tools and libraries that make form building much easier. In particular, Django’s Form class offers a very convenient set of class methods to take care of most of the form processing and validation for you.

With the Form class, you create a special class that looks a lot like a Django model. Form class fields have built-in validation, depending on the field type, and an associated HTML widget.

Let’s explore the Form class further with the Django interactive shell. From within your virtual environment, run the command:

(env_myclub) ...\myclub_root> python manage.py shell

Once the shell is running, create your SimpleForm class:

1  >>> from django import forms
2  >>> class SimpleForm(forms.Form):
3  ...     firstname = forms.CharField(max_length=100)
4  ...     lastname = forms.CharField(max_length=100)
5  ...
6  >>>

Let’s have a look at what we did here:

  • Line 1. To use the Form class, we need to import the forms module from Django.
  • Line 2. We create our SimpleForm class, which inherits from Django’s forms.Form class.
  • Lines 3 and 4 are the firstname and lastname fields from our simple HTML form. Notice that the field declarations are almost identical to Django’s model field declarations.

This is the first big plus for Django’s Form class—you don’t have to remember a new syntax for declaring form fields. But it gets better. Let’s go back to the shell:

1  >>> f = SimpleForm()
2  >>> print(f.as_p())
<p><label for="id_firstname">Firstname:</label> <input type="text" name="firstname" maxlength="100" required id="id_firstname"></p>
<p><label for="id_lastname">Lastname:</label> <input type="text" name="lastname" maxlength="100" required id="id_lastname"></p>
>>>

Let’s see what’s happening here:

  • Line 1 should be easy enough to follow—we have created an instance of the SimpleForm class and named the instance f.
  • Line 2 is where the Django magic happens. as_p() is a class method that formats the form as paragraphs. You can see by the output that Django has created your form elements for you without you having to write a single HTML tag!

Django doesn’t just output HTML paragraphs—you can also get Django to output HTML for displaying your form as a list or a table. Try these out for yourself:

>>> print(f.as_ul())
>>> print(f.as_table())

Note Django doesn’t generate the <form></form> element for you, nor does it generate the <ul></ul> or <table></table> elements or the submit button. This is because they are structural elements on your page, so they should remain in the template.

Django’s Form class also handles validation for you. Let’s go back to the shell to try this out:

1 >>> f = SimpleForm({})
2 >>> f.is_valid()
3 False
4 >>> f.errors
{'firstname': ['This field is required.'], 'lastname': ['This field is required.']}

Reviewing what we did this time:

  • Line 1. We created a new instance of the SimpleForm class and passed an empty dictionary ({}) to the form.
  • Line 2. When Django created the Form class, it made firstname and lastname required by default, so when we run the is_valid() method on the empty form, it returns False.
  • Line 4. Finally, if form validation fails, Django will create a dictionary of error messages. We can access this dictionary via the errors attribute of the Form class.

One other time-saving feature of the Form class is, when a form doesn’t validate, Django re-renders the form with the error messages added. Let’s try this out in the shell:

>>> print(f.as_p())
<ul class="errorlist"><li>This field is required.</li></ul>
<p><label for="id_firstname">Firstname:</label> <input type="text" name="firstname" maxlength="100" required id="id_firstname"></p>
<ul class="errorlist"><li>This field is required.</li></ul>
<p><label for="id_lastname">Lastname:</label> <input type="text" name="lastname" maxlength="100" required id="id_lastname"></p>
>>>

You can see Django added the errors to the form as unordered lists. If you were to render this form in your browser, it would look something like Figure 8-2.

Figure 8-2: Django’s Form class renders the error messages to the form automatically.

Now we’ve had a look at how Django’s Form class works, let’s create our first form for the website. We will start with a simple form common to most websites—a contact form.

Creating a Contact Form

To create our ContactForm class, we first create a new file called contact.py. As the contact form is a part of the website, we will add it to the site app (new file):

# myclub_root\myclub_site\contact.py

1 from django import forms
2 
3 class ContactForm(forms.Form):
4     yourname = forms.CharField(max_length=100, label='Your Name')
5     email = forms.EmailField(required=False, label='Your Email Address')
6     subject = forms.CharField(max_length=100)
7     message = forms.CharField(widget=forms.Textarea)

This is like the SimpleForm class we created in the shell, with some differences:

  • Line 4. If you don’t specify the label attribute, Django uses the field name for the field label. We want the label for the yourname field to be more readable, so we set the label attribute to “Your Name”.
  • Line 5. We don’t want the email address to be a required field, so we set the required attribute to False, so the person submitting the form can leave the email field blank. We are also changing the default label of the email field to “Your e-mail address”.
  • Line 7. The message field must allow the person submitting the form to enter a detailed message, so we are setting the field widget to a Textarea, replacing the default TextInput widget.

Now we have created our ContactForm class, we have a few tasks to complete to get it to render on our website:

  1. Add our form to the site URLs;
  2. Add navigation to our site template;
  3. Create a template for the contact form; and
  4. Create a new view to manage the contact form.

Add Contact Form URL to Site App

To show our contact form, we start by creating a URL for it. To do that, we need to modify our site’s urls.py file (changes in bold):

# myclub_root\myclub_site\urls.py

1 from django.contrib import admin
2 from django.urls import include, path
3 from django.contrib.auth import views as auth_views
4 from . import contact
5 
6 urlpatterns = [
7     path('admin/', admin.site.urls),
8     path('contact/', contact.contact, name='contact'),
      # ...

In line 4 we’ve imported the contact module and in line 8 we have added a URLconf that will direct the URL ending in “contact” to the new contact view we will write shortly.

Add Navigation to Site Template

We added a placeholder for the contact page in the top menu when we created the base template. Now we will turn the placeholder into a link for our contact form (changes in bold):

# myclub_site\templates\base.html

# ...

1 <header id="header">
2     <div id="logo"><img src="{% static 'logo.png' %}" alt="" /></div>
3     <div id="top_menu">
4       Home | Calendar | About | 
5       <a href="/contact">Contact Us</a>
6     </div>
    # ...

I have made one change to the base.html template—in line 5 we have turned the placeholder into a link to the contact page. I’ve also reformatted the code slightly.

Create the Contact Form Template

For our contact form to render, it needs a template. In your site templates folder, create a new folder called “contact”. Inside the new folder, create a file called contact.html and enter the following template code (new file):

# \myclub_site\templates\contact\contact.html

1  {% extends "base.html" %}
2  
3  {% block title %}Contact Us{% endblock title %}
4  
5  {% block content %}
6  <h1>Contact us</h1>
7  
8  {% if submitted %}
9    <p class="success">
10     Your message was submitted successfully. Thank you.
11   </p>
12 
13 {% else %}
14   <form action="" method="post" novalidate>
15   <table>
16     {{ form.as_table }}
17     <tr>
18       <td>&nbsp;</td>
19       <td><input type="submit" value="Submit"></td>
20     </tr>
21   </table>
22   {% csrf_token %}
23   </form>
24 {% endif %}
25 {% endblock content %}

In the contact template, we are extending the base template, and replacing the title and content blocks with new content for our contact form. Some other things to note:

  • Line 8. We are using the {% if %} template tag for the first time. submitted is a boolean value passed in from the view. The {% if %} / {% else %} / {% endif %} tags (Lines 8, 13 and 24) are creating a logical branch that is saying “if the form has been submitted, show the thank you message, otherwise show the blank form.”
  • Line 14. Is the start of our POST form. This is standard HTML. Note the novalidate attribute in the <form> tag. When using HTML5 in some of the latest browsers (notably Chrome), form fields will be automatically validated by the browser. As we want Django to handle form validation, the novalidate attribute tells the browser not to validate the form.
  • Line 16. This is the line that renders the form fields. The as_table method will render the form fields as table rows. Django doesn’t render the table tags or the submit button, so we are adding these on line 15 and lines 17 to 21.
  • Line 22. All POST forms targeted at internal URLs must use the {% csrf_token %} template tag. This is to protect against Cross-Site Request Forgeries (CSRF). A full explanation of CSRF is beyond the scope of this book; just rest assured that adding the {% csrf_token %} tag is a Good Thing.

Create the Contact Form View

Our last step is to create the new contact view. Open your contact.py file and add the contact view code (changes in bold):

# myclub_root\myclub_site\contact.py

1  from django import forms
2  from django.shortcuts import render
3  from django.http import HttpResponseRedirect
4  
5  
6  class ContactForm(forms.Form):
7      yourname = forms.CharField(max_length=100, label='Your Name')
8      email = forms.EmailField(required=False,label='Your e-mail address')
9      subject = forms.CharField(max_length=100)
10     message = forms.CharField(widget=forms.Textarea)
11 
12 
13 def contact(request):
14     submitted = False
15     if request.method == 'POST':
16         form = ContactForm(request.POST)
17         if form.is_valid():
18             cd = form.cleaned_data
19             # assert False
20             return HttpResponseRedirect('/contact?submitted=True')
21     else:
22         form = ContactForm()
23         if 'submitted' in request.GET:
24             submitted = True
25 
26     return render(request, 
27         'contact/contact.html', 
28         {'form': form, 'submitted': submitted}
29         )

Let’s step through the important bits of this code:

  • Line 2. Import the render() shortcut function from django.shortcuts.
  • Line 3. Import the HttpResponseRedirect class from django.http.
  • Line 13. The beginning of our new contact view.
  • Line 15. Check if the form was POSTed. If not, skip down to line 22 and create a blank form.
  • Line 17. Check to see if the form contains valid data. Notice there is no cruft for handling invalid form data. This is what’s really cool about the Form class. If the form is invalid, the view drops right through to line 26 and simply re-renders the form as Django has already automatically added the relevant error messages to the form.
  • Line 18. If the form is valid, Django will normalize the data and save it to a dictionary accessible via the cleaned_data attribute of the Form class. In this context, normalizing means changing it to a consistent format. For example, regardless of what entry format you use, Django will always convert a date string to a Python datetime.date object.
  • Line 19. We’re not doing anything with the submitted form right now, so we put in an assertion error to test the form submission with Django’s error page.
  • Line 20. Once the form has been submitted successfully, we are using Django’s HttpResponseRedirect class to redirect back to the contact view. We set the submitted variable to True, so instead of rendering the form, the view will render the thank you message.
  • Line 26. Renders the template and data back to the view.

To test the contact form, uncomment line 19, save the contact.py file and then navigate to http://127.0.0.1:8000/contact to see your new contact form. First, note there is a link to the contact form in the top menu.

Next, submit the empty form to make sure the form validation is working. Django should show the error messages (Figure 8-3).

Figure 8-3: The contact form showing errors for required fields.

Now, fill out the form with valid data and submit it again. You should get an assertion error triggered by the assert False statement in the view (line 19). When we wrote our contact form view, we told Django to put the contents of the cleaned_data attribute into the variable cd (line 18).

With the assert False active in our view, we can check the contents of cd with the Django error page. Scroll down to the assertion error and open the Local vars panel. You should see the cd variable containing a dictionary of the complete form submission (Figure 8-4).

Figure 8-4: Using the assert False statement allows us to check the contents of the submitted form.

Once you have checked the submitted data is correct, click the back button in your browser and then click on the “Contact Us” link in the menu to take you back to the empty form.

Add Styles to the Contact Form

Our contact form is working great, but it still looks a bit plain—the fields don’t line up well, and the error messages don’t stand out. Let’s make the form prettier with some CSS. Add the following to the end of your main.css file:

# \myclub_site\static\main.css

# ...

ul.errorlist {
    margin: 0;
    padding: 0;
}
.errorlist li {
    border: 1px solid red;
    color: red;
    background: rgba(255, 0, 0, 0.15);
    list-style-position: inside;
    display: block;
    font-size: 1.2em;
    margin: 0 0 3px;
    padding: 4px 5px;
    text-align: center;    
    border-radius: 3px;
}
input, textarea {
    width: 100%;
    padding: 5px!important;
    -webkit-box-sizing: border-box;
    -moz-box-sizing: border-box;
    box-sizing: border-box; 
    border-radius: 3px;
    border-style: solid;
    border-width: 1px;
    border-color: rgb(169,169,169)
}
input { 
    height: 30px;
}
.success {
    background-color: rgba(0, 128, 0, 0.15);
    padding: 10px;
    text-align: center;
    color: green;
    border: 1px solid green;
    border-radius: 3px;
}

Once you have saved the changes to your CSS file, refresh the browser and submit the empty form. You may have to clear the browser cache to reload your CSS file. Not only should your form be better laid out, but showing pretty error messages too (Figure 8-5).

Figure 8-5: Adding some CSS changes our rather plain contact form into something to be proud of.

Emailing the Form Data

Our contact form works well and looks good, but it’s not much use right now because we aren’t doing anything with the form data.

As this is a contact form, the most common way to deal with form submissions is to email them to a site administrator or some other contact person within the organization.

Setting up an email server to test emails in development can be painful. Luckily, this is another problem for which the Django developers have provided a handy solution. Django provides several email backends, including a few designed for use during development.

We will use the console backend. This backend is useful in development as it doesn’t require you to set up an email server while you are developing a Django application. The console backend sends email output to the terminal (console). You can check this in your terminal window after you submit your form.

There are other email backends for testing: filebased, locmem and dummy, which send your emails to a file on your local system, save it in an attribute in memory or send to a dummy backend respectively.

You can find more information in the Django documentation under Email Backends.

So, let’s modify the contact view to send emails (changes in bold):

# myclub_root\myclub_site\contact.py

1  from django import forms
2  from django.shortcuts import render
3  from django.http import HttpResponseRedirect
4  from django.core.mail import send_mail, get_connection
5  
6  
7  class ContactForm(forms.Form):
8      yourname = forms.CharField(max_length=100, label='Your Name')
9      email = forms.EmailField(required=False,label='Your e-mail address')
10     subject = forms.CharField(max_length=100)
11     message = forms.CharField(widget=forms.Textarea)
12 
13 
14 def contact(request):
15     submitted = False
16     if request.method == 'POST':
17         form = ContactForm(request.POST)
18         if form.is_valid():
19             cd = form.cleaned_data
20             # assert False
21             con = get_connection('django.core.mail.backends.console.EmailBackend')
22             send_mail(
23                 cd['subject'],
24                 cd['message'],
25                 cd.get('email', 'noreply@example.com'),
26                 ['siteowner@example.com'],
27                 connection=con
28             )
29             return HttpResponseRedirect('/contact?submitted=True')
30     else:
31         form = ContactForm()
32         if 'submitted' in request.GET:
33             submitted = True
34 
35     return render(request, 'contact/contact.html', {'form': form, 'submitted': submitted})

Let’s have a look at the changes we’ve made:

  • Line 4. Import the send_mail() and get_connection() functions from django.core.mail.
  • Line 20. Comment out the assert False statement. If we don’t do this, we will keep getting Django’s error page.
  • Lines 21 to 28. Open a connection to the email backend and use the send_mail() function to send the email.

This is all you need to send an email in Django. To switch to production, you only need to change the backend and add your email server settings to settings.py.

Test the view by filling out the form and submitting. If you look in the console window (PowerShell or command prompt) you will see the view sent the coded email straight to the console. For example, when I submitted the form, this was what Django output to PowerShell (I’ve shortened some of the longer lines):

Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: this is the subject
From: nigel@masteringdjango.com
To: siteowner@example.com
Date: Fri, 22 May 2020 23:50:39 -0000
Message-ID: <...@DESKTOP.home>

This is the message
------------------------------------------

Now the form is complete, submit the form with valid data and the contact view will redirect to the contact page with “submitted=True” as a GET parameter—http://127.0.0.1:8000/contact?submitted=True. With submitted set to True, the contact.html template will execute the first {% if %} block and render the success message instead of the form (Figure 8-6).

Figure 8-6: Once a valid form has been submitted, the thank you message is shown instead of the form.

Model Forms

The contact form is a common, but simple use of a website form. Another common use for forms is to collect information from the user and save the information in the database. Examples include entering your personal information for a membership application, your name and address details for a sales order, and filling out a survey.

Using forms for collecting and saving data from users is so common Django has a special form class to make creating forms from Django models much easier—model forms. With model forms, you create a Django model and then create a form that inherits from Django’s ModelForm class. As always, the devil is in the detail, so let’s create a form for our Venue model.

MyClub wants to allow venue managers to add their venue to the club database. We can’t give venue managers admin access to the backend, so we will create a form they can fill out in the frontend.

The process is as follows:

  1. Create the VenueForm model form for collecting venue information from the user.
  2. Add a new view to manage the form.
  3. Create the form template; and
  4. Add the new view and form to our urls.py file and update the site template to link to the venue form.

Create the Venue Form

Creating a form for the model is where the power of Django’s ModelForm class really shines, as it’s an almost trivial task. Create a new forms.py file in your events app and enter the following code (new file):

# \myclub_root\events\forms.py

1  from django import forms
2  from django.forms import ModelForm
3  from .models import Venue
4  
5  class VenueForm(ModelForm):
6      required_css_class = 'required'
7      class Meta:
8          model = Venue
9          fields = '__all__'

That’s it—a few lines of code is all Django needs to create a form for your model to show the necessary HTML on the page, validate your form fields, and pass form data to your view.

There are some things to note, however, so let’s look at those now:

  • Line 2. We import the ModelForm class, which does all the heavy lifting for us.
  • Line 3. We import our Venue model.
  • Line 5. Our VenueForm class inherits from ModelForm
  • Line 6. required_css_class is a handy ModelForm class option that adds a CSS class to our required fields. We will use this class to add an asterisk (*) to the required fields in the form template.
  • Line 7. The ModelForm class has an internal Meta class which we use to pass in the metadata options the ModelForm class needs to render our form:
    • Line 8. The model on which to base our form; and
    • Line 9. The model fields to render on the form. Here, we’re using the special __all__ value to tell Django to use all the form fields.

Add the Venue View

The view to add a venue builds on what we learned previously in the chapter. We will call the new view add_venue, so let’s add the view code to the views.py file in our events app (changes in bold):

# \myclub_root\events\views.py

1  from django.shortcuts import render
2  from django.http import HttpResponse
3  from django.http import HttpResponseRedirect
4  from datetime import date
5  import calendar
6  from calendar import HTMLCalendar
7  from .models import Event
8  from .forms import VenueForm
9  
10 # ...
11 
12 def add_venue(request):
13     submitted = False
14     if request.method == 'POST':
15         form = VenueForm(request.POST)
16         if form.is_valid():
17             form.save()
18             return HttpResponseRedirect('/add_venue/?submitted=True')
19     else:
20         form = VenueForm()
21         if 'submitted' in request.GET:
22             submitted = True
23     return render(request, 
24         'events/add_venue.html', 
25         {'form': form, 'submitted': submitted}
26         )

At the top of the file, we’re importing HttpResponseRedirect from django.http (line 3) and the form (VenueForm) from forms.py (line 8). This view is functionally identical to the view for our contact form, except we have removed the code for emailing the form data and replaced it with the form.save() method to save the form data to our database (line 17).

Create the Venue Form Template

Now it’s time to create the template for our form. We will inherit from the site’s base template, so the form is very similar to the contact form template. Create a new file called add_venue.html and add it to the events app’s templates folder (new file):

# \events\templates\events\add_venue.html

1  {% extends "base.html" %}
2  
3  {% block title %}Add Venue{% endblock title %}
4  
5  {% block content %}
6  <h1>Add your venue to our database</h1>
7  
8  {% if submitted %}
9    <p class="success">
10     Your venue was submitted successfully. Thank you.
11   </p>
12 {% else %}
13   <form action="" method="post" novalidate>
14   <table>
15     {{ form.as_table }}
16     <tr>
17       <td>&nbsp;</td>
18       <td><input type="submit" value="Submit"></td>
19     </tr>
20   </table>
21   {% csrf_token %}
22   </form>
23 {% endif %}
24 {% endblock content %}

Except for some contextual changes to the display text, this template is identical to the contact form template, so I won’t go over any details.

While we are working on the form template, we need to add a little tweak to the main.css file, so our required field labels will have an asterisk appended to the label:

# add to the end of \static\main.css

.required label:after {
    content: "*";
}

The last task to complete is to provide a new URL configuration for the events app and add an HTML anchor to the base template to link our website to the new add venue form.

First, let’s add the URL configuration to the events app’s urls.py file (changes in bold):

# \myclub_root\events\urls.py

1  from django.urls import path, re_path
2  from . import views
3  
4  urlpatterns = [
5      path('', views.index, name='index'),
6      path('add_venue/', views.add_venue, name='add-venue'),
7      # ...
8  ]

One change here—I’ve added a new path() function on line 6 which will redirect a URL ending with add_venue/ to the add_venue view.

And now for the base template (change in bold):

# \myclub_site\templates\base.html

1 <aside id="rightsidebar">
2   <nav id="nav">
3     <ul>
4       <li><a href="/add_venue">Add Your Venue</a></li>
5       <li>Menu 2</li>
6       <li>Menu 3</li>
7     </ul>
8   </nav>
9 </aside>

Here, in line 4, I’ve added a simple HTML anchor tag so the first menu item on the right sidebar links to our new add venue form.

Save all your files and fire up the development server. When you open your site, there should be a link to add a venue in the right sidebar. Click this link, and you should see your new add a venue form (Figure 8-7).

Figure 8-7: The new form for adding a venue.

Overriding Form Methods

While our new form for adding venues is functional, it has a problem—both contact phone and contact email address fields are optional. This was OK in the admin because a staff member would know that MyClub needs at least one form of contact in the database. User experience design best-practice says you should never assume site visitors know how to fill out a form correctly. So, we need to add custom validation to ensure the person filling out the form enters either a phone number or an email address.

As a part of the validation process, both regular forms and model forms run the clean() method. You can override this special method to provide custom validation. To override the clean() method in a ModelForm class, we add the override to the class (changes in bold):

# \myclub_root\events\forms.py

1  from django import forms
2  from django.forms import ModelForm
3  from .models import Venue
4  
5  class VenueForm(ModelForm):
6      required_css_class = 'required'
7      class Meta:
8          model = Venue
9          fields = '__all__'
10     
11     def clean(self):
12         cleaned_data = super().clean()
13         phone = cleaned_data.get("phone")
14         email_address = cleaned_data.get("email_address")
15         if not (phone or email_address):
16             raise forms.ValidationError(
17                 "You must enter either a phone number or an email, or both."
18             )

Let’s have a closer look at the new method we’ve added to the VenueForm class:

  • Line 12. super().clean() maintains any validation logic from parent classes.
  • Lines 13 and 14. We’re retrieving the values for the venue phone number and email address from the dictionary saved in the cleaned_data attribute.
  • Line 15. If both the phone number and email address are blank, a validation error is raised (line 16).

You can see how this new custom validation works in practice if you try to submit the form with both the phone number and email address fields blank (Figure 8-8).

Figure 8-8: Overriding the clean() method of the Form class provides a painless way to add custom validation to your form.

Chapter Summary

In this chapter, we learned the fundamentals of how to create and manage forms in Django. We learned how to create a contact form for collecting feedback from site visitors, and how to create a form for a model, so users can submit data to the site database in the frontend.

This chapter concludes Part 1 of the book. In the next chapter, we will move on from the fundamentals of Django to dig deeper into models, views, and templates, and cover more advanced topics on the Django admin, forms and user management.