HTTP methods (GET, POST, PUT, DELETE) in Flask - Deep Dive

Overview - HTTP methods (GET, POST, PUT, DELETE)

What is it?

HTTP methods are ways a web browser or client tells a server what action it wants to perform on a resource. The most common methods are GET, POST, PUT, and DELETE. Each method has a specific purpose, like fetching data, sending new data, updating existing data, or removing data. These methods help organize how web applications communicate and work.

Why it matters

Without HTTP methods, servers wouldn't know what clients want to do with data, making web communication confusing and unreliable. For example, without GET and POST, you couldn't load a webpage or submit a form properly. These methods create clear rules so websites and apps work smoothly and predictably, which affects everything from browsing to online shopping.

Where it fits

Before learning HTTP methods, you should understand basic web concepts like URLs and client-server communication. After mastering HTTP methods, you can learn about REST APIs, web security, and how to build full web applications using frameworks like Flask.

Mental Model

Core Idea

HTTP methods are simple instructions that tell a server what to do with data: get it, add it, change it, or delete it.

Think of it like...

Imagine a library where you can ask to see a book (GET), donate a new book (POST), replace a damaged book with a new copy (PUT), or remove a book from the shelf (DELETE). Each action has a clear purpose and rule.

┌─────────────┐      ┌───────────────┐
│   Client    │─────▶│    Server     │
└─────────────┘      └───────────────┘
       │                    ▲
       │ HTTP Method        │
       │ (GET, POST, PUT,   │
       │  DELETE)           │
       ▼                    │
  Request Data          Response Data

Build-Up - 6 Steps

1

Foundation

Understanding HTTP and Requests

Concept: Learn what HTTP is and how clients and servers communicate using requests.

HTTP stands for HyperText Transfer Protocol. It is the language browsers and servers use to talk. When you type a website address, your browser sends an HTTP request to the server asking for the webpage. The server replies with the webpage data. This request includes a method that tells the server what you want to do.

Result

You understand that HTTP is the basic communication system for the web and that requests carry methods to specify actions.

Understanding HTTP as a communication protocol is the foundation for knowing why methods like GET and POST exist.

2

Foundation

What Are HTTP Methods?

Concept: HTTP methods are commands sent in requests that tell the server what action to perform.

There are many HTTP methods, but the most common are GET, POST, PUT, and DELETE. GET asks the server to send data. POST sends new data to the server. PUT updates existing data. DELETE removes data. Each method changes how the server treats the request.

Result

You can identify the four main HTTP methods and their basic purposes.

Knowing that methods define the action helps you predict how servers respond and how to design web interactions.

3

Intermediate

Using GET and POST in Flask

🤔Before reading on: Do you think GET or POST is used to send form data to the server? Commit to your answer.

Concept: Learn how to handle GET and POST requests in Flask to receive and send data.

In Flask, you define routes that respond to HTTP methods. GET is used to fetch pages or data. POST is used to send data, like form submissions. Example: from flask import Flask, request app = Flask(__name__) @app.route('/form', methods=['GET', 'POST']) def form(): if request.method == 'POST': data = request.form['name'] return f'Hello, {data}!' return '''

Name:

''' This code shows a form that sends data with POST and a page that loads with GET.

Result

You can create Flask routes that handle both GET and POST, enabling interactive web pages.

Understanding how Flask maps HTTP methods to route functions is key to building dynamic web apps.

4

Intermediate

Working with PUT and DELETE Methods

🤔Before reading on: Do you think browsers support PUT and DELETE methods directly in forms? Commit to your answer.

Concept: Learn how to use PUT and DELETE methods in Flask, often used for updating and deleting data in APIs.

PUT replaces or updates data on the server. DELETE removes data. Browsers don't support these methods in HTML forms directly, so they are often used in APIs or with JavaScript fetch calls. Example Flask route: @app.route('/item/', methods=['PUT', 'DELETE']) def modify_item(id): if request.method == 'PUT': # update item logic return f'Item {id} updated', 200 elif request.method == 'DELETE': # delete item logic return f'Item {id} deleted', 200 You can test these with tools like curl or Postman.

Result

You understand how to handle data updates and deletions in Flask using PUT and DELETE.

Knowing that PUT and DELETE are essential for full data control helps you build complete RESTful APIs.

5

Advanced

Idempotency and Safety of HTTP Methods

🤔Before reading on: Is POST idempotent like GET and PUT? Commit to your answer.

Concept: Learn the concepts of idempotency and safety in HTTP methods and why they matter for web design.

GET is safe and idempotent: it doesn't change data and multiple identical requests have the same effect. PUT is idempotent but not safe: it changes data but repeating the same request doesn't change the result beyond the first. POST is neither safe nor idempotent: it usually creates new data, so repeating can cause duplicates. DELETE is idempotent: deleting the same resource multiple times has the same effect as deleting once. These properties guide how clients and servers handle retries and caching.

Result

You can predict how repeating requests affect server data and design APIs accordingly.

Understanding idempotency and safety prevents bugs like duplicate data or unintended changes in web apps.

6

Expert

HTTP Methods in RESTful API Design

🤔Before reading on: Do you think REST APIs must use all four methods equally? Commit to your answer.

Concept: Explore how HTTP methods form the backbone of RESTful API design and best practices for their use.

RESTful APIs use HTTP methods to map CRUD operations: - GET to read data - POST to create data - PUT to update or replace data - DELETE to remove data Good API design uses these methods consistently with clear URLs representing resources. For example, POST /users creates a user, PUT /users/1 updates user 1. Sometimes PATCH is used for partial updates, but PUT replaces the entire resource. Proper use improves API clarity, caching, and security.

