File upload handling basics in Django - Step-by-Step Execution

Concept Flow - File upload handling basics

User selects file in form

↓

Form submits POST request

↓

Django view receives request

↓

Access file in request.FILES

↓

Save file to model or disk

↓

Return response to user

This flow shows how a user uploads a file via a form, Django receives it, accesses the file in request.FILES, saves it, and responds.

Execution Sample

Django

from django.http import HttpResponse

def upload_file(request):
    if request.method == 'POST':
        uploaded_file = request.FILES['file']
        with open('uploads/' + uploaded_file.name, 'wb+') as f:
            for chunk in uploaded_file.chunks():
                f.write(chunk)
        return HttpResponse('File uploaded')
    return HttpResponse('Upload a file')

This Django view handles a POST request with a file, saves it in chunks to disk, and returns a confirmation.

Execution Table

Step	Action	Request Method	request.FILES Content	File Write Action	Response
1	User submits form	POST	{'file': <UploadedFile>}	No write yet	No response yet
2	View checks method	POST	{'file': <UploadedFile>}	No write yet	No response yet
3	Access uploaded_file	POST	<UploadedFile object>	No write yet	No response yet
4	Open file for writing	POST	<UploadedFile object>	File opened for writing	No response yet
5	Write chunk 1	POST	<UploadedFile object>	Chunk 1 written	No response yet
6	Write chunk 2	POST	<UploadedFile object>	Chunk 2 written	No response yet
7	Finish writing file	POST	<UploadedFile object>	All chunks written	No response yet
8	Return response	POST	<UploadedFile object>	File closed	HttpResponse('File uploaded')

💡 File fully written and response sent to user confirming upload

Variable Tracker

Variable	Start	After Step 3	After Step 7	Final
request.method	GET or POST	POST	POST	POST
request.FILES	{}	{'file': <UploadedFile>}	{'file': <UploadedFile>}	{'file': <UploadedFile>}
uploaded_file	None	<UploadedFile object>	<UploadedFile object>	<UploadedFile object>
file write status	None	Not started	Writing chunks	Completed

Key Moments - 3 Insights

Why do we use request.FILES instead of request.POST to get the uploaded file?

Because uploaded files are sent in a special part of the request called FILES, not in POST data. See execution_table step 3 where uploaded_file is accessed from request.FILES.

Why do we write the file in chunks instead of all at once?

Writing in chunks helps handle large files without using too much memory. Execution_table steps 5 and 6 show writing chunk by chunk.

What happens if the request method is not POST?

The view does not process the file upload and skips writing. This is shown in execution_table step 2 where method check happens.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the uploaded file first accessed in the code?

A Step 3

B Step 5

C Step 2

D Step 8

💡 Hint

Check the 'Action' and 'request.FILES Content' columns in execution_table rows.

According to variable_tracker, what is the value of 'uploaded_file' after step 7?

A Empty file

B <UploadedFile object>

C None

D File path string

💡 Hint

Look at the 'uploaded_file' row and the 'After Step 7' column in variable_tracker.

If the request method was GET instead of POST, what would happen according to the execution flow?

A File would be saved anyway

B File would be accessed but not saved

C File upload code would be skipped

D An error would occur

💡 Hint

Refer to execution_table step 2 where method check decides the flow.

Concept Snapshot

Django file upload basics:
- Use <form method='POST' enctype='multipart/form-data'>
- Access files via request.FILES['file'] in view
- Save file in chunks to handle large files
- Check request.method == 'POST' before processing
- Return response after saving file

Full Transcript

This visual trace shows how Django handles file uploads step-by-step. The user selects a file and submits a form with POST method. Django view checks the request method, then accesses the uploaded file from request.FILES. The file is saved in chunks to disk to avoid memory issues. After writing all chunks, the view returns a confirmation response. Variables like request.method and uploaded_file change as the code runs. Key points include using request.FILES for files, writing in chunks, and processing only POST requests.

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