File upload handling basics in Django - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the module needed to handle uploaded files in Django views.

Django

from django.core.files import [1]

Drag options to blanks, or click blank then click option'

Afiles

Buploadhandler

Cstorage

Dupload

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'uploadhandler' which is a different module.

Using 'storage' which is for file storage backends.

The django.core.files module provides classes and functions to handle uploaded files.

2fill in blank

medium

Complete the code to access the uploaded file from the request in a Django view.

Django

uploaded_file = request.FILES.get('[1]')

Drag options to blanks, or click blank then click option'

Aupload

Bimage

Cdocument

Dfile

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'upload' which is not the default input name.

Using 'image' or 'document' without matching the form input.

The key used in request.FILES matches the name attribute of the file input in the HTML form. Commonly, it is 'file'.

3fill in blank

hard

Fix the error in saving the uploaded file to disk by completing the missing method call.

Django

with open('uploads/' + uploaded_file.name, 'wb+') as destination:
    for chunk in uploaded_file.[1]():
        destination.write(chunk)

Drag options to blanks, or click blank then click option'

Achunks

Bread

Creadlines

Dgetchunks

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'read' which reads the whole file at once.

Using 'readlines' which is for text files line by line.

The chunks() method reads the uploaded file in small pieces to avoid memory issues.

4fill in blank

hard

Fill both blanks to create a Django form field that accepts file uploads and validates the file size.

Django

from django import forms

class UploadForm(forms.Form):
    file = forms.[1](required=True)

    def clean_file(self):
        file = self.cleaned_data.get('file')
        if file.size > [2]:
            raise forms.ValidationError('File too large')
        return file

Drag options to blanks, or click blank then click option'

AFileField

BCharField

C1000000

D1048576

Attempts:

3 left

💡 Hint

Common Mistakes

Using CharField which is for text input.

Setting size limit as 1000000 which is close but not exact 1MB.

FileField is used for file uploads in forms. The size limit is set in bytes; 1048576 bytes equals 1MB.

5fill in blank

hard

Fill all three blanks to write a Django view that saves an uploaded file using the default storage system.

Django

from django.core.files.storage import [1]

@csrf_exempt
def upload_view(request):
    if request.method == 'POST' and request.FILES.get('file'):
        uploaded_file = request.FILES['file']
        fs = [2]()
        filename = fs.[3](uploaded_file.name, uploaded_file)
        return HttpResponse(f'File saved as {filename}')
    return HttpResponse('Upload a file')

Drag options to blanks, or click blank then click option'

AFileSystemStorage

Csave

Dstore

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'store' which is not a method of FileSystemStorage.

Using a different storage class not imported.

FileSystemStorage is the default storage class. The save() method saves the file and returns the filename.

Practice

1. What is the main purpose of request.FILES in Django when handling file uploads?

easy

A. To access the uploaded file data sent by the user

B. To store form validation errors

C. To save files directly to the database

D. To send files from the server to the client

Solution

1. Step 1: Understand the role of request.FILES

   This attribute contains all files uploaded by the user in the current request.

2. Step 2: Differentiate from other request attributes

   request.POST holds form data, but request.FILES specifically holds file data.

3. Final Answer:

   To access the uploaded file data sent by the user -> Option A

4. Quick Check:

   File data = request.FILES [OK]

Hint: Remember: files come in request.FILES, not request.POST [OK]

Common Mistakes:

• Confusing request.FILES with request.POST
• Thinking files are saved automatically
• Assuming request.FILES is a file path

2. Which of the following is the correct way to define a file upload field in a Django form?

easy

A. file = forms.FileField()

B. file = forms.CharField()

C. file = models.FileField()

D. file = forms.ImageField()

Solution

1. Step 1: Identify form field types for file uploads

   forms.FileField() is used in forms to accept any file upload.

2. Step 2: Differentiate from model fields and other form fields

   models.FileField() is for models, not forms. forms.ImageField() is for images only.

3. Final Answer:

   file = forms.FileField() -> Option A

