Form class definition in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Django form validation?

Given the following Django form class and data, what will be the value of form.is_valid() and form.errors after validation?

Django

from django import forms

class ContactForm(forms.Form):
    name = forms.CharField(max_length=50)
    email = forms.EmailField()

form = ContactForm(data={'name': 'Alice', 'email': '[e-mail]'})
valid = form.is_valid()
errors = form.errors

A valid is True, errors is an empty dictionary

B valid is True, errors contains 'email' key

C valid is False, errors contains 'name' key

D valid is False, errors contains 'email' key

💡 Hint

Check if the provided email matches the EmailField format and if all required fields are present.

The form has both required fields filled correctly. The email is valid, so form.is_valid() returns True and form.errors is empty.

📝 Syntax

intermediate

Which option correctly defines a Django form with a required integer field?

Select the code snippet that correctly defines a Django form class with a required integer field named age.

A

class AgeForm(forms.Form):
    age = forms.IntegerField(required=False)

B

class AgeForm(forms.Form):
    age = forms.IntegerField(required=True)

C

class AgeForm(forms.Form):
    age = forms.CharField(required=True)

D

class AgeForm(forms.Form):
    age = forms.FloatField(required=True)

💡 Hint

Look for the field type that accepts only integers and is required.

Option B uses IntegerField with required=True, which matches the requirement exactly. Option B makes it optional. Option B uses CharField, which accepts strings. Option B uses FloatField, which accepts floats.

❓ state_output

advanced

What is the cleaned_data content after form validation?

Given this Django form and input data, what will form.cleaned_data contain after calling form.is_valid()?

Django

from django import forms

class SignupForm(forms.Form):
    username = forms.CharField(max_length=30)
    age = forms.IntegerField()

form = SignupForm(data={'username': 'bob', 'age': '25'})
form.is_valid()
cleaned = form.cleaned_data

A {'username': 'bob', 'age': 25}

B {'username': 'bob', 'age': '25'}

C {'username': 'bob'}

D Raises ValidationError

💡 Hint

Remember that IntegerField converts input strings to integers in cleaned_data.

The form converts the 'age' string '25' to integer 25 in cleaned_data after validation.

🔧 Debug

advanced

Why does this Django form raise a TypeError?

Examine the following form class. Why does instantiating it with data cause a TypeError?

Django

from django import forms

class ProfileForm(forms.Form):
    bio = forms.CharField(max_length=100)

form = ProfileForm(data='not a dict')

A Because forms.Form cannot be instantiated with data argument

B Because CharField requires an integer max_length

C Because data must be a dictionary or QueryDict, not a string

D Because bio field is missing a required argument

💡 Hint

Check the type expected for the data parameter when creating a form instance.

The data argument must be a dictionary-like object. Passing a string causes a TypeError.

🧠 Conceptual

expert

Which statement about Django form class definition is true?

Select the correct statement about defining and using Django form classes.

A Form classes cannot have custom validation methods

B Form fields can only be defined inside the __init__ method of the form class

C Django forms automatically save data to the database when is_valid() is called

D A form class must inherit from forms.Form and define fields as class attributes

💡 Hint

Think about how Django expects form fields to be declared.

Django form classes inherit from forms.Form and define fields as class attributes. Custom validation methods are allowed. Forms do not save data automatically.

Practice

1. What is the main purpose of defining a form class in Django?

easy

A. To write JavaScript code for user interaction

B. To define database tables automatically

C. To style HTML pages with CSS

D. To create a reusable structure for user input fields and validation

Solution

1. Step 1: Understand what a Django form class does

   A Django form class defines fields and validation rules for user input, making form handling easier.

2. Step 2: Compare options with this purpose

   Only To create a reusable structure for user input fields and validation describes creating reusable input fields and validation, which is the main purpose.

3. Final Answer:

   To create a reusable structure for user input fields and validation -> Option D

4. Quick Check:

   Form class purpose = reusable input and validation [OK]

Hint: Form classes handle input and validation, not styling or DB [OK]

Common Mistakes:

• Confusing form classes with database models
• Thinking form classes handle page styling
• Assuming form classes write JavaScript

2. Which of the following is the correct way to define a simple Django form class with a single text field named name?

easy

A. def MyForm():
name = CharField()

B. class MyForm(forms.Form):
name = forms.CharField()

C. class MyForm(forms.Model):
name = models.CharField()

D. class MyForm(forms.Form):
name = CharField

Solution

1. Step 1: Identify correct base class and field syntax

   Django form classes inherit from forms.Form and fields use forms.FieldType(), so forms.CharField() is correct.

2. Step 2: Check each option

   class MyForm(forms.Form): name = forms.CharField() uses forms.Form and forms.CharField() correctly. Others use wrong base class, missing parentheses, or wrong imports.

3. Final Answer:

   class MyForm(forms.Form): name = forms.CharField() -> Option B

