Process request and process response in Django - Step-by-Step Execution

Concept Flow - Process request and process response

Client sends HTTP request

↓

Django receives request

↓

Middleware processes request

↓

URL Dispatcher matches URL

↓

View function executes

↓

View returns HTTP response

↓

Middleware processes response

↓

Django sends HTTP response back to client

This flow shows how Django handles a web request from client to server and back, passing through middleware, URL routing, and views.

Execution Sample

Django

from django.http import HttpResponse

def my_view(request):
    name = request.GET.get('name', 'Guest')
    return HttpResponse(f'Hello, {name}!')

A simple Django view that reads a query parameter from the request and returns a personalized greeting in the response.

Execution Table

Step	Action	Request State	Response State	Output
1	Client sends GET /?name=Alice	Empty	None	Request with path '/' and GET param name=Alice
2	Django receives request	Request with path '/' and GET param name=Alice	None	Request object created
3	Middleware processes request	Request with path '/' and GET param name=Alice	None	Request possibly modified
4	URL Dispatcher matches '/' to my_view	Request with path '/' and GET param name=Alice	None	my_view selected
5	my_view executes: reads name='Alice'	Request with GET param name=Alice	None	Variable name='Alice'
6	my_view returns HttpResponse('Hello, Alice!')	Request unchanged	Response with content 'Hello, Alice!'	Response created
7	Middleware processes response	Request unchanged	Response with content 'Hello, Alice!'	Response possibly modified
8	Django sends response back to client	Request unchanged	Response with content 'Hello, Alice!'	Client receives 'Hello, Alice!'
9	End	Request unchanged	Response sent	Process complete

💡 Response sent back to client, request-response cycle ends

Variable Tracker

Variable	Start	After Step 5	After Step 6	Final
request.GET	Empty	{'name': 'Alice'}	{'name': 'Alice'}	{'name': 'Alice'}
name	Undefined	'Alice'	'Alice'	'Alice'
response	None	None	HttpResponse('Hello, Alice!')	HttpResponse('Hello, Alice!')

Key Moments - 3 Insights

Why do we access request.GET to get query parameters?

Because Django stores URL query parameters in request.GET dictionary, as shown in step 5 where name is read from request.GET.

What happens if the view returns a response?

The response is passed back through middleware (step 7) before Django sends it to the client (step 8), as shown in the execution table.

Can middleware change the request or response?

Yes, middleware can modify both request and response objects, as indicated in steps 3 and 7 where middleware processes them.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'name' variable at step 5?

A None

B 'Alice'

C 'Guest'

D Undefined

💡 Hint

Check the 'Action' and 'Output' columns at step 5 where 'name' is assigned from request.GET

At which step does Django match the URL to the view function?

A Step 2

B Step 6

C Step 4

D Step 7

💡 Hint

Look for the step mentioning 'URL Dispatcher matches' in the execution table

If the client sends a request without 'name' parameter, what would 'name' be in the view?

A 'Guest'

B None

C 'Alice'

D Error

💡 Hint

Look at the code where request.GET.get('name', 'Guest') provides a default value

Concept Snapshot

Django request-response cycle:
1. Client sends HTTP request
2. Django creates request object
3. Middleware processes request
4. URL dispatcher finds matching view
5. View reads request data and returns response
6. Middleware processes response
7. Django sends response back
Use request.GET to read query params
View returns HttpResponse with content

Full Transcript

This visual execution shows how Django processes a web request and response. The client sends an HTTP request with a URL and optional query parameters. Django receives this request and creates a request object. Middleware can modify the request before it reaches the URL dispatcher. The URL dispatcher matches the request path to a view function. The view reads data from the request, such as query parameters from request.GET, and returns an HttpResponse. This response passes back through middleware, which can modify it. Finally, Django sends the response back to the client. The example view reads a 'name' parameter and returns a greeting. If 'name' is missing, it defaults to 'Guest'. This cycle is fundamental to how Django handles web interactions.

Practice

1. What does the request object in a Django view primarily contain?

easy

A. Information sent by the user, like form data and headers

B. The HTML template to render

C. The final content sent back to the user

D. Database connection details

Solution

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

   The request object holds all data sent by the user, such as form inputs, cookies, and headers.

2. Step 2: Differentiate request from response

   The response object is what the server sends back, not the request.