4. Quick Check:

   File upload field in form = FileField() [OK]

Hint: Use FileField() in forms, not CharField() or model fields [OK]

Common Mistakes:

• Using CharField instead of FileField
• Confusing model fields with form fields
• Using ImageField for non-image files

3. Given this Django view snippet handling a file upload:

def upload_file(request):
    if request.method == 'POST':
        uploaded_file = request.FILES['file']
        with open('uploaded.txt', 'wb+') as destination:
            for chunk in uploaded_file.chunks():
                destination.write(chunk)
    return HttpResponse('Upload complete')

What will happen if the uploaded file is large?

medium

A. The file will cause a memory error because it is read all at once

B. The file will be saved in chunks to avoid memory issues

C. The file will be saved as text instead of binary

D. The file upload will fail because chunks() is not a valid method

Solution

1. Step 1: Understand the use of chunks() method

   The chunks() method reads the uploaded file in small parts to avoid loading the entire file into memory.

2. Step 2: Analyze the file saving logic

   The code writes each chunk to the file, so large files are handled safely without memory errors.

3. Final Answer:

   The file will be saved in chunks to avoid memory issues -> Option B

4. Quick Check:

   chunks() saves large files safely [OK]

Hint: chunks() method helps save large files safely [OK]

Common Mistakes:

• Assuming chunks() reads whole file at once
• Thinking chunks() is invalid method
• Ignoring binary write mode 'wb+'

4. Identify the error in this Django view code for file upload:

def upload(request):
    if request.method == 'POST':
        file = request.POST['file']
        with open('file.txt', 'wb') as f:
            f.write(file.read())
    return HttpResponse('Done')

medium

A. Missing form validation before saving the file

B. Opening the file in write mode instead of append mode

C. Using request.POST instead of request.FILES to get the file

D. Not checking if the request method is GET

Solution

1. Step 1: Check how the uploaded file is accessed

   The code uses request.POST['file'], but uploaded files are in request.FILES.

2. Step 2: Understand the impact of this mistake

   Accessing the file from request.POST will cause a KeyError or wrong data type error.

3. Final Answer:

   Using request.POST instead of request.FILES to get the file -> Option C

4. Quick Check:

   Files come from request.FILES, not request.POST [OK]

Hint: Always get files from request.FILES, not request.POST [OK]

Common Mistakes:

• Using request.POST for files
• Not opening file in binary mode
• Ignoring request method check

5. You want to save an uploaded file in Django but only if its size is less than 2MB. Which code snippet correctly checks the file size before saving?

hard

A. if uploaded_file.length < 2 * 1024 * 1024:
with open('file.txt', 'w') as f:
f.write(uploaded_file)

B. if len(uploaded_file) < 2 * 1024 * 1024:
with open('file.txt', 'wb+') as f:
f.write(uploaded_file.read())

C. if uploaded_file.size > 2 * 1024 * 1024:
with open('file.txt', 'wb+') as f:
for chunk in uploaded_file.chunks():
f.write(chunk)

D. if uploaded_file.size < 2 * 1024 * 1024:
with open('file.txt', 'wb+') as f:
for chunk in uploaded_file.chunks():
f.write(chunk)

Solution

1. Step 1: Check the correct attribute for file size

   The size attribute gives the file size in bytes.

2. Step 2: Verify the condition and saving method

   The condition checks if size is less than 2MB (2 * 1024 * 1024 bytes). The file is saved in chunks to handle large files safely.

3. Final Answer:

   if uploaded_file.size < 2 * 1024 * 1024: with open('file.txt', 'wb+') as f: for chunk in uploaded_file.chunks(): f.write(chunk) -> Option D

4. Quick Check:

   Use uploaded_file.size and chunks() to save safely [OK]

Hint: Use uploaded_file.size to check size before saving [OK]

Common Mistakes:

• Using len() or length instead of size
• Opening file in text mode 'w' instead of binary
• Checking size with wrong comparison operator