4. Quick Check:

   Form class inherits forms.Form and fields use forms.Field() [OK]

Hint: Use forms.Form base and fields with parentheses [OK]

Common Mistakes:

• Using models.Model instead of forms.Form
• Forgetting parentheses after field type
• Defining form as a function instead of a class

3. Given this form class definition, what will form.is_valid() return if the submitted data is {'age': '25'}?

from django import forms

class AgeForm(forms.Form):
    age = forms.IntegerField(min_value=18, max_value=30)

form = AgeForm(data={'age': '25'})
valid = form.is_valid()

medium

A. True

B. False

C. Raises a TypeError

D. None

Solution

1. Step 1: Check field type and validation rules

   The age field is an IntegerField with min 18 and max 30, so '25' as string converts to integer 25, which is valid.

2. Step 2: Understand form.is_valid() behavior

   Since the data meets the validation rules, form.is_valid() returns True.

3. Final Answer:

   True -> Option A

4. Quick Check:

   Valid integer in range = True [OK]

Hint: IntegerField converts strings if valid number [OK]

Common Mistakes:

• Thinking string input causes error
• Assuming is_valid returns data instead of boolean
• Ignoring min_value and max_value constraints

4. Identify the error in this Django form class definition:

from django import forms

class ContactForm(forms.Form):
    email = forms.EmailField
    message = forms.CharField(widget=forms.Textarea)

medium

A. TextArea widget is invalid

B. forms.Form should be models.Form

C. Missing parentheses after EmailField

D. message field must be an EmailField

Solution

1. Step 1: Check field definitions for syntax

   Fields must be assigned with field instances, so EmailField() requires parentheses.

2. Step 2: Verify other parts

   Textarea widget is valid, forms.Form is correct base, and message can be CharField.

3. Final Answer:

   Missing parentheses after EmailField -> Option C

4. Quick Check:

   Field types need parentheses to create instances [OK]

Hint: Always add () after field types to create instances [OK]

Common Mistakes:

• Omitting parentheses after field classes
• Confusing widget names capitalization
• Using models.Form instead of forms.Form

5. You want to create a Django form class that only accepts a username if it starts with a letter and is at least 5 characters long. Which of these definitions correctly implements this using a custom validation method?

hard

A. class UsernameForm(forms.Form):
username = forms.CharField(min_length=5)
def clean_username(self):
data = self.cleaned_data['username']
if not data[0].isalpha():
raise forms.ValidationError('Must start with a letter')
return data

B. class UsernameForm(forms.Form):
username = forms.CharField(min_length=5)
def clean(self):
data = self.cleaned_data['username']
if not data[0].isalpha():
raise forms.ValidationError('Must start with a letter')
return data

C. class UsernameForm(forms.Form):
username = forms.CharField(min_length=5)
def clean_username(self):
data = self.cleaned_data['username']
if data[0].isdigit():
raise forms.ValidationError('Must start with a letter')
return data

D. class UsernameForm(forms.Form):
username = forms.CharField(min_length=5)
def clean_username(self):
data = self.cleaned_data['username']
if not data[0].isalpha():
return forms.ValidationError('Must start with a letter')
return data

Solution

1. Step 1: Understand custom field validation method

   To validate a single field, define clean_fieldname method that raises ValidationError on invalid data.

2. Step 2: Check each option's validation logic

   class UsernameForm(forms.Form): username = forms.CharField(min_length=5) def clean_username(self): data = self.cleaned_data['username'] if not data[0].isalpha(): raise forms.ValidationError('Must start with a letter') return data correctly checks if first character is a letter and raises ValidationError properly. class UsernameForm(forms.Form): username = forms.CharField(min_length=5) def clean(self): data = self.cleaned_data['username'] if not data[0].isalpha(): raise forms.ValidationError('Must start with a letter') return data uses clean() which is for whole form, not single field. class UsernameForm(forms.Form): username = forms.CharField(min_length=5) def clean_username(self): data = self.cleaned_data['username'] if data[0].isdigit(): raise forms.ValidationError('Must start with a letter') return data wrongly checks if first char is digit instead of not letter. class UsernameForm(forms.Form): username = forms.CharField(min_length=5) def clean_username(self): data = self.cleaned_data['username'] if not data[0].isalpha(): return forms.ValidationError('Must start with a letter') return data returns ValidationError instead of raising it.

3. Final Answer:

   class UsernameForm(forms.Form): username = forms.CharField(min_length=5) def clean_username(self): data = self.cleaned_data['username'] if not data[0].isalpha(): raise forms.ValidationError('Must start with a letter') return data -> Option A

4. Quick Check:

   Use clean_fieldname and raise ValidationError [OK]

Hint: Use clean_fieldname and raise ValidationError, not return it [OK]

Common Mistakes:

• Using clean() instead of clean_fieldname for single field
• Returning ValidationError instead of raising it
• Checking wrong condition for first character