Python > Web Development with Python > Django > Views (Function-Based and Class-Based)

Django Function-Based View

This snippet demonstrates a simple function-based view in Django, which handles HTTP requests and returns a response. Function-based views are straightforward for simple logic and can be easier to understand for beginners.

Basic Function-Based View

This code defines a function `my_view` that takes a `request` object as input. It prepares a `context` dictionary containing data to be passed to the template. Finally, it uses `render` to combine the template 'my_template.html' with the context and return an `HttpResponse`.

from django.http import HttpResponse
from django.shortcuts import render

def my_view(request):
    context = {
        'message': 'Hello from a function-based view!'
    }
    return render(request, 'my_template.html', context)

Creating the Template (my_template.html)

This is a simple HTML template that displays the 'message' passed from the view. Django's template engine replaces `{{ message }}` with the actual value from the context.

<!-- my_template.html -->
<!DOCTYPE html>
<html>
<head>
    <title>Function-Based View Example</title>
</head>
<body>
    <h1>{{ message }}</h1>
</body>
</html>

Mapping the View to a URL (urls.py)

This code maps the URL path 'function-view/' to the `my_view` function in your `views.py` file. The `name` argument provides a way to reference this URL in templates and other parts of your application.

from django.urls import path
from . import views

urlpatterns = [
    path('function-view/', views.my_view, name='my_view'),
]

Concepts Behind the Snippet

Function-based views (FBVs) are Python functions that accept an HTTP request and return an HTTP response (e.g., HTML content, a redirect, an error). They handle the logic to process the request and determine what to return to the user.

Real-Life Use Case

Displaying a simple contact form or a confirmation page is a common use case for function-based views. These scenarios usually involve a limited amount of logic and don't require the complexities of class-based views.

Best Practices

Keep function-based views concise and focused on a single task. For complex logic, consider refactoring into separate functions or using class-based views.

When to Use Them

Use function-based views for simple tasks that don't require extensive code reuse or complex logic. They are suitable for basic form handling, displaying static content, or performing simple data processing.

Pros

  • Simpler to understand and implement for basic tasks.
  • Less boilerplate code compared to class-based views.

Cons

  • Can become difficult to manage for complex applications with a lot of shared logic.
  • Less support for code reuse and inheritance compared to class-based views.

← Django Form Example: Simple Contact Form Django Middleware for Handling Maintenance Mode →

FAQ

  • What is the 'request' object?

    The 'request' object contains information about the current HTTP request, such as the user's browser, the data they submitted, and the URL they requested.
  • What does the 'render' function do?

    The 'render' function takes a request object, a template name, and a context dictionary as input. It combines the template with the context data and returns an HttpResponse object containing the rendered HTML.