File upload handling basics in Django - Mini Project: Build & Apply

File upload handling basics

📖 Scenario: You are building a simple Django web app where users can upload a profile picture. This project will guide you through setting up the data model, configuring the upload settings, writing the view to handle the file upload, and completing the template to show the upload form.

🎯 Goal: Build a Django app that allows users to upload a file and saves it to the server. The app will display a form to upload a profile picture and save the uploaded file in the model.

📋 What You'll Learn

Create a Django model with a FileField to store the uploaded file

Add a setting variable for the upload directory

Write a view function to handle the file upload and save it

Create a template with a form that allows file upload

💡 Why This Matters

🌍 Real World

File uploads are common in web apps for user profile pictures, documents, or media content. Handling uploads correctly is essential for user interaction.

💼 Career

Understanding file upload handling is a key skill for backend and full-stack developers working with Django or similar web frameworks.

1

Create the model with a FileField

Create a Django model called Profile in models.py with a profile_picture field using models.FileField and set upload_to='uploads/'.

Django

# Your code here

Hint

Use models.FileField with the upload_to parameter to specify the folder.

2

Add upload directory setting

In settings.py, add a variable called MEDIA_ROOT and set it to BASE_DIR / 'media'. Also add MEDIA_URL = '/media/'.

Django

from django.db import models

class Profile(models.Model):
    profile_picture = models.FileField(upload_to='uploads/')

# Your code here

Hint

Use BASE_DIR / 'media' to set the media root folder for uploads.

3

Write the view to handle file upload

In views.py, write a function called upload_profile_picture that handles a POST request. Use request.FILES['profile_picture'] to get the uploaded file, create a Profile instance with it, and save it.

Django

from django.db import models

class Profile(models.Model):
    profile_picture = models.FileField(upload_to='uploads/')

# In settings.py
MEDIA_ROOT = BASE_DIR / 'media'
MEDIA_URL = '/media/'

# Your code here

Hint

Check if the request method is POST and the file is in request.FILES. Then create and save the model instance.

4

Create the upload form template

Create a template called upload.html with a form that uses method='POST' and enctype='multipart/form-data'. Add a file input with name='profile_picture' and a submit button.

Django

from django.db import models

class Profile(models.Model):
    profile_picture = models.FileField(upload_to='uploads/')

# In settings.py
MEDIA_ROOT = BASE_DIR / 'media'
MEDIA_URL = '/media/'

from django.shortcuts import render
from .models import Profile


def upload_profile_picture(request):
    if request.method == 'POST' and 'profile_picture' in request.FILES:
        uploaded_file = request.FILES['profile_picture']
        profile = Profile(profile_picture=uploaded_file)
        profile.save()

Hint

Remember to add enctype='multipart/form-data' to the form tag for file uploads.

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