Calling tasks asynchronously in Django - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Django Celery task call?

Consider this Django Celery task defined in tasks.py. What will be printed when the task is called asynchronously?

Django

from celery import shared_task

@shared_task
def add(x, y):
    return x + y

result = add.delay(4, 5)
print(result.ready())

A False

B True

C 9

D None

💡 Hint

Think about what delay() returns and when the task finishes.

The delay() method queues the task and returns an AsyncResult immediately. The task is not finished yet, so result.ready() returns False.

❓ state_output

intermediate

What is the value of result.get() after task completion?

Given this Celery task and its asynchronous call, what will result.get() return after the task finishes?

Django

from celery import shared_task

@shared_task
def multiply(x, y):
    return x * y

result = multiply.delay(3, 7)
output = result.get(timeout=10)
print(output)

A 10

B None

C TimeoutError

D 21

💡 Hint

The get() method waits for the task result.

The get() method blocks until the task completes or the timeout expires. Since the task multiplies 3 and 7, the result is 21.

📝 Syntax

advanced

Which option correctly schedules a periodic task in Django Celery?

You want to schedule a task to run every 10 minutes using Django Celery. Which code snippet correctly sets this up in celery.py or tasks.py?

A

from celery.schedules import crontab
app.conf.beat_schedule = {'task-every-10-minutes': {'task': 'myapp.tasks.my_task', 'schedule': crontab(minute='*/10')}}

B app.conf.beat_schedule = {'task-every-10-minutes': {'task': 'myapp.tasks.my_task', 'schedule': 10}}

C

from celery.schedules import schedule
app.conf.beat_schedule = {'task-every-10-minutes': {'task': 'myapp.tasks.my_task', 'schedule': schedule(10)}}

D app.conf.beat_schedule = {'task-every-10-minutes': {'task': 'myapp.tasks.my_task', 'interval': 600}}

💡 Hint

Look for the correct way to specify a periodic schedule using crontab.

Option A uses crontab(minute='*/10') which correctly schedules the task every 10 minutes. Other options either use wrong keys or invalid schedule types.

🔧 Debug

advanced

Why does this asynchronous task call raise an error?

Examine the code below. Why does calling send_email.delay() raise an error?

Django

from celery import shared_task

@shared_task
def send_email(to_address):
    print(f"Sending email to {to_address}")

send_email.delay()

A No error, prints 'Sending email to None'

B SyntaxError due to missing colon in function definition

C TypeError because delay() is called without required argument

D AttributeError because send_email is not a task

💡 Hint

Check the function parameters and how delay() is called.

The send_email task requires one argument to_address. Calling delay() without arguments causes a TypeError.

🧠 Conceptual

expert

Which statement about Django Celery task execution is true?

Select the correct statement about how Django Celery executes asynchronous tasks.

A Tasks run synchronously in the main Django process by default

B Tasks are sent to a message broker and executed by separate worker processes asynchronously

C Calling <code>delay()</code> immediately executes the task in the worker process

D Django automatically retries failed tasks without any configuration

💡 Hint

Think about how Celery separates task execution from the Django app.

Celery sends tasks to a message broker like RabbitMQ or Redis. Worker processes listen to the broker and execute tasks asynchronously, separate from the Django main process.

Practice

1. What is the main purpose of calling tasks asynchronously in a Django app using Celery?

easy

A. To avoid using any external libraries

B. To make the app run slower by adding extra steps

C. To run time-consuming tasks in the background without blocking the main app

D. To run tasks only when the server restarts

Solution

1. Step 1: Understand asynchronous task calling

   Calling tasks asynchronously means running them in the background so the main app can continue working without waiting.

2. Step 2: Identify the benefit in Django apps

   This helps keep the app fast and responsive by not blocking user requests with long tasks.

3. Final Answer:

   To run time-consuming tasks in the background without blocking the main app -> Option C

4. Quick Check:

   Async tasks = background work = To run time-consuming tasks in the background without blocking the main app [OK]

Hint: Async tasks run in background, keeping app responsive [OK]

Common Mistakes:

• Thinking async tasks slow down the app
• Believing async tasks run only on server restart
• Confusing async with avoiding external libraries

2. Which of the following is the correct way to call a Celery task named send_email asynchronously?

easy

A. send_email.delay()

B. send_email()

C. send_email.async()

D. send_email.run()

Solution

1. Step 1: Recall Celery task calling syntax

   Celery tasks are called asynchronously using the .delay() method.

2. Step 2: Match the correct method to the task name

   Calling send_email.delay() queues the task to run in the background.

3. Final Answer:

   send_email.delay() -> Option A

4. Quick Check:

   Use .delay() to call async tasks [OK]

Hint: Use .delay() to call Celery tasks asynchronously [OK]

Common Mistakes:

• Calling the task like a normal function without .delay()
• Using .async() which is not a Celery method
• Using .run() which executes task synchronously

3. Given the following Celery task and call:

@shared_task
def add(x, y):
    return x + y

result = add.delay(4, 5)

What will result.get() return after the task completes?

medium

A. 9

B. None

C. An error because .get() is not valid

D. A task ID string

Solution

1. Step 1: Understand what add.delay(4, 5) does

   This queues the add task with arguments 4 and 5 to run asynchronously.

2. Step 2: Understand result.get() usage

   Calling result.get() waits for the task to finish and returns the result, which is 4 + 5 = 9.

3. Final Answer:

   9 -> Option A

4. Quick Check:

   Task result = 4 + 5 = 9 [OK]

Hint: Use .get() to fetch async task result after completion [OK]

Common Mistakes:

• Thinking .get() returns task ID instead of result
• Believing .get() is invalid for Celery AsyncResult
• Expecting None because task runs asynchronously

4. What is wrong with this Celery task call?

@shared_task
def multiply(x, y):
    return x * y

result = multiply(3, 7)

medium

A. The arguments 3 and 7 are invalid types

B. The task is missing the @app.task decorator

C. The function multiply should not return a value

D. The task is called synchronously, not asynchronously

Solution

1. Step 1: Check how the task is called

   The task is called directly as multiply(3, 7), which runs it immediately and blocks.

2. Step 2: Identify correct async call method

   To call asynchronously, it should be multiply.delay(3, 7).

3. Final Answer:

   The task is called synchronously, not asynchronously -> Option D

4. Quick Check:

   Direct call runs sync, use .delay() for async [OK]

Hint: Use .delay() to call tasks async, not direct function call [OK]

Common Mistakes:

• Calling task function directly instead of using .delay()
• Confusing @shared_task with @app.task (both valid but different)
• Thinking return values are disallowed in tasks

5. You want to send a welcome email asynchronously after a user registers. Which approach correctly combines Django signals and Celery tasks to achieve this?

hard

A. Call send_welcome_email(user.id) directly inside the signal handler

B. Connect a signal handler that calls send_welcome_email.delay(user.id) after user creation

C. Use a signal to call send_welcome_email.run(user.id) synchronously

D. Call send_welcome_email.delay() before the user is saved

Solution

1. Step 1: Understand the goal

   We want to send the email asynchronously after the user is created to avoid slowing registration.

2. Step 2: Use Django signals with Celery correctly

   Connect a signal (like post_save) to call send_welcome_email.delay(user.id) after user creation, queuing the task.

3. Final Answer:

   Connect a signal handler that calls send_welcome_email.delay(user.id) after user creation -> Option B

4. Quick Check:

   Signal + .delay() after save = async email send [OK]

Hint: Use signals to trigger .delay() after user save [OK]

Common Mistakes:

• Calling task directly inside signal, blocking request
• Calling .run() which is synchronous
• Calling .delay() before user exists in DB