The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Handling HTTP Methods

Next ►
►

In this section, we will explore how to handle different HTTP methods in Flask. HTTP methods are essential for defining the actions that can be performed on a resource. The most common HTTP methods are GET, POST, PUT, DELETE, and PATCH. Understanding how to handle these methods in Flask is crucial for building robust web applications.

Key Concepts

  1. HTTP Methods Overview:

    • GET: Retrieve data from the server.
    • POST: Send data to the server to create a new resource.
    • PUT: Update an existing resource on the server.
    • DELETE: Remove a resource from the server.
    • PATCH: Partially update a resource on the server.

  2. Flask Route Decorators:

    • Use @app.route to define routes and specify the allowed methods.

  3. Accessing Request Data:

    • Use request object to access data sent with the request.

Practical Examples

Example 1: Handling GET and POST Requests

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/data', methods=['GET', 'POST'])
def handle_data():
    if request.method == 'GET':
        return jsonify({"message": "This is a GET request"})
    elif request.method == 'POST':
        data = request.json
        return jsonify({"message": "Data received", "data": data})

if __name__ == '__main__':
    app.run(debug=True)

Explanation:

  • The route /data can handle both GET and POST requests.
  • For GET requests, it returns a simple JSON message.
  • For POST requests, it retrieves the JSON data sent in the request body and returns it in the response.

Example 2: Handling PUT and DELETE Requests

@app.route('/resource/<int:id>', methods=['PUT', 'DELETE'])
def modify_resource(id):
    if request.method == 'PUT':
        data = request.json
        return jsonify({"message": f"Resource {id} updated", "data": data})
    elif request.method == 'DELETE':
        return jsonify({"message": f"Resource {id} deleted"})

if __name__ == '__main__':
    app.run(debug=True)

Explanation:

  • The route /resource/<int:id> can handle both PUT and DELETE requests.
  • For PUT requests, it retrieves the JSON data sent in the request body and returns a message indicating the resource has been updated.
  • For DELETE requests, it returns a message indicating the resource has been deleted.

Practical Exercises

Exercise 1: Create a Flask Application to Handle Different HTTP Methods

Task:

  1. Create a Flask application with a route /items that handles GET and POST requests.
  2. Create another route /items/<int:item_id> that handles PUT and DELETE requests.

Solution:

from flask import Flask, request, jsonify

app = Flask(__name__)

items = []

@app.route('/items', methods=['GET', 'POST'])
def manage_items():
    if request.method == 'GET':
        return jsonify(items)
    elif request.method == 'POST':
        item = request.json
        items.append(item)
        return jsonify({"message": "Item added", "item": item}), 201

@app.route('/items/<int:item_id>', methods=['PUT', 'DELETE'])
def modify_item(item_id):
    if item_id >= len(items) or item_id < 0:
        return jsonify({"message": "Item not found"}), 404

    if request.method == 'PUT':
        item = request.json
        items[item_id] = item
        return jsonify({"message": "Item updated", "item": item})
    elif request.method == 'DELETE':
        items.pop(item_id)
        return jsonify({"message": "Item deleted"})

if __name__ == '__main__':
    app.run(debug=True)

Explanation:

  • The /items route handles GET requests to retrieve all items and POST requests to add a new item.
  • The /items/<int:item_id> route handles PUT requests to update an item and DELETE requests to remove an item.

Common Mistakes and Tips

  • Common Mistake: Not specifying the allowed methods in the route decorator.

    • Tip: Always specify the methods parameter in the @app.route decorator to avoid unexpected behavior.

  • Common Mistake: Not handling different HTTP methods properly within a single route.

    • Tip: Use request.method to differentiate between the methods and handle them accordingly.

Conclusion

In this section, we learned how to handle different HTTP methods in Flask. We covered the basics of GET, POST, PUT, and DELETE methods, and how to use the @app.route decorator to define routes that handle these methods. We also provided practical examples and exercises to reinforce the concepts. Understanding how to handle HTTP methods is fundamental for building RESTful APIs and web applications with Flask.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved