Async views basics in Django - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define an async view function in Django.

Django

from django.http import JsonResponse

async def my_view(request):
    data = {'message': 'Hello, async!'}
    return [1](data)

Drag options to blanks, or click blank then click option'

AJsonResponse

BHttpResponse

Crender

Dredirect

Attempts:

3 left

💡 Hint

Common Mistakes

Using HttpResponse without JSON formatting

Trying to use render which expects a template

Returning redirect which is for URL redirection

The async view should return a JsonResponse to send JSON data back to the client.

2fill in blank

medium

Complete the code to await an async function inside the async view.

Django

import asyncio
from django.http import JsonResponse

async def fetch_data():
    await asyncio.sleep(1)
    return {'status': 'done'}

async def my_view(request):
    result = [1] fetch_data()
    return JsonResponse(result)

Drag options to blanks, or click blank then click option'

Afetch_data

Bawait

Casync

Dyield

Attempts:

3 left

💡 Hint

Common Mistakes

Calling the async function without await causing a coroutine object to be returned

Using async keyword incorrectly inside the function body

Using yield which is for generators

Inside an async function, you use await to wait for another async function to finish.

3fill in blank

hard

Fix the error in the async view by completing the code to import the correct decorator.

Django

from django.http import JsonResponse
from django.views.decorators.csrf import [1]

@[1]  # Decorator to exempt CSRF for async view
async def my_view(request):
    return JsonResponse({'message': 'No CSRF check'})

Drag options to blanks, or click blank then click option'

Acache_page

Blogin_required

Crequire_http_methods

Dcsrf_exempt

Attempts:

3 left

💡 Hint

Common Mistakes

Using login_required which is for authentication

Using require_http_methods which restricts HTTP methods

Using cache_page which caches the response

The csrf_exempt decorator disables CSRF checks, which is often needed for async views handling POST requests.

4fill in blank

hard

Fill both blanks to create an async view that reads a query parameter and returns it in JSON.

Django

from django.http import JsonResponse

async def echo_view(request):
    param = request.GET.get([1], 'default')
    return JsonResponse([2]: param)

Drag options to blanks, or click blank then click option'

A'name'

B'value'

C'param'

D'key'

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong keys causing missing data

Not using quotes around string keys

Mixing up parameter and JSON keys

The query parameter key is 'name', and the JSON response key is 'param' to return the value.

5fill in blank

hard

Fill all three blanks to create an async view that waits for two async tasks and returns combined results.

Django

import asyncio
from django.http import JsonResponse

async def task1():
    await asyncio.sleep(1)
    return 'first'

async def task2():
    await asyncio.sleep(1)
    return 'second'

async def combined_view(request):
    result1, result2 = await asyncio.gather([1](), [2]())
    return JsonResponse([3]: f'{result1} and {result2}')

Drag options to blanks, or click blank then click option'

Atask1

Btask2

C'result'

D'output'

Attempts:

3 left

💡 Hint

Common Mistakes

Calling functions without parentheses

Using wrong keys in JSON response

Not awaiting both tasks together

Use task1 and task2 functions in asyncio.gather, and return JSON with key 'result'.

Practice

1. What is the main benefit of using async views in Django?

easy

A. They allow Django to handle many requests without waiting for slow tasks.

B. They automatically speed up CPU-heavy calculations.

C. They replace the need for a database in your app.

D. They make your app use less memory by default.

Solution

1. Step 1: Understand what async views do

   Async views let Django pause a request while waiting for slow tasks like network calls, so it can handle other requests meanwhile.

2. Step 2: Compare options to this behavior

   Only They allow Django to handle many requests without waiting for slow tasks. correctly describes this benefit. Options B, C, and D are incorrect because async views do not speed up CPU tasks, replace databases, or reduce memory automatically.

3. Final Answer:

   They allow Django to handle many requests without waiting for slow tasks. -> Option A

4. Quick Check:

   Async views improve concurrency = A [OK]

Hint: Async views help handle many requests without blocking [OK]

Common Mistakes:

• Thinking async speeds up CPU-heavy tasks
• Believing async removes the need for a database
• Assuming async reduces memory usage automatically

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

easy

A. def my_view(request): return HttpResponse('Hello')

