Defining tasks in Django - Step-by-Step Execution

Concept Flow - Defining tasks

Create tasks.py file

↓

Define task function

↓

Use @shared_task decorator

↓

Task registered with Celery

↓

Task can be called asynchronously

↓

Task executes in worker process

This flow shows how to define a task in Django using Celery: create a tasks.py file, define a function, decorate it, register it, and then call it asynchronously.

Execution Sample

Django

from celery import shared_task

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

Defines a simple Celery task named 'add' that adds two numbers asynchronously.

Execution Table

Step	Action	Code Line	Result
1	Import shared_task decorator	from celery import shared_task	shared_task available
2	Apply @shared_task decorator	@shared_task	add registered as Celery task
3	Define function add(x, y)	def add(x, y):	Function add created
4	Function body executes when task runs	return x + y	Returns sum of x and y
5	Task can be called asynchronously	add.delay(4, 6)	Task sent to worker for execution
6	Worker executes task	add(4, 6)	Returns 10 asynchronously

💡 Task definition completes after decorator; execution happens later asynchronously.

Variable Tracker

Variable	Start	After Task Call	After Execution
x	undefined	4	4
y	undefined	6	6
result	undefined	undefined	10

Key Moments - 2 Insights

Why do we use @shared_task decorator instead of calling the function directly?

The @shared_task decorator registers the function as a Celery task so it can run asynchronously in a worker process, as shown in execution_table step 2 and 5.

When does the function body actually run?

The function body runs later in a separate worker process after calling add.delay(), not immediately when defining the function (see execution_table step 6).

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 3?

A The function add is executed immediately

B The task is sent to the worker

C The function add is registered as a Celery task

D The function add is deleted

💡 Hint

Check the 'Result' column at step 3 in the execution_table.

At which step is the task sent to the worker for execution?

A Step 5

B Step 4

C Step 2

D Step 6

💡 Hint

Look for 'Task sent to worker' in the execution_table.

If you remove the @shared_task decorator, what changes in the execution?

A The function will be registered as a task automatically

B The function can still run asynchronously

C The function will run synchronously when called

D The function will not be defined

💡 Hint

Refer to the key moment about the role of @shared_task decorator.

Concept Snapshot

Defining tasks in Django with Celery:
- Create tasks.py in app
- Define function with @shared_task decorator
- Call task asynchronously with .delay()
- Task runs in worker process
- Decorator registers function as async task

Full Transcript

To define a task in Django using Celery, you create a tasks.py file in your app. Inside, you define a function and decorate it with @shared_task. This decorator registers the function as a Celery task, allowing it to run asynchronously. When you call the task using .delay(), the task is sent to a worker process which executes the function body later. Variables like function arguments are passed to the worker, and the result is returned asynchronously. Without the decorator, the function runs synchronously when called.