Custom form validation methods in Django - Step-by-Step Execution

Concept Flow - Custom form validation methods

Start form submission

↓

Call form.is_valid()

↓

Run built-in validations

↓

Run custom clean_<field>() methods

↓

Run form's clean() method

↓

Collect errors or accept data

↓

Return validation result

When a form is submitted, Django runs built-in checks, then custom field validations, then overall form validation before accepting or rejecting data.

Execution Sample

Django

from django import forms

class MyForm(forms.Form):
    age = forms.IntegerField()

    def clean_age(self):
        age = self.cleaned_data['age']
        if age < 18:
            raise forms.ValidationError('Must be 18 or older')
        return age

This form checks if the age field is 18 or older using a custom validation method.

Execution Table

Step	Action	Evaluation	Result
1	Call form.is_valid()	Trigger validation	Start validation process
2	Run built-in validations	Check age is integer and required	Pass if valid integer
3	Run clean_age()	Check if age < 18	Raise error if true, else pass
4	Run clean()	No extra checks here	Pass
5	Collect errors	If any errors, form.is_valid() returns False	Form invalid if errors exist
6	Return validation result	No errors found	Form is valid

💡 Validation stops after all checks; errors cause form.is_valid() to be False

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
age	None	25 (input parsed)	25 (validated)	25 (cleaned)
errors	{}	{}	{}	{}

Key Moments - 3 Insights

Why does clean_age() raise ValidationError instead of returning False?

In execution_table step 3, raising ValidationError signals Django to mark the field invalid and show the error message. Returning False would not trigger this behavior.

When is the form's clean() method called compared to clean_<field>()?

As shown in execution_table step 4, clean_<field>() methods run first for each field, then clean() runs once for the whole form to check combined data.

What happens if built-in validation fails before custom methods?

In step 2, if built-in validation fails (e.g., age not an integer), custom methods like clean_age() are not called, and form.is_valid() returns False immediately.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 3 if age is 16?

A clean_age() passes without error

B built-in validation fails

C clean_age() raises ValidationError

D form.is_valid() returns True immediately

💡 Hint

See step 3 where clean_age() checks if age < 18 and raises error if true

At which step does Django collect all errors to decide if form is valid?

A Step 5

B Step 3

C Step 2

D Step 6

💡 Hint

Step 5 is labeled 'Collect errors' in the execution_table

If the input for age is 'abc', what changes in the execution_table?

A clean_age() raises ValidationError

B Step 2 fails built-in validation, clean_age() not called

C clean() method raises error

D form.is_valid() returns True

💡 Hint

Refer to key_moments 3 and step 2 in execution_table about built-in validation

Concept Snapshot

Custom form validation in Django:
- Define clean_<field>() to validate individual fields
- Raise ValidationError to signal invalid data
- clean() method validates whole form after fields
- form.is_valid() runs all validations and collects errors
- Validation stops early if built-in checks fail

Full Transcript

When you submit a Django form, the system first runs built-in checks like required fields and data types. Then it calls any custom clean_<field>() methods you wrote to check specific fields. If those pass, it runs the form's clean() method to check the whole form together. If any validation fails, Django collects errors and form.is_valid() returns False. If all checks pass, form.is_valid() returns True and you can use the cleaned data safely.

Practice

1. What is the purpose of defining a clean_fieldname method in a Django form?

easy

A. To handle form submission via AJAX

B. To automatically save the form data to the database

C. To add custom validation logic for a specific form field

D. To style the form field with CSS classes

Solution

1. Step 1: Understand the role of clean_fieldname

   This method is used to add validation logic for a single field in a Django form.

2. Step 2: Differentiate from other methods

   Unlike clean which validates multiple fields, clean_fieldname focuses on one field only.

3. Final Answer:

   To add custom validation logic for a specific form field -> Option C

4. Quick Check:

   clean_fieldname validates one field [OK]

Hint: Remember: clean_fieldname validates one field only [OK]

Common Mistakes:

• Confusing clean_fieldname with clean method
• Thinking it saves data automatically
• Assuming it styles the form

