Form validation (is_valid, cleaned_data) in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does form.is_valid() do in Django forms?

Consider a Django form instance with user input data. What is the main purpose of calling form.is_valid()?

A It converts the form data into JSON format.

B It saves the form data directly to the database without validation.

C It clears all the data from the form fields.

D It checks if the form data meets all field validations and returns True or False accordingly.

💡 Hint

Think about what happens before you use the form data safely.

Calling form.is_valid() runs all validation rules on the form fields. It returns True if all data is valid, otherwise False. This prevents bad data from being processed.

❓ state_output

intermediate

What is the content of form.cleaned_data after validation?

After calling form.is_valid() and it returns True, what does form.cleaned_data contain?

Django

from django import forms

class SampleForm(forms.Form):
    name = forms.CharField(max_length=10)
    age = forms.IntegerField()

form = SampleForm({'name': 'Alice', 'age': '30'})
if form.is_valid():
    data = form.cleaned_data
else:
    data = None

A A dictionary with form fields as keys and validated, converted Python values as values.

B A list of error messages for each invalid field.

C The original input dictionary without any changes.

D A string representation of the form HTML.

💡 Hint

Think about what you want to use after validation passes.

form.cleaned_data holds the validated and converted data from the form fields as a dictionary. For example, strings converted to integers where needed.

📝 Syntax

advanced

Which option correctly defines a custom clean method in a Django form?

You want to add a custom validation that checks if the 'age' field is at least 18. Which code snippet correctly implements this in a Django form?

A

def clean_age(self):
    age = self.data['age']
    if age < 18:
        raise forms.ValidationError('Must be at least 18')
    return age

B

def clean(self):
    age = self.cleaned_data['age']
    if age < 18:
        raise forms.ValidationError('Must be at least 18')
    return self.cleaned_data

C

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

D

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

💡 Hint

Custom field validation uses clean_fieldname methods and accesses cleaned_data.

Custom validation for a single field uses a method named clean_fieldname. It accesses self.cleaned_data to get the field value and returns the cleaned value or raises ValidationError.

🔧 Debug

advanced

Why does this form always return False for is_valid()?

Given this form code, why does form.is_valid() always return False?

class MyForm(forms.Form):
    email = forms.EmailField()

form = MyForm({'email': 'not-an-email'})
valid = form.is_valid()

A The email value is not a valid email format, so validation fails.

B The form is missing a required field called 'email'.

C The form data dictionary keys must be bytes, not strings.

D The form instance was not created with a request object.

💡 Hint

Check the format of the input data for the EmailField.

The string 'not-an-email' is not a valid email format, so the EmailField validation fails and is_valid() returns False.

🧠 Conceptual

expert

What happens if you access form.cleaned_data before calling form.is_valid()?

Consider this code snippet:

form = MyForm({'name': 'Bob'})
data = form.cleaned_data

What will happen when you try to access form.cleaned_data before calling form.is_valid()?

A It returns an empty dictionary because no validation has run yet.

B It raises an AttributeError because cleaned_data is not set until is_valid() is called.

C It returns the raw input data dictionary passed to the form.

D It automatically calls is_valid() and returns cleaned data.

💡 Hint

Think about when cleaned_data is created in the form lifecycle.

cleaned_data is only populated after is_valid() runs validation. Accessing it before causes an AttributeError because it does not exist yet.

Practice

1. What does the is_valid() method do in a Django form?

easy

A. Saves the form data to the database

B. Clears all data from the form fields

C. Checks if the form data meets all validation rules

D. Generates HTML for the form

Solution

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

   This method runs all validation checks on the form data to ensure it is correct and complete.

2. Step 2: Identify what is_valid() returns

   It returns True if all data passes validation, otherwise False.

3. Final Answer:

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

4. Quick Check:

   Form validation = is_valid() [OK]

Hint: Remember: is_valid() means data is good to use [OK]

Common Mistakes:

• Thinking is_valid() saves data
• Confusing is_valid() with form rendering
• Assuming is_valid() clears form fields

2. Which of the following is the correct way to access cleaned form data after validation?

easy

A. form.get_cleaned('field_name')

B. form.data['field_name']

C. form.fields['field_name']

D. form.cleaned_data['field_name']

Solution

1. Step 1: Identify how cleaned data is stored

   After calling is_valid(), valid data is stored in cleaned_data dictionary.

2. Step 2: Access cleaned data by field name

   You use form.cleaned_data['field_name'] to get the safe, validated value.

3. Final Answer:

   form.cleaned_data['field_name'] -> Option D

4. Quick Check:

   Access safe data = cleaned_data['field_name'] [OK]

Hint: Use cleaned_data after is_valid() to get safe inputs [OK]

Common Mistakes:

• Using form.data which is raw input, not validated
• Trying to call a non-existent method get_cleaned()
• Accessing form.fields which holds field definitions, not data

3. Given this code snippet:

form = MyForm(request.POST)
if form.is_valid():
    name = form.cleaned_data['name']
else:
    errors = form.errors

What will errors contain if the form is invalid?

medium

A. A dictionary of error messages for each invalid field

B. An empty list

C. The cleaned data from the form

D. A boolean False value

Solution

1. Step 1: Understand what form.errors holds

   When validation fails, form.errors contains error messages keyed by field names.

2. Step 2: Differentiate errors from cleaned_data

   Errors are messages explaining what went wrong, not data or booleans.

3. Final Answer:

   A dictionary of error messages for each invalid field -> Option A

4. Quick Check:

   Invalid form errors = form.errors dict [OK]

Hint: form.errors holds messages, not data or booleans [OK]

Common Mistakes:

• Confusing errors with cleaned_data
• Expecting errors to be a list or boolean
• Assuming errors is empty when invalid

4. What is wrong with this code?

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

medium

A. request.POST should be request.GET

B. Missing parentheses after is_valid, so validation is not called

C. cleaned_data should be called as a method

D. form variable is not defined

Solution

1. Step 1: Check how is_valid is used

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

2. Step 2: Understand the effect of missing parentheses

   Without calling is_valid(), validation does not run and cleaned_data is not populated.

3. Final Answer:

   Missing parentheses after is_valid, so validation is not called -> Option B

4. Quick Check:

   Call is_valid() with () to validate [OK]

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

Common Mistakes:

• Forgetting parentheses on is_valid()
• Trying to call cleaned_data as a method
• Confusing POST and GET without context

5. You want to create a form that only accepts an email if the user is over 18 years old. Which approach correctly uses is_valid() and cleaned_data to enforce this?

hard

A. Call is_valid(), then check cleaned_data['age'] to conditionally accept the email

B. Check form.data['age'] before calling is_valid()

C. Use form.errors before calling is_valid()

D. Assign cleaned_data before calling is_valid()

Solution

1. Step 1: Understand validation order

   You must call is_valid() first to run all validations and populate cleaned_data.

2. Step 2: Use cleaned_data to check age and decide if email is accepted

   After validation, cleaned_data['age'] is safe to use for conditional logic.

3. Final Answer:

   Call is_valid(), then check cleaned_data['age'] to conditionally accept the email -> Option A

4. Quick Check:

   Validate first, then use cleaned_data [OK]

Hint: Always validate before using cleaned_data for conditions [OK]

Common Mistakes:

• Using raw data before validation
• Accessing errors before validation
• Trying to use cleaned_data before calling is_valid()