Form error handling in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a Django form is invalid?

Consider a Django form instance that has been submitted with invalid data. What will be the state of form.errors and what will the template typically display?

Django

form = MyForm(data=request.POST)
if not form.is_valid():
    errors = form.errors

A form.errors is empty; the template shows no errors because the form is invalid.

B form.errors contains a dictionary of field names to error messages; the template shows these errors next to the fields.

C form.errors contains a list of error strings without field names; the template shows a generic error message only.

D form.errors raises an exception if the form is invalid; the template crashes.

💡 Hint

Think about how Django helps users know what went wrong with their input.

When a Django form is invalid, form.errors holds a dictionary mapping each field to its list of error messages. Templates can access these to show errors next to each field, guiding the user.

📝 Syntax

intermediate

Which code correctly adds a non-field error to a Django form?

You want to add a custom error message that is not tied to any specific field. Which code snippet correctly does this inside a Django form's clean() method?

Django

def clean(self):
    cleaned_data = super().clean()
    if some_condition:
        # add non-field error here
    return cleaned_data

A self.non_field_errors.append('Custom non-field error message')

B self.errors['__all__'] = 'Custom non-field error message'

C self.add_error(None, 'Custom non-field error message')

D self.add_error('non_field', 'Custom non-field error message')

💡 Hint

Check Django docs for adding errors not tied to fields.

Using self.add_error(None, message) adds a non-field error properly. Other options are invalid or cause errors.

🔧 Debug

advanced

Why does this Django form not show errors in the template?

Given this view code snippet, why might the form errors not appear in the template?

form = MyForm(request.POST or None) if form.is_valid(): # process data else: form = MyForm()

A The form is reinitialized with empty data in the else block, so errors are lost.

B The form is valid, so no errors exist to show.

C The template does not have access to the form variable.

D Django automatically clears errors after is_valid() check.

💡 Hint

Look at how the form variable is assigned in the else block.

Reassigning form = MyForm() in the else block creates a new empty form without errors, so the template sees no errors to display.

❓ state_output

advanced

What is the output of this Django form error check?

Consider this code snippet inside a Django form's clean() method:

if self.cleaned_data.get('age', 0) < 18: self.add_error('age', 'Must be at least 18') return self.cleaned_data

What will form.errors contain if the submitted age is 16?

A {'age': ['Must be at least 18']}

B {} (empty dictionary)

C {'__all__': ['Must be at least 18']}

D Raises a KeyError because 'age' is missing

💡 Hint

Check how add_error associates messages with fields.

The error is added to the 'age' field, so form.errors will have a key 'age' with the message.

🧠 Conceptual

expert

Which statement about Django form error handling is true?

Select the one true statement about how Django handles form errors during validation.

A Django stores all errors as a flat list in <code>form.errors</code>, without distinguishing fields.

B Non-field errors must be added by raising exceptions inside the form's <code>clean()</code> method.

C Calling <code>form.is_valid()</code> clears all previous errors automatically.

D Field-specific errors are stored in <code>form.errors</code> under their field names, while non-field errors are stored under the key <code>__all__</code>.

💡 Hint

Think about how Django separates errors for fields and general form errors.

Django keeps field errors keyed by field name in form.errors. Non-field errors appear under the special key __all__. Other options are incorrect.

Practice

1. What does form.is_valid() do in Django form handling?

easy

A. Saves the form data to the database automatically

B. Checks if the submitted form data meets all validation rules

C. Clears all errors from the form

D. Displays the form errors to the user

Solution

1. Step 1: Understand the purpose of form.is_valid()

   This method checks if the form data passes all validation checks defined in the form.

2. Step 2: Differentiate from other form methods

   It does not save data or clear errors; it only returns True if data is valid, False otherwise.

3. Final Answer:

   Checks if the submitted form data meets all validation rules -> Option B

4. Quick Check:

   form.is_valid() = validation check [OK]

Hint: Remember: is_valid() only checks data correctness [OK]

Common Mistakes:

