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.