Working with HTTP Methods (GET, POST, PUT, DELETE)

HTTP methods are the standard methods used to communicate between a client (e.g., a web browser) and a server (e.g., a web application) over the internet. In Flask, you can handle different HTTP methods using the @app.route decorator and the method’s argument. The four most commonly used HTTP methods are GET, POST, PUT, and DELETE.

1. GET method: The GET method is used to retrieve data from a server. In Flask, you can handle GET requests by creating a route that uses the GET method. For example:

@app.route("/articles", methods=["GET"])
def get_articles():
    # Code to retrieve articles from a database
    return jsonify(articles)

In this example, the get_articles view will only handle GET requests made to the /articles URL. When a client sends a GET request to this URL, Flask will call the get_articles view, which retrieves the articles from a database and returns them as a JSON response.

2. POST method: The POST method is used to submit data to a server. In Flask, you can handle POST requests by creating a route that uses the POST method. For example:

@app.route("/articles", methods=["POST"])
def create_article():
    # Code to create a new article in the database
    return jsonify(article), 201

In this example, the create_article view will only handle POST requests made to the /articles URL. When a client sends a POST request to this URL with data, Flask will call the create_article view, which creates a new article in the database and returns a JSON response indicating that the article was created successfully.

3. PUT method: The PUT method is used to update data on a server. In Flask, you can handle PUT requests by creating a route that uses the PUT method. For example:

@app.route("/articles/<int:id>", methods=["PUT"])
def update_article(id):
    # Code to update an article in the database
    return jsonify(article), 200

In this example, the update_article view will only handle PUT requests made to the /articles/<id> URL, where <id> is the ID of the article being updated. When a client sends a PUT request to this URL with updated data, Flask will call the update_article view, which updates the article in the database and returns a JSON response indicating that the article was updated successfully.

4. DELETE method: The DELETE method is used to delete data from a server. In Flask, you can handle DELETE requests by creating a route that uses the DELETE method. For example:

@app.route("/articles/<int:id>", methods=["DELETE"])
def delete_article(id):
    # Code to delete an article from the database
    return "", 204

In this example, the delete_article view will only handle DELETE requests.

In Flask, you can use the request object to access data sent in a POST or PUT request. For example, you can access the data in a POST request like this:

@app.route("/articles", methods=["POST"])
def create_article():
    title = request.form.get("title")
    body = request.form.get("body")

    # Code to create a new article in the database
    return jsonify(article), 201

In this example, the request.form dictionary is used to access the data sent in the POST request. The get method is used to retrieve the values of the title and body fields.

You can also use the request.json property to access JSON data sent in a POST or PUT request. For example:

@app.route("/articles", methods=["POST"])
def create_article():
    data = request.json

    title = data.get("title")
    body = data.get("body")

    # Code to create a new article in the database
    return jsonify(article), 201

In this example, the request.json property is used to access the JSON data sent in the POST request. The data is then used to create a new article in the database.

It’s important to validate the data received in a POST or PUT request to ensure that it’s in the correct format and meets certain requirements. You can use the request.form or request.json dictionaries, along with Python’s built-in assert statement, to validate the data. For example:

@app.route("/articles", methods=["POST"])
def create_article():
    title = request.form.get("title")
    body = request.form.get("body")

    assert title, "Title is required"
    assert body, "Body is required"

    # Code to create a new article in the database
    return jsonify(article), 201

In this example, the assert statement is used to ensure that the title and body fields are present in the POST request. If either field is missing, the assertion will raise an error, and Flask will return a response indicating that the request is missing the required data.

In addition to handling different HTTP methods in Flask, you can also use the request object to access other information about the request, such as the URL, headers, and cookies. For example:

@app.route("/articles", methods=["GET"])
def get_articles():
    url = request.url
    headers = request.headers
    cookies = request.cookies

    # Code to retrieve articles from a database
    return jsonify(articles)

In this example, the request.url property is used to access the URL of the GET request, the request.headers property is used to access the headers of the request, and the request.cookies property is used to access the cookies sent with the request.

In conclusion, Flask makes it easy to handle different HTTP methods and access data sent in requests.