Request parsing and response rendering in Django - Mini Project: Build & Apply

Request parsing and response rendering in Django

📖 Scenario: You are building a simple Django view that receives a user's name via a URL query parameter and returns a greeting message as an HTTP response.

🎯 Goal: Create a Django view function that parses the name parameter from the request's GET data and returns a plain text greeting message including that name.

📋 What You'll Learn

Create a Django view function named greet_user

Parse the name parameter from request.GET

Set a default name if name is not provided

Return an HttpResponse with a greeting message including the name

Use plain text content type in the response

💡 Why This Matters

🌍 Real World

Parsing request data and sending responses is a core part of building web applications with Django.

💼 Career

Understanding how to handle HTTP requests and responses is essential for backend web developers working with Django.

1

Create the Django view function

Create a Django view function called greet_user that takes a single parameter request.

Django

# Define the greet_user view function with request parameter
# Your code here

Hint

Start by defining a function named greet_user that accepts request as its only argument.

2

Parse the 'name' parameter from the request

Inside the greet_user function, create a variable called name that gets the name parameter from request.GET. Use "Guest" as the default value if name is not provided.

Django

from django.http import HttpResponse

def greet_user(request):
    # Get the 'name' parameter from request.GET with default 'Guest'
    # Your code here

Hint

Use request.GET.get('name', 'Guest') to safely get the name parameter or default to "Guest".

3

Create the greeting message

Still inside the greet_user function, create a variable called message that uses an f-string to say "Hello, {name}! Welcome to our site.".

Django

from django.http import HttpResponse

def greet_user(request):
    name = request.GET.get('name', 'Guest')
    # Create the greeting message using f-string
    # Your code here

Hint

Use an f-string to include the name variable inside the greeting message.

4

Return the HttpResponse with the greeting

Return an HttpResponse from the greet_user function with the message as content and set the content_type to "text/plain".

Django

from django.http import HttpResponse

def greet_user(request):
    name = request.GET.get('name', 'Guest')
    message = f"Hello, {name}! Welcome to our site."
    # Return HttpResponse with message and content_type 'text/plain'
    # Your code here

Hint

Use return HttpResponse(message, content_type='text/plain') to send the plain text response.

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