B. async def my_view(request): return HttpResponse('Hello')

C. async def my_view(request): await HttpResponse('Hello')

D. def async my_view(request): return HttpResponse('Hello')

Solution

1. Step 1: Recall async view syntax

   Async views must be defined with async def and can return a response directly.

2. Step 2: Check each option

   async def my_view(request): return HttpResponse('Hello') correctly uses async def and returns a response. def my_view(request): return HttpResponse('Hello') is a normal sync view. async def my_view(request): await HttpResponse('Hello') wrongly uses await on a response object, which is not awaitable. def async my_view(request): return HttpResponse('Hello') has invalid syntax.

3. Final Answer:

   async def my_view(request): return HttpResponse('Hello') -> Option B

4. Quick Check:

   Async view syntax = async def [OK]

Hint: Async views start with 'async def' keyword [OK]

Common Mistakes:

• Using 'def' instead of 'async def'
• Awaiting non-awaitable objects like HttpResponse
• Incorrect function declaration syntax

3. What will the following async view return when called?

from django.http import HttpResponse
import asyncio

async def my_view(request):
    await asyncio.sleep(1)
    return HttpResponse('Done')

medium

A. Returns 'Done' after 1 second delay

B. Returns immediately with 'Done'

C. Raises a SyntaxError

D. Returns None

Solution

1. Step 1: Analyze the async view code

   The view awaits asyncio.sleep(1), which pauses for 1 second asynchronously before continuing.

2. Step 2: Determine the response behavior

   After the 1 second pause, it returns an HttpResponse with 'Done'. So the client receives 'Done' after 1 second.

3. Final Answer:

   Returns 'Done' after 1 second delay -> Option A

4. Quick Check:

   Await asyncio.sleep delays response = B [OK]

Hint: Await pauses async view before returning response [OK]

Common Mistakes:

• Thinking the response is immediate despite await
• Confusing syntax errors with valid async/await usage
• Assuming None is returned without explicit return

4. Identify the error in this async view code:

async def my_view(request):
    response = HttpResponse('Hello')
    await response
    return response

medium

A. HttpResponse must be awaited to send the response.

B. Missing 'async' keyword before function definition.

C. The function should return a string, not HttpResponse.

D. HttpResponse object is not awaitable, so 'await response' causes an error.

Solution

1. Step 1: Check usage of await

   The code tries to 'await response' where response is an HttpResponse object, which is not awaitable.

2. Step 2: Understand correct async view behavior

   HttpResponse objects are returned directly without awaiting. Awaiting a non-awaitable causes a runtime error.

3. Final Answer:

   HttpResponse object is not awaitable, so 'await response' causes an error. -> Option D

4. Quick Check:

   Only await awaitable objects = C [OK]

Hint: Only await async functions or awaitables, not HttpResponse [OK]

Common Mistakes:

• Awaiting HttpResponse objects
• Forgetting async keyword on function
• Returning wrong types from views

5. You want to fetch data from an external API inside a Django async view. Which approach correctly uses async/await to avoid blocking the server?

import httpx

async def fetch_data():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://api.example.com/data')
        return response.json()

async def my_view(request):
    data = fetch_data()
    return JsonResponse(data)

hard

A. Replace async def with def in fetch_data to fix it.

B. Call fetch_data() without await; it runs synchronously.

C. Await fetch_data() inside my_view to get the data asynchronously.

D. Use requests.get() instead of httpx.AsyncClient for async calls.

Solution

1. Step 1: Identify async call usage

   fetch_data is an async function returning a coroutine. To get its result, you must await it inside an async view.

2. Step 2: Check the given my_view code

   my_view calls fetch_data() without await, so data is a coroutine, not the actual data. This will cause errors or wrong behavior.

3. Step 3: Correct usage

   Use data = await fetch_data() inside my_view to get the awaited result asynchronously.

4. Final Answer:

   Await fetch_data() inside my_view to get the data asynchronously. -> Option C

5. Quick Check:

   Await async functions to get results = A [OK]

Hint: Always await async functions to get their results [OK]

Common Mistakes:

• Calling async functions without await
• Using sync HTTP clients in async views
• Changing async def to def incorrectly