Defining tasks in Django - Mini Project: Build & Apply

Defining Tasks in Django

📖 Scenario: You are building a Django project that needs to perform background tasks. To do this, you will define a simple task function that can be called later by a task runner.

🎯 Goal: Create a Django task function named send_reminder_email that accepts a user_email parameter and prints a message simulating sending an email.

📋 What You'll Learn

Create a Python function named send_reminder_email in a file called tasks.py inside a Django app.

The function must accept one parameter called user_email.

Inside the function, write a print statement that outputs exactly: Sending reminder email to {user_email} using an f-string.

Ensure the function is properly defined with def syntax.

💡 Why This Matters

🌍 Real World

Background tasks like sending reminder emails are common in web applications to improve user engagement without slowing down the main app.

💼 Career

Knowing how to define and use tasks in Django is essential for backend developers working on scalable and responsive web applications.

1

Create the tasks.py file and define the function

Create a file named tasks.py inside your Django app folder. Inside it, define a function called send_reminder_email that takes one parameter named user_email.

Django

# Define the function send_reminder_email with parameter user_email
# Your code here

Hint

Use the def keyword to define the function with the exact name and parameter.

2

Add a print statement inside the function

Inside the send_reminder_email function, add a print statement that outputs Sending reminder email to {user_email} using an f-string exactly as shown.

Django

def send_reminder_email(user_email):
    # Add print statement here
    # Your code here

Hint

Use print(f"Sending reminder email to {user_email}") inside the function body.

3

Import the task function in views.py

In your Django app's views.py file, import the send_reminder_email function from the tasks module.

Django

def send_reminder_email(user_email):
    print(f"Sending reminder email to {user_email}")

# Import send_reminder_email in views.py
# Your code here

Hint

Use from .tasks import send_reminder_email to import the function.

4

Call the task function in a view

Inside a Django view function named reminder_view in views.py, call the send_reminder_email function with the argument "[e-mail]".

Django

def send_reminder_email(user_email):
    print(f"Sending reminder email to {user_email}")

from .tasks import send_reminder_email

# Define reminder_view and call send_reminder_email
# Your code here

Hint

Define reminder_view with request parameter and call send_reminder_email("[e-mail]") inside it.

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