3. Final Answer:

   Information sent by the user, like form data and headers -> Option A

4. Quick Check:

   Request = User data [OK]

Hint: Request holds user input; response sends output [OK]

Common Mistakes:

• Confusing request with response
• Thinking request contains templates
• Assuming request holds server data

2. Which of the following is the correct way to return a simple text response in a Django view?

easy

A. return HttpResponse('Hello World')

B. return render('Hello World')

C. return JsonResponse('Hello World')

D. return redirect('Hello World')

Solution

1. Step 1: Identify the correct response class for text

   HttpResponse is used to send plain text or HTML content back to the user.

2. Step 2: Check other options

   render is for templates, JsonResponse for JSON data, redirect for URL redirects.

3. Final Answer:

   return HttpResponse('Hello World') -> Option A

4. Quick Check:

   Text response uses HttpResponse [OK]

Hint: Use HttpResponse for plain text output [OK]

Common Mistakes:

• Using render without a template
• Using JsonResponse for plain text
• Confusing redirect with response content

3. Given this Django view code, what will be the output when accessed?

from django.http import JsonResponse

def my_view(request):
    data = {'name': 'Alice', 'age': 30}
    return JsonResponse(data)

medium

A. name=Alice&age=30

B. {'name': 'Alice', 'age': 30}

C. {"name": "Alice", "age": 30}

D. An error because JsonResponse needs a string

Solution

1. Step 1: Understand JsonResponse output format

   JsonResponse converts the Python dictionary into a JSON string with double quotes.

2. Step 2: Check the output format

   The output is a JSON string: {"name": "Alice", "age": 30} with double quotes, not Python dict syntax.

3. Final Answer:

   {"name": "Alice", "age": 30} -> Option C

4. Quick Check:

   JsonResponse outputs JSON string [OK]

Hint: JsonResponse outputs JSON with double quotes [OK]

Common Mistakes:

• Expecting Python dict syntax in output
• Confusing URL query string with JSON
• Thinking JsonResponse needs string input

4. What is wrong with this Django view code?

from django.http import HttpResponse

def bad_view(request):
    response = HttpResponse('Hello')
    response.status_code = '404'
    return response

medium

A. HttpResponse cannot have status_code set manually

B. status_code must be an integer, not a string

C. Missing return statement

D. HttpResponse requires a JSON object

Solution

1. Step 1: Check the status_code assignment

   Status codes must be integers like 404, not strings like '404'.

2. Step 2: Confirm HttpResponse usage

   HttpResponse allows setting status_code manually but it must be int.

3. Final Answer:

   status_code must be an integer, not a string -> Option B

4. Quick Check:

   status_code = int, not string [OK]

Hint: status_code must be int, not string [OK]

Common Mistakes:

• Using string for status_code
• Thinking HttpResponse forbids status_code
• Forgetting to return response

5. You want to create a Django view that processes a POST request with JSON data and returns a JSON response with a message and the original data. Which code snippet correctly handles this?

hard

A. def view(request):
data = request.GET
return JsonResponse({'message': 'Received', 'data': data})

B. def view(request):
data = request.POST
return HttpResponse({'message': 'Received', 'data': data})

C. def view(request):
data = request.body
return JsonResponse(data)

D. def view(request):
data = json.loads(request.body)
return JsonResponse({'message': 'Received', 'data': data})

Solution

1. Step 1: Parse JSON from POST request body

   request.body contains raw bytes; json.loads converts it to a Python dict.

2. Step 2: Return JsonResponse with message and data

   JsonResponse correctly serializes the Python dict to JSON for response.

3. Step 3: Check other options

   def view(request): data = request.POST return HttpResponse({'message': 'Received', 'data': data}) wrongly uses HttpResponse with dict, def view(request): data = request.GET return JsonResponse({'message': 'Received', 'data': data}) uses GET instead of POST, def view(request): data = request.body return JsonResponse(data) returns raw bytes without parsing.

4. Final Answer:

   def view(request): data = json.loads(request.body) return JsonResponse({'message': 'Received', 'data': data}) -> Option D

5. Quick Check:

   Parse JSON body, respond with JsonResponse [OK]

Hint: Parse JSON from request.body, respond with JsonResponse [OK]

Common Mistakes:

• Using request.POST for JSON body
• Returning dict in HttpResponse
• Not parsing JSON before response