Beginner’s Guide to Django Models and Forms (With Examples)

If you're starting out with Django and are curious about how models and forms work together, you're in the right place.

This guide will walk you through the essentials of Django models and forms, enriched with detailed examples to solidify your understanding.

What Are Django Models?

Django models are Python classes that define the structure of your database.

 Each model maps to a single database table, and each attribute of the model represents a database field.

Example:

from django.db import models

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

In this example, the Book model has three fields: title, author, and published_date. Django uses this model to create a corresponding table in the database with columns for each field.

Understanding Model Fields

Django provides various field types to handle different kinds of data. Here's a breakdown of some commonly used fields:

• CharField: Used for short text fields. Requires a max_length parameter.

  title = models.CharField(max_length=100)
  

• TextField: For large text fields.

  description = models.TextField()
  

• IntegerField: For integer values.

  pages = models.IntegerField()
  

• DecimalField: For fixed-precision decimal numbers. Requires max_digits and decimal_places.

  price = models.DecimalField(max_digits=5, decimal_places=2)
  

• DateField: For date values.

  published_date = models.DateField()
  

• BooleanField: For boolean values.

  is_available = models.BooleanField(default=True)
  

For a comprehensive list of field types and their options, refer to the Django documentation: (Django Project).

Model Field Options

Each field in a Django model can accept various options to customize its behavior:

• null: If True, Django will store empty values as NULL in the database. Default is False.

• blank: If True, the field is allowed to be blank in forms. Default is False.

• default: Sets a default value for the field.

• choices: Limits the field's values to the given choices.

  Example:

  STATUS_CHOICES = [
      ('D', 'Draft'),
      ('P', 'Published'),
      ('W', 'Withdrawn'),
  ]
  
  status = models.CharField(max_length=1, choices=STATUS_CHOICES, default='D')

  In this example, the status field can only have one of the specified choices.

Meta Class in Models

The Meta class inside a Django model provides metadata to the model. It can be used to define various behaviors of the model.

Common Meta options:

• ordering: Specifies the default ordering of records.

  class Meta:
      ordering = ['published_date']
  

• verbose_name: A human-readable name for the object, singular.

  class Meta:
      verbose_name = "Book"
  

• verbose_name_plural: The plural name for the object.

  class Meta:
      verbose_name_plural = "Books"
  

• db_table: Specifies the name of the database table.

  class Meta:
      db_table = 'library_books'
  

For more details on Meta options, check the Django documentation: (Django Project).

What Are Django Forms?

Django forms are a way to handle user input and validation in your web applications. They can be used to create HTML forms and validate user input.

There are two main types of forms in Django:

1. Form: Used when you want to create a form not directly tied to a Django model.

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

2. ModelForm: Used when you want to create a form that corresponds to a Django model.

from django.forms import ModelForm
from .models import Book

class BookForm(ModelForm):
    class Meta:
        model = Book
        fields = ['title', 'author', 'published_date']

How Models and Forms Work Together

When using ModelForm, Django handles the creation of form fields and validation based on the model's fields.

Example view using ModelForm:

from django.shortcuts import render, redirect
from .forms import BookForm

def add_book(request):
    if request.method == 'POST':
        form = BookForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('book_list')
    else:
        form = BookForm()
    return render(request, 'add_book.html', {'form': form})

In this view:

• If the request is a POST, it means the form was submitted. We instantiate the form with request.POST data.

• form.is_valid() checks if the submitted data is valid.

• If valid, form.save() saves the data to the database.

• If the request is not a POST, we instantiate an empty form.

Common Mistakes to Avoid

• Not callingform.is_valid()before form.save(): Always validate the form before saving.

• Using null=True on string-based fields: It's recommended to use blank=True instead of null=True for string-based fields like CharField and TextField.

• Not defining__str__method in models: Defining __str__ helps in displaying meaningful names for model instances.

  def __str__(self):
      return self.title

• Not usingchoicesfor fields with limited options: Using choices helps in data validation and provides better user experience.

• Use ModelForm unless you have a specific reason not to.
• Keep your validation logic inside the form, not the view.
• Use the Meta class to control which fields appear in the form.
• Use widgets if you need to customize form inputs (e.g., textareas, datepickers).
• Call form.save(commit=False) if you need to modify the instance before saving.

Want to Learn More?

Check out the official Django docs on
📘 Using Forms — very helpful once you understand the basics.

Also, explore our related articles -

•  Django clean() vs clean_field() — How Validation Works

Conclusion

Understanding Django models and forms is crucial for building robust web applications.

Models define the structure of your data, while forms handle user input and validation. By leveraging Django's powerful features and following best practices, you can create efficient and maintainable applications.

If you have any questions or need further clarification, feel free to ask!