2. Which of the following is the correct way to raise a validation error inside a custom clean method for a field named email?

easy

A. return ValidationError('Invalid email')

B. raise ValidationError('Invalid email')

C. self.add_error('email', 'Invalid email')

D. ValidationError('Invalid email')

Solution

1. Step 1: Identify how to raise errors in Django forms

   In custom clean methods, you raise a ValidationError to signal invalid data.

2. Step 2: Check the syntax for raising errors

   The correct syntax is to use raise ValidationError('message'), not return or just call it.

3. Final Answer:

   raise ValidationError('Invalid email') -> Option B

4. Quick Check:

   Use raise to throw ValidationError [OK]

Hint: Use raise, not return, to signal validation errors [OK]

Common Mistakes:

• Using return instead of raise
• Calling ValidationError without raise
• Misusing self.add_error inside clean_fieldname

3. Given this Django form snippet, what will happen if the user enters 'abc' for the age field?

class MyForm(forms.Form):
    age = forms.IntegerField()

    def clean_age(self):
        age = self.cleaned_data.get('age')
        if age < 18:
            raise ValidationError('Must be at least 18')
        return age

medium

A. Form will crash with a TypeError

B. Form will accept 'abc' and pass validation

C. clean_age will raise 'Must be at least 18' error

D. Form will raise a validation error because 'abc' is not an integer

Solution

1. Step 1: Understand IntegerField behavior

   IntegerField automatically validates input to be an integer before calling clean_age.

2. Step 2: Analyze input 'abc'

   'abc' is not an integer, so IntegerField will raise a validation error before clean_age runs.

3. Final Answer:

   Form will raise a validation error because 'abc' is not an integer -> Option D

4. Quick Check:

   IntegerField rejects non-integers first [OK]

Hint: IntegerField validates type before custom clean runs [OK]

Common Mistakes:

• Thinking clean_age handles type errors
• Assuming 'Must be at least 18' error triggers for 'abc'
• Expecting a crash instead of validation error

4. Identify the error in this custom form validation method:

def clean(self):
    data = self.cleaned_data
    if data['start_date'] > data['end_date']:
        raise ValidationError('Start date must be before end date')
    return data

medium

A. Accessing cleaned_data directly without calling super().clean()

B. Raising ValidationError with a string instead of a dictionary

C. Not returning cleaned_data at the end of clean()

D. Using '>' operator instead of '>=' for date comparison

Solution

1. Step 1: Check how clean() should be overridden

   When overriding clean(), you must call super().clean() to get cleaned_data properly.

2. Step 2: Identify the error in accessing cleaned_data

   This code accesses self.cleaned_data directly without calling super().clean(), which may cause missing or incomplete data.

3. Final Answer:

   Accessing cleaned_data directly without calling super().clean() -> Option A

4. Quick Check:

   Always call super().clean() first [OK]

Hint: Call super().clean() before using cleaned_data [OK]

Common Mistakes:

• Forgetting to call super().clean()
• Returning wrong data type
• Misusing ValidationError format

5. You want to ensure that a Django form's password and confirm_password fields match. Which is the best way to implement this validation?

hard

A. Override the form's clean method to compare both fields and raise ValidationError if they differ

B. Add a validator to the password field that checks confirm_password

C. Define a clean_password method that compares both fields

D. Use JavaScript on the client side only to check matching passwords

Solution

1. Step 1: Understand field-level vs form-level validation

   Field-level methods like clean_password only see one field's data, so can't compare two fields.

2. Step 2: Use form-level clean() for cross-field validation

   Overriding clean lets you access all fields and compare password and confirm_password.

3. Final Answer:

   Override the form's clean method to compare both fields and raise ValidationError if they differ -> Option A

4. Quick Check:

   Use clean() for multi-field validation [OK]

Hint: Use clean() method for comparing multiple fields [OK]

Common Mistakes:

• Trying to compare fields in clean_password
• Relying only on client-side JavaScript
• Adding validators that can't access other fields