• Thinking is_valid() saves data
• Confusing is_valid() with error display
• Assuming is_valid() clears errors

2. Which of the following is the correct way to access form errors in a Django template?

easy

A. {{ form.errors }}

B. {{ form.error_list }}

C. {{ form.error_messages }}

D. {{ form.error }}

Solution

1. Step 1: Recall Django form error attribute

   The correct attribute to access errors is form.errors, which returns a dictionary of errors.

2. Step 2: Verify template syntax

   Using {{ form.errors }} in the template displays the errors properly.

3. Final Answer:

   {{ form.errors }} -> Option A

4. Quick Check:

   Use form.errors to show errors [OK]

Hint: Use form.errors to get all errors in templates [OK]

Common Mistakes:

• Using non-existent attributes like error_list
• Trying to access errors with singular 'error'
• Confusing error_messages with errors

3. Given this Django form code snippet, what will print(form.errors) output if the 'email' field is left empty?

class ContactForm(forms.Form):
    email = forms.EmailField(required=True)

form = ContactForm(data={'email': ''})
form.is_valid()
print(form.errors)

medium

A. {'email': ['This field is required.']}

B. {}

C. {'email': ['Enter a valid email address.']}

D. None

Solution

1. Step 1: Understand required field behavior

   The 'email' field is required, so leaving it empty triggers a 'This field is required.' error.

2. Step 2: Check form.errors output

   After calling form.is_valid(), form.errors contains the error message for the empty 'email' field.

3. Final Answer:

   {'email': ['This field is required.']} -> Option A

4. Quick Check:

   Empty required field = 'This field is required.' error [OK]

Hint: Empty required fields always add 'This field is required.' error [OK]

Common Mistakes:

• Expecting empty errors dictionary
• Confusing empty with invalid email format error
• Assuming errors is None when invalid

4. Identify the error in this Django form handling code snippet:

form = MyForm(request.POST)
if form.is_valid:
    form.save()

medium

A. Using form.save() without checking is_valid

B. Form instance should be created with request.FILES

C. request.POST should be request.GET

D. Missing parentheses after is_valid method call

Solution

1. Step 1: Check method call syntax

   The code uses form.is_valid without parentheses, so it references the method but does not call it.

2. Step 2: Understand consequences

   This means the if condition always evaluates to True because the method itself is truthy, causing potential errors.

3. Final Answer:

   Missing parentheses after is_valid method call -> Option D

4. Quick Check:

   Call is_valid() with () to check validity [OK]

Hint: Always add () to call is_valid method [OK]

Common Mistakes:

• Forgetting parentheses on is_valid
• Assuming is_valid is a property
• Mixing request.POST with request.GET incorrectly

5. You want to display individual error messages next to each form field in your Django template. Which template code snippet correctly achieves this?

hard

A. {{ form.errors }}

B. {% for error in form.errors %}
{{ error }}
{% endfor %}

C. {% for field in form %}
{{ field.label }}
{{ field }}
{% for error in field.errors %}
{{ error }}
{% endfor %}
{% endfor %}

D. {% if form.errors %}
There are errors in the form.
{% endif %}

Solution

1. Step 1: Understand error display per field

   To show errors next to each field, iterate over form fields and then over each field's errors.

2. Step 2: Analyze each option

   {% for field in form %} {{ field.label }} {{ field }} {% for error in field.errors %} {{ error }} {% endfor %} {% endfor %} loops over fields and their errors, displaying them properly. Using {{ form.errors }} or {% for error in form.errors %} shows all errors together, not per field. {% if form.errors %}

   There are errors in the form.

   {% endif %} only shows a message if errors exist, no details.

3. Final Answer:

   {% for field in form %} {{ field.label }} {{ field }} {% for error in field.errors %} {{ error }} {% endfor %} {% endfor %} -> Option C

4. Quick Check:

   Loop fields and field.errors for per-field messages [OK]

Hint: Loop fields and field.errors to show errors per field [OK]

Common Mistakes:

• Showing all errors together without field context
• Not looping over field.errors
• Only showing generic error message