Django Views and URL Routing - Django Tutorials

Handling HTTP Methods in Views

Tutorial 1 of 5

Introduction
This tutorial aims to walk you through handling different HTTP methods in Django views. By the end of this guide, you will be able to control how your Django application responds to various user actions.
You will learn how to set up views to handle GET, POST, PUT, DELETE and other HTTP methods.
Prerequisites: Basic knowledge of Python and Django is required. Familiarity with HTTP methods and their roles in a web application will be helpful.
Step-by-Step Guide
Django views are Python functions that take a web request and return a web response. Each view is responsible for doing some logic, fetching data from the database, rendering a template, or redirecting to another view.
HTTP methods dictate how data should be sent and received in a web server. The most common methods include GET (retrieve data), POST (send data), PUT and PATCH (update data), and DELETE (remove data).
Django views can be written as function-based views (FBVs) or class-based views (CBVs). While you can handle HTTP methods in both, CBVs provide more structure and are recommended for larger projects.
Code Examples
Here's how to handle GET and POST methods in a basic Django view:

```python
from django.http import HttpResponse
from django.views.decorators.http import require_http_methods

@require_http_methods(["GET", "POST"])
def my_view(request):
if request.method == 'GET':
# Handle the GET request
return HttpResponse('Hello, GET!')
```
elif request.method == 'POST':
    # Handle the POST request
    return HttpResponse('Hello, POST!')
```
`` - In this code snippet, we first import the required modules. Therequire_http_methods` decorator restricts the HTTP methods that this view will accept. If a request comes in with a different method, Django will automatically return a 405 ‘Method Not Allowed’ response.
- Inside the view, we check the method of the request. Depending on whether it's a GET or POST request, we return a different HTTP response.
Summary
We covered how to handle different HTTP methods in Django views, both in function-based and class-based views. We also discussed how to restrict the allowed methods for a view using Django's built-in decorators.
The next step would be to learn how to handle forms, user authentication, and other complex tasks in Django views.
For more information, you can refer to Django’s official documentation.
Practice Exercises
Try creating a view that only accepts PUT requests.
Try creating a view that accepts GET requests and returns a specific HttpResponse depending on the value of a query parameter.
Solutions and explanations:
- To create a view that only accepts PUT requests, you can use the require_http_methods decorator like this:
python @require_http_methods(["PUT"]) def my_view(request): # Handle the PUT request return HttpResponse('Hello, PUT!')
- To create a view that returns a specific HttpResponse based on a query parameter, you can use request.GET:
python @require_http_methods(["GET"]) def my_view(request): param = request.GET.get('param', 'default') if param == 'special': return HttpResponse('Hello, special!') else: return HttpResponse('Hello, default!')
For further practice, consider creating views that interact with a database model, such as creating a new instance or updating an existing one.