Request parsing and response rendering in Django

Introduction

Request parsing helps your Django app understand what the user sends. Response rendering sends back the right information to the user.

When you want to get data from a user submitting a form or API call.

When you need to send HTML pages or JSON data back to the user.

When building APIs that accept JSON and return JSON responses.

When handling file uploads or complex data from users.

When you want to customize how data is shown to users.

Syntax

Django

from django.http import JsonResponse, HttpResponse
from django.views.decorators.csrf import csrf_exempt
import json

@csrf_exempt
def my_view(request):
    if request.method == 'POST':
        data = json.loads(request.body.decode('utf-8'))  # parse JSON request
        response_data = {'message': f"Hello, {data.get('name', 'Guest')}!"}
        return JsonResponse(response_data)  # render JSON response
    else:
        return HttpResponse('Send a POST request with JSON data.')

Use request.body to get raw data sent by the user.

JsonResponse helps send JSON data back easily.

Examples

This reads JSON data sent by the user in the request body.

Django

data = json.loads(request.body.decode('utf-8'))

This sends a JSON response with the given dictionary.

Django

return JsonResponse({'key': 'value'})

This sends a plain text response to the user.

Django

return HttpResponse('Hello world', content_type='text/plain')

Sample Program

This Django view accepts POST requests with JSON data containing a 'name'. It responds with a JSON greeting. If the JSON is invalid, it returns an error. For other request types, it sends a simple text message.

Django

from django.http import JsonResponse, HttpResponse
from django.views.decorators.csrf import csrf_exempt
import json

@csrf_exempt
def greet_user(request):
    if request.method == 'POST':
        try:
            data = json.loads(request.body.decode('utf-8'))
            name = data.get('name', 'Guest')
            response = {'greeting': f'Hello, {name}!'}
            return JsonResponse(response)
        except json.JSONDecodeError:
            return JsonResponse({'error': 'Invalid JSON'}, status=400)
    else:
        return HttpResponse('Please send a POST request with JSON data.', content_type='text/plain')

Important Notes

Remember to disable CSRF protection for API views or handle tokens properly.

Always check the request method before parsing data.

Use JsonResponse to automatically set the right headers for JSON.

Summary

Request parsing reads user data from the request body, often JSON.

Response rendering sends data back, like JSON or plain text.

Django provides easy tools like json.loads and JsonResponse to handle these tasks.

Practice

1. What is the main purpose of JsonResponse in Django?

easy

A. To send JSON data back to the client as an HTTP response

B. To parse JSON data from the client's request body

C. To convert Python objects into HTML templates

D. To handle file uploads in a Django view

Solution

1. Step 1: Understand JsonResponse role

   JsonResponse is a Django class that formats Python data as JSON and sends it as an HTTP response.

2. Step 2: Differentiate from request parsing

   Parsing JSON from requests is done with json.loads() or similar, not JsonResponse.

3. Final Answer:

   To send JSON data back to the client as an HTTP response -> Option A

4. Quick Check:

   JsonResponse sends JSON responses [OK]

Hint: JsonResponse sends data out, not reads it in [OK]

Common Mistakes:

• Confusing JsonResponse with JSON parsing
• Thinking JsonResponse parses request data
• Mixing up response rendering with template rendering

2. Which of the following is the correct way to parse JSON data from a Django request object named request?

easy

A. data = request.json()

B. data = json.dumps(request.body)

C. data = JsonResponse(request.body)

D. data = json.loads(request.body)

Solution

1. Step 1: Identify JSON parsing method

   To convert JSON string to Python object, use json.loads().

2. Step 2: Apply to request body

   request.body contains raw bytes, so decode if needed, then parse with json.loads().

3. Final Answer:

   data = json.loads(request.body) -> Option D

4. Quick Check:

   json.loads parses JSON string [OK]

Hint: Use json.loads to read JSON from request body [OK]

Common Mistakes:

• Using json.dumps instead of json.loads
• Calling non-existent request.json() method
• Using JsonResponse to parse input

3. Given this Django view code, what will be the HTTP response content?

from django.http import JsonResponse
import json

def my_view(request):
    data = json.loads(request.body)
    result = {"message": f"Hello, {data['name']}!"}
    return JsonResponse(result)

And the client sends JSON body: {"name": "Alice"}

medium

A. Hello, Alice!

B. {"message": "Hello, {data['name']}!"}

C. {"message": "Hello, Alice!"}

D. SyntaxError

Solution

1. Step 1: Parse JSON from request body

   The code uses json.loads(request.body) to get a Python dict with key 'name' and value 'Alice'.

2. Step 2: Format message and return JsonResponse

   The message string becomes "Hello, Alice!" and is wrapped in a dict, then sent as JSON response.

3. Final Answer:

   {"message": "Hello, Alice!"} -> Option C

4. Quick Check:

   JsonResponse sends formatted JSON string [OK]

Hint: JsonResponse returns JSON string with keys and values [OK]

Common Mistakes:

• Thinking JsonResponse returns plain text
• Confusing string interpolation syntax
• Expecting raw Python dict as response

4. What is wrong with this Django view code snippet for parsing JSON?

def my_view(request):
    data = json.loads(request.POST)
    return JsonResponse({"status": "ok"})

medium

A. request.POST is empty for GET requests only

B. request.POST is not a JSON string, so json.loads will fail

C. The function must return a string, not JsonResponse

D. JsonResponse cannot be used without importing

Solution

1. Step 1: Understand request.POST content

   request.POST is a QueryDict, not a JSON string, so passing it to json.loads() causes an error.

2. Step 2: Correct JSON parsing method

   To parse JSON, use json.loads(request.body) instead, since request.body contains raw JSON bytes.

3. Final Answer:

   request.POST is not a JSON string, so json.loads will fail -> Option B

4. Quick Check:

   json.loads needs JSON string, not QueryDict [OK]

Hint: Use request.body for JSON, not request.POST [OK]

Common Mistakes:

• Passing request.POST to json.loads
• Assuming JsonResponse needs string return
• Ignoring HTTP method differences

5. You want to create a Django view that accepts JSON with a list of numbers under key values, sums them, and returns the sum as JSON. Which code correctly implements this?

hard

A. def sum_view(request):
data = json.loads(request.body)
total = sum(data['values'])
return JsonResponse({'sum': total})

B. def sum_view(request):
total = sum(request.POST.getlist('values'))
return JsonResponse({'sum': total})

C. def sum_view(request):
data = json.dumps(request.body)
total = sum(data['values'])
return JsonResponse({'sum': total})

D. def sum_view(request):
total = sum(request.GET['values'])
return JsonResponse({'sum': total})

Solution

1. Step 1: Parse JSON body correctly

   Use json.loads(request.body) to get Python dict from JSON input.

2. Step 2: Sum the list and return JSON response

   Extract the list under 'values', sum it, and return with JsonResponse.

3. Final Answer:

   def sum_view(request): data = json.loads(request.body) total = sum(data['values']) return JsonResponse({'sum': total}) -> Option A

4. Quick Check:

   Parse JSON body, sum list, return JsonResponse [OK]

Hint: Parse JSON body, then sum list, then JsonResponse [OK]

Common Mistakes:

• Using json.dumps instead of json.loads
• Trying to sum QueryDict values directly
• Using request.GET or request.POST for JSON body