Defining tasks in Django - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the task decorator from Celery.

Django

from celery import [1]

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

Ashared_task

Btask

Cworker

Dapp

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'task' instead of 'shared_task' causes import errors.

Importing 'app' is incorrect for task decorators.

The shared_task decorator is used to define tasks in Django with Celery without needing the app instance.

2fill in blank

medium

Complete the code to define a simple Celery task that adds two numbers.

Django

@shared_task
def add(x, y):
    return x [1] y

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

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-' subtracts instead of adds.

Using '*' or '/' changes the operation to multiplication or division.

The task adds two numbers, so the operator must be +.

3fill in blank

hard

Fix the error in the task definition by completing the decorator correctly.

Django

@[1]_task
def multiply(x, y):
    return x * y

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

Aapp

Btask

Ccelery

Dshared

Attempts:

3 left

💡 Hint

Common Mistakes

Using '@task_task' causes syntax errors.

Using '@celery_task' is invalid.

The correct decorator is @shared_task to define a reusable Celery task.

4fill in blank

hard

Fill both blanks to create a task that sends an email asynchronously.

Django

from celery import [1]

@[2]
def send_email(to, subject, body):
    # email sending logic here
    pass

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

Ashared_task

Btask

Capp

Dworker

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing 'task' and 'shared_task' causes import or decorator errors.

Using 'app' or 'worker' is incorrect here.

Import shared_task and use @shared_task decorator to define the asynchronous task.

5fill in blank

hard

Fill all three blanks to define a periodic task that runs every minute.

Django

from celery import [1]
from celery.schedules import [2]

@[3]()

def periodic_task():
    print('Runs every minute')

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

Ashared_task

Bcrontab

Ctask

Dapp

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'task' instead of 'shared_task' for decorator causes errors.

Using 'app' or 'worker' is incorrect for these imports.

Use shared_task to import and decorate the task, and crontab to schedule periodic tasks.

Practice

1. What decorator is commonly used to define a background task in Django with Celery?

easy

A. @task_runner

B. @shared_task

C. @async_task

D. @background_task

Solution

1. Step 1: Understand task definition in Django with Celery

   Celery uses the @shared_task decorator to mark functions as tasks that can run asynchronously.

2. Step 2: Identify the correct decorator

   Among the options, only @shared_task is the correct and standard decorator for defining tasks.

3. Final Answer:

   @shared_task -> Option B

4. Quick Check:

   Task decorator = @shared_task [OK]

Hint: Remember: Celery tasks use @shared_task decorator [OK]

Common Mistakes:

• Using @background_task which is not a Celery decorator
• Confusing @async_task with async/await syntax
• Using @task_runner which is not valid in Django

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

easy

A. my_task.run()

B. my_task.execute()

C. my_task.delay()

D. my_task.start()

Solution

1. Step 1: Recall how to call Celery tasks asynchronously

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

2. Step 2: Identify the correct method

   Only delay() triggers the task asynchronously; other methods like run() execute synchronously or do not exist.

3. Final Answer:

   my_task.delay() -> Option C

4. Quick Check:

   Async call method = delay() [OK]

Hint: Use delay() to run tasks asynchronously [OK]

Common Mistakes:

• Calling run() which runs task synchronously
• Using execute() which is not a Celery method
• Trying start() which does not exist for tasks

3. Given this task definition:

from celery import shared_task

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

result = add.delay(4, 5)

What will result.get() return?

medium

A. 9

B. None

C. An AsyncResult object

D. A syntax error

Solution

1. Step 1: Understand the task and its call

   The add function adds two numbers. Calling add.delay(4, 5) runs it asynchronously and returns an AsyncResult.

2. Step 2: Using result.get() retrieves the task result

   Calling result.get() waits for the task to finish and returns the sum, which is 9.

3. Final Answer:

   9 -> Option A

4. Quick Check:

   Task result = 9 [OK]

Hint: delay() returns AsyncResult; get() fetches the actual result [OK]

Common Mistakes:

• Thinking delay() returns the result immediately
• Confusing AsyncResult object with the actual result
• Expecting None because task runs asynchronously

4. Identify the error in this task definition:

from celery import shared_task

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

medium

A. Function name is invalid

B. Missing @shared_task decorator

C. Using delay() incorrectly

D. Indentation error in function body

Solution

1. Step 1: Check the function syntax

   The function body must be indented inside the function definition. Here, return x * y is not indented.

2. Step 2: Identify the error type

   Python requires indentation for blocks. Missing indentation causes an IndentationError.

3. Final Answer:

   Indentation error in function body -> Option D

4. Quick Check:

   Python blocks need indentation [OK]

Hint: Check indentation inside function definitions [OK]

Common Mistakes:

• Ignoring indentation errors
• Assuming decorator is missing when it is present
• Confusing function name validity with syntax errors

5. You want to define a task that sends emails but only if the email address is not empty. Which of these task definitions correctly applies this condition?

hard

A. from celery import shared_task

@shared_task
def send_email(email):
if email:
# send email code
return 'Sent'
return 'No email provided'

B. from celery import shared_task

@shared_task
def send_email(email):
if email == None:
return 'No email provided'
# send email code
return 'Sent'

C. from celery import shared_task

@shared_task
def send_email(email):
if not email:
return 'Sent'
# send email code
return 'No email provided'

D. from celery import shared_task

def send_email(email):
if email:
# send email code
return 'Sent'
return 'No email provided'

Solution

1. Step 1: Check for correct task decorator and condition

   from celery import shared_task @shared_task def send_email(email): if email: # send email code return 'Sent' return 'No email provided' uses @shared_task and checks if email: which correctly tests for a non-empty email.

2. Step 2: Verify logic correctness

   from celery import shared_task @shared_task def send_email(email): if email: # send email code return 'Sent' return 'No email provided' returns 'Sent' only if email is truthy (not empty), else returns 'No email provided'. This matches the requirement.

3. Final Answer:

   Option A correctly defines the task with the condition -> Option A

4. Quick Check:

   Use if email: to check non-empty string [OK]

Hint: Use if email: to check non-empty strings in tasks [OK]

Common Mistakes:

• Forgetting @shared_task decorator
• Using if not email: incorrectly reversing logic
• Not indenting task function properly