Function-based views basics in Django - Step-by-Step Execution

Concept Flow - Function-based views basics

HTTP Request Received

↓

URL Dispatcher Matches URL

↓

Call Function-based View

↓

Process Request in View Function

↓

Return HttpResponse Object

↓

Send Response to Client

The web server receives a request, Django matches the URL, calls the function-based view, which processes the request and returns a response.

Execution Sample

Django

from django.http import HttpResponse

def hello_view(request):
    return HttpResponse('Hello, world!')

A simple function-based view that returns a plain text 'Hello, world!' response.

Execution Table

Step	Action	Input	Output	Notes
1	Receive HTTP GET request	GET /hello/	Request object created	Request object contains method, path, headers
2	URL dispatcher matches '/hello/'	/hello/	Calls hello_view(request)	Django finds the view function for URL
3	Execute hello_view function	request object	HttpResponse object	Returns response with content 'Hello, world!'
4	Send HttpResponse to client	HttpResponse object	Client receives 'Hello, world!'	Response sent back over HTTP
5	End	N/A	N/A	Request cycle complete

💡 Request processed and response sent, no further action.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
request	N/A	Request object with GET /hello/	Same request object passed	Same request object
response	N/A	N/A	HttpResponse('Hello, world!')	HttpResponse object sent to client

Key Moments - 3 Insights

Why does the view function take 'request' as a parameter?

The 'request' parameter holds all information about the client's HTTP request. In the execution_table step 3, the view uses this to process and decide what response to return.

What does the view function return?

The view must return an HttpResponse object, as shown in execution_table step 3, which Django sends back to the client.

How does Django know which function to call for a URL?

Django uses the URL dispatcher to match the URL to a view function, as seen in execution_table step 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the output of step 3?

A Request object with GET method

B URL pattern string '/hello/'

C HttpResponse object with 'Hello, world!' content

D Client's browser window

💡 Hint

Check the 'Output' column in step 3 of the execution_table.

At which step does Django match the URL to the view function?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' column to find when URL matching happens.

If the view function returned a string instead of HttpResponse, what would happen?

A Django would raise an error because it expects HttpResponse

B The URL dispatcher would fail to match the URL

C Django would send the string as response automatically

D The client would receive an empty response

💡 Hint

Recall the 'Output' expected in step 3 of the execution_table.

Concept Snapshot

Function-based views in Django:
- Receive 'request' object as parameter
- Process request inside the function
- Return an HttpResponse object
- URL dispatcher maps URLs to view functions
- Response sent back to client after view returns

Full Transcript

In Django, when a client sends an HTTP request, the URL dispatcher matches the URL to a function-based view. This view function receives a request object containing all request details. The function processes the request and returns an HttpResponse object with the content to send back. Django then sends this response to the client, completing the request cycle. The key is that the view must accept the request parameter and return an HttpResponse. This simple flow allows Django to handle web requests efficiently.

Practice

1. What is the main purpose of a function-based view in Django?

easy

A. To handle web requests and return responses

B. To define database models

C. To style HTML pages with CSS

D. To manage user sessions automatically

Solution

1. Step 1: Understand the role of views in Django

   Views are responsible for processing web requests and returning responses.

2. Step 2: Identify the function-based view role

   Function-based views are simple Python functions that take a request and return a response.

3. Final Answer:

   To handle web requests and return responses -> Option A

4. Quick Check:

   Function-based views handle requests = A [OK]

Hint: Views handle requests and responses in Django [OK]

Common Mistakes:

• Confusing views with models
• Thinking views handle styling
• Assuming views manage sessions automatically

2. Which of the following is the correct way to define a simple function-based view in Django?

easy

A. def my_view(request): print('Hello')

B. class my_view: return HttpResponse('Hello')

C. def my_view(): return HttpResponse('Hello')

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

Solution

1. Step 1: Check function signature for views

   A function-based view must accept a request parameter.

2. Step 2: Verify the return value

   The view must return an HttpResponse object, not just print or omit request.

3. Final Answer:

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

4. Quick Check:

   Function with request param and HttpResponse return = A [OK]

Hint: View functions need request param and return HttpResponse [OK]

Common Mistakes:

• Omitting the request parameter
• Using class syntax instead of function
• Printing instead of returning HttpResponse

3. Given this function-based view code, what will be the HTTP response content?

from django.http import HttpResponse

def greet(request):
    name = request.GET.get('name', 'Guest')
    return HttpResponse(f'Hello, {name}!')

medium

A. Hello, None!

B. Hello, Guest!

C. Hello, name!

D. Error: missing name parameter

Solution

1. Step 1: Understand request.GET.get usage

   The code tries to get 'name' from query parameters; if missing, defaults to 'Guest'.

2. Step 2: Determine response content when no name given

   If no 'name' parameter is in the URL, it uses 'Guest', so response is 'Hello, Guest!'.

3. Final Answer:

   Hello, Guest! -> Option B

4. Quick Check:

   Missing name defaults to Guest = B [OK]

Hint: GET.get with default returns default if param missing [OK]

Common Mistakes:

• Assuming missing param causes error
• Confusing string literal with variable name
• Expecting None instead of default value

4. Identify the error in this function-based view code:

from django.http import HttpResponse

def my_view():
    return HttpResponse('Hi')

medium

A. Return statement syntax is incorrect

B. HttpResponse is not imported

C. Missing request parameter in function definition

D. Function name is invalid

Solution

1. Step 1: Check function parameters for views

   Function-based views must accept a request parameter to receive HTTP requests.

2. Step 2: Verify imports and syntax

   HttpResponse is imported correctly and return syntax is valid; function name is valid.

3. Final Answer:

   Missing request parameter in function definition -> Option C

4. Quick Check:

   View functions need request param = C [OK]

Hint: Always include request parameter in view functions [OK]

Common Mistakes:

• Omitting request parameter
• Forgetting to import HttpResponse
• Misnaming the function

5. You want to create a function-based view that returns a 404 error if a query parameter 'id' is missing. Which code snippet correctly implements this?

hard

A. def view(request):
if request.GET.get('id') is None:
return HttpResponse('Not found', status=404)
return HttpResponse('Found')

B. def view(request):
if request.GET['id'] is None:
return HttpResponse('Not found', status=404)
return HttpResponse('Found')

C. def view(request):
if request.GET.get('id') == '':
return HttpResponse('Not found', status=404)
return HttpResponse('Found')

D. def view(request):
if 'id' not in request.POST:
return HttpResponse('Not found', status=404)
return HttpResponse('Found')

Solution

1. Step 1: Check how to safely get query parameters

   Using request.GET.get('id') returns None if 'id' is missing, avoiding KeyError.

2. Step 2: Verify condition to return 404

   If get returns None, return HttpResponse with status=404; else return 'Found'.

3. Final Answer:

   def view(request): if request.GET.get('id') is None: return HttpResponse('Not found', status=404) return HttpResponse('Found') -> Option A

4. Quick Check:

   Use GET.get to check missing param safely = D [OK]

Hint: Use request.GET.get to avoid KeyError when checking params [OK]

Common Mistakes:

• Using request.GET['id'] without checking existence
• Checking for empty string instead of None
• Confusing request.GET with request.POST