When async helps and when it does not in Django - Mini Project: Build & Apply

When async helps and when it does not in Django

📖 Scenario: You are building a Django web application that fetches data from an external API and also processes some local database queries.You want to understand when using asynchronous views can improve your app's performance and when it might not help.

🎯 Goal: Create a simple Django view that fetches data from an external API asynchronously and also performs a local database query synchronously.This will help you see when async helps (waiting for external API) and when it does not (database query blocking).

📋 What You'll Learn

Create a Django view function named fetch_data

Use the httpx library to fetch data asynchronously from https://jsonplaceholder.typicode.com/todos/1

Perform a synchronous query to get all objects from a model named Item

Return a JsonResponse combining the external API data and the count of Item objects

Use async def for the view and await the external API call

💡 Why This Matters

🌍 Real World

Many web apps fetch data from external services and query local databases. Knowing when async helps improves performance and user experience.

💼 Career

Understanding async in Django is important for backend developers to write efficient, scalable web applications.

1

Setup the Django model and import statements

Create a Django model named Item with a single field name as a CharField with max length 100. Also import JsonResponse from django.http and httpx at the top of your views.py file.

Django

from django.db import models
from django.http import JsonResponse
import httpx

# Your code here

Hint

Define the Item model with one field name. Import JsonResponse and httpx at the top.

2

Add the async view function with external API URL

Create an async view function named fetch_data that sets a variable api_url to 'https://jsonplaceholder.typicode.com/todos/1'.

Django

from django.db import models
from django.http import JsonResponse
import httpx

class Item(models.Model):
    name = models.CharField(max_length=100)

async def fetch_data(request):
    # Define the API URL
    # Your code here

Hint

Define an async function fetch_data and set api_url to the given URL string.

3

Fetch external API data asynchronously and query local database synchronously

Inside the fetch_data function, use async with httpx.AsyncClient() as client to await client.get(api_url) and store the JSON response in external_data. Then query all Item objects synchronously with items = Item.objects.all().

Django

from django.db import models
from django.http import JsonResponse
import httpx

class Item(models.Model):
    name = models.CharField(max_length=100)

async def fetch_data(request):
    api_url = 'https://jsonplaceholder.typicode.com/todos/1'
    # Fetch external API data asynchronously
    # Query local database synchronously
    # Your code here

Hint

Use async with and await to get the external API data. Then query Item.objects.all() synchronously.

4

Return combined JsonResponse with external data and item count

At the end of fetch_data, return a JsonResponse with a dictionary containing 'external' key set to external_data and 'item_count' key set to items.count().

Django

from django.db import models
from django.http import JsonResponse
import httpx

class Item(models.Model):
    name = models.CharField(max_length=100)

async def fetch_data(request):
    api_url = 'https://jsonplaceholder.typicode.com/todos/1'
    async with httpx.AsyncClient() as client:
        response = await client.get(api_url)
        external_data = response.json()
    items = Item.objects.all()
    # Return JsonResponse combining external_data and item count
    # Your code here

Hint

Return a JsonResponse with keys 'external' and 'item_count' using the variables you created.

Practice

1. Which scenario best shows when Django's async features help improve performance?

easy

A. Handling many simultaneous network requests without blocking

B. Performing heavy calculations on the CPU

C. Rendering a simple HTML template synchronously

D. Writing data to a local file synchronously

Solution

1. Step 1: Understand async strengths

   Async in Django helps when tasks involve waiting, like network calls, allowing other tasks to run meanwhile.

2. Step 2: Match scenario to async use

   Handling many network requests fits async well because it avoids waiting and blocking the server.

3. Final Answer:

   Handling many simultaneous network requests without blocking -> Option A

4. Quick Check:

   Async helps with waiting tasks = A [OK]

Hint: Async helps when waiting, not heavy CPU work [OK]

Common Mistakes:

• Thinking async speeds up CPU-heavy tasks
• Assuming async helps synchronous file writes
• Confusing async with faster template rendering

2. Which of the following is the correct way to declare an async view in Django?

easy

A. def my_view(request):

B. async def my_view(request):

C. def async my_view(request):

D. async my_view(request):

Solution

1. Step 1: Recall async function syntax in Python

   Async functions start with the keyword 'async' before 'def'.

2. Step 2: Apply to Django view declaration

   The correct syntax is 'async def my_view(request):' to define an async view.

3. Final Answer:

   async def my_view(request): -> Option B

4. Quick Check:

   Async function syntax = D [OK]

Hint: Async functions start with 'async def' in Python [OK]

Common Mistakes:

• Omitting 'def' after 'async'
• Placing 'async' after 'def'
• Using 'async' without 'def'

3. Consider this Django async view snippet:

async def fetch_data(request):
    data = await some_network_call()
    return JsonResponse({'result': data})

What happens if some_network_call() is a slow network request?

medium

A. The server crashes due to await usage

B. The server blocks and waits until the call finishes

C. The view returns immediately with empty data

D. The server can handle other requests while waiting

Solution

1. Step 1: Understand 'await' in async views

   The 'await' keyword pauses this view but lets the server handle other tasks meanwhile.

2. Step 2: Effect on server behavior

   Because of 'await', the server does not block and can serve other requests during the slow network call.

3. Final Answer:

   The server can handle other requests while waiting -> Option D

4. Quick Check:

   Await allows concurrency = A [OK]

Hint: Await pauses task but frees server for others [OK]

Common Mistakes:

• Thinking await blocks the whole server
• Assuming immediate return without data
• Believing await causes server crash

4. You wrote this async Django view:

async def cpu_task(request):
    result = heavy_calculation()
    return JsonResponse({'value': result})

Why might this cause performance issues?

medium

A. Because heavy_calculation() is synchronous and blocks the event loop

B. Because async views cannot return JsonResponse

C. Because async views must not have return statements

D. Because heavy_calculation() is awaited incorrectly

Solution

1. Step 1: Identify sync call inside async view

   The function heavy_calculation() is synchronous and CPU-heavy, called without await.

2. Step 2: Understand impact on async event loop

   This blocks the async event loop, preventing other tasks from running concurrently, hurting performance.

3. Final Answer:

   Because heavy_calculation() is synchronous and blocks the event loop -> Option A

4. Quick Check:

   Sync CPU work blocks async loop = B [OK]

Hint: Sync CPU tasks block async event loop, causing lag [OK]

Common Mistakes:

• Thinking async views can't return JsonResponse
• Believing return statements are forbidden in async views
• Assuming heavy_calculation() is awaited automatically

5. You want to optimize a Django app that reads many files and processes data. Which approach best uses async to improve performance?

hard

A. Keep everything synchronous to avoid complexity

B. Make all processing CPU-heavy tasks async without changing file reading

C. Make file reading async and process data in small CPU chunks synchronously

D. Use async only for database queries, not file reading or processing

Solution

1. Step 1: Identify async benefits for I/O tasks

   Async helps with waiting tasks like file reading, allowing other tasks to run meanwhile.

2. Step 2: Combine async I/O with sync CPU processing

   Processing CPU-heavy data synchronously in small chunks avoids blocking the event loop too long.

3. Final Answer:

   Make file reading async and process data in small CPU chunks synchronously -> Option C

4. Quick Check:

   Async for I/O, sync for CPU work = C [OK]

Hint: Use async for waiting tasks, sync for CPU work [OK]

Common Mistakes:

• Making CPU-heavy tasks async without benefit
• Ignoring async for file reading
• Avoiding async due to complexity fears