Result

You can design or understand professional REST APIs that use HTTP methods correctly.

Knowing how HTTP methods align with REST principles is essential for building scalable and maintainable web services.

Under the Hood

When a client sends an HTTP request, it includes a method in the request line (e.g., GET /path HTTP/1.1). The server reads this method and routes the request to the appropriate handler. The server's software interprets the method to decide whether to return data, accept new data, update existing data, or delete data. Internally, the server may check permissions, validate data, and interact with databases based on the method.

Why designed this way?

HTTP methods were designed to separate different types of actions clearly, making web communication predictable and standardized. Early web needed a simple way to distinguish between fetching pages and submitting forms. Over time, methods like PUT and DELETE were added to support full resource management. This design avoids mixing actions in one request and helps intermediaries like caches and proxies understand traffic.

┌───────────────┐
│ Client sends  │
│ HTTP Request  │
│ with Method   │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Server receives│
│ request and    │
│ reads method   │
└──────┬─────────┘
       │
       ▼
┌───────────────┐
│ Routes request │
│ to handler for │
│ that method    │
└──────┬─────────┘
       │
       ▼
┌───────────────┐
│ Handler runs  │
│ logic based on│
│ method type   │
└──────┬─────────┘
       │
       ▼
┌───────────────┐
│ Server sends  │
│ response back │
│ to client     │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Is POST idempotent like PUT? Commit to yes or no.

Common Belief: POST requests are idempotent and safe to repeat without side effects.

Reality: POST is not idempotent; repeating a POST can create duplicate data or trigger repeated actions.

Why it matters: Assuming POST is idempotent can cause bugs like multiple orders or duplicate entries when users refresh pages.

Quick: Can HTML forms send PUT or DELETE requests directly? Commit to yes or no.

Common Belief: HTML forms can send PUT and DELETE requests just like GET and POST.

Reality: HTML forms only support GET and POST methods natively; PUT and DELETE require JavaScript or tools like curl.

Why it matters: Trying to use PUT or DELETE in forms without workarounds leads to unexpected failures or ignored requests.

Quick: Does GET change data on the server? Commit to yes or no.

Common Belief: GET requests can change data on the server if programmed that way.

Reality: GET should never change server data; it is designed to be safe and only retrieve information.

Why it matters: Violating GET's safety breaks caching, bookmarking, and can cause security issues.

Quick: Is PUT always used for partial updates? Commit to yes or no.

Common Belief: PUT is used for partial updates of resources.

Reality: PUT replaces the entire resource; PATCH is the method for partial updates.

Why it matters: Misusing PUT for partial updates can overwrite data unintentionally, causing data loss.

Expert Zone

1

Some APIs use POST for actions that are not resource creation, like triggering processes, which breaks strict REST conventions but can be practical.

2

Idempotency is crucial for network reliability; clients retry failed requests safely only if methods are idempotent.

3

Caching behavior depends heavily on HTTP methods; GET responses are cacheable by default, while POST responses are not.

When NOT to use

Avoid using POST for updates or deletions; use PUT or DELETE instead for clarity and idempotency. For partial updates, use PATCH. For simple data retrieval, always use GET to leverage caching and safety.

Production Patterns

In production Flask APIs, routes are organized by resource with methods explicitly declared. Middleware often checks method validity and permissions. Developers use tools like Postman or curl to test PUT and DELETE. APIs often return proper HTTP status codes (200, 201, 204, 404) based on method results.

Connections

REST API Design

HTTP methods form the core operations in REST APIs.

Understanding HTTP methods deeply helps grasp REST principles and how web services manage resources.

Database CRUD Operations

HTTP methods map directly to Create, Read, Update, Delete operations in databases.

Knowing this mapping clarifies how web requests translate to database actions behind the scenes.

Command Pattern in Software Design

HTTP methods act like commands telling the server what action to perform.

Recognizing HTTP methods as commands helps understand their role in controlling behavior and state changes.

Common Pitfalls

#1 Using POST for updating data instead of PUT.

Wrong approach:

@app.route('/item/', methods=['POST'])
def update_item(id):
# update logic here
return 'Updated', 200

Correct approach:

@app.route('/item/', methods=['PUT'])
def update_item(id):
# update logic here
return 'Updated', 200

Root cause:

Confusing POST as a general method for sending data rather than using PUT for updates.

#2 Trying to send DELETE request via HTML form without JavaScript.

Wrong approach:

Correct approach:

Root cause:

HTML forms only support GET and POST; developers must use workarounds to simulate other methods.

#3 Changing server data in a GET request handler.

Wrong approach:

@app.route('/increment')
def increment():
global counter
counter += 1
return str(counter)

Correct approach:

@app.route('/increment', methods=['POST'])
def increment():
global counter
counter += 1
return str(counter)

Root cause:

Misunderstanding that GET should be safe and not modify server state.

Key Takeaways

HTTP methods are clear instructions that tell servers what action to perform on data, making web communication organized and predictable.

GET retrieves data safely without changing anything, while POST sends new data, PUT updates existing data, and DELETE removes data.

Understanding the properties of HTTP methods like idempotency and safety helps prevent bugs and design better APIs.

Flask routes handle HTTP methods explicitly, enabling dynamic web applications and RESTful APIs.

Misusing HTTP methods can cause security issues, data loss, or unexpected behavior, so following standards is crucial.