CRUD operations in Flask - Step-by-Step Execution

Concept Flow - CRUD operations

Client sends HTTP request

↓

Flask route matches URL

↓

Identify CRUD operation

↓

Process data

↓

Send HTTP response

This flow shows how Flask handles HTTP requests for CRUD: create, read, update, and delete data, then sends back a response.

Execution Sample

Flask

from flask import Flask, request, jsonify
app = Flask(__name__)

items = []

@app.route('/items', methods=['POST'])
def create_item():
    data = request.json
    items.append(data)
    return jsonify(data), 201

This code adds a new item to a list when a POST request is sent to /items.

Execution Table

Step	HTTP Method	Route	Action	Data State	Response
1	POST	/items	Receive JSON data {'name': 'apple'}	items = []	Waiting
2	POST	/items	Append {'name': 'apple'} to items	items = [{'name': 'apple'}]	Waiting
3	POST	/items	Return JSON {'name': 'apple'} with status 201	items = [{'name': 'apple'}]	Response sent: 201 Created
4	GET	/items	Return all items	items = [{'name': 'apple'}]	Response sent: [{'name': 'apple'}]
5	PUT	/items/0	Update item at index 0 with {'name': 'banana'}	items = [{'name': 'banana'}]	Response sent: {'name': 'banana'}
6	DELETE	/items/0	Remove item at index 0	items = []	Response sent: 204 No Content
7	-	-	No more requests	items = []	End of execution

💡 No more HTTP requests to process, CRUD cycle complete.

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 6	Final
items	[]	[{'name': 'apple'}]	[{'name': 'banana'}]	[]	[]

Key Moments - 3 Insights

Why does the list 'items' change after a POST request?

Because in step 2, the POST request adds the new data to the 'items' list, updating its state as shown in the execution_table.

What happens if we try to DELETE an item that does not exist?

The code would likely raise an error or return a 404 response, but in this trace, deletion only happens when the item exists (step 6).

Why does the PUT request update the item instead of adding a new one?

Because the PUT method targets a specific item index (step 5), replacing the existing data rather than appending.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'items' after step 2?

A []

B [{'name': 'apple'}]

C [{'name': 'banana'}]

D [{'name': 'apple'}, {'name': 'banana'}]

💡 Hint

Check the 'Data State' column in row for step 2.

At which step does the 'items' list become empty again?

A Step 3

B Step 5

C Step 6

D Step 4

💡 Hint

Look at the 'Data State' column and find when 'items' is [].

If the POST request sent {'name': 'orange'} instead of {'name': 'apple'}, what would be the 'items' state after step 2?

A [{'name': 'orange'}]

B [{'name': 'apple'}]

C []

D [{'name': 'banana'}]

💡 Hint

Step 2 shows the list after appending the POST data.

Concept Snapshot

CRUD operations in Flask:
- Create: POST /items adds data
- Read: GET /items returns data
- Update: PUT /items/<id> modifies data
- Delete: DELETE /items/<id> removes data
Each route handles one operation and updates the data store accordingly.

Full Transcript

This visual trace shows how Flask handles CRUD operations step-by-step. When a client sends a POST request to /items with JSON data, Flask adds that data to the items list and returns it with status 201. A GET request returns all items. A PUT request updates an item at a specific index, and DELETE removes it. The variable tracker shows how the items list changes after each operation. Key moments clarify why the list changes after POST, how PUT updates instead of adds, and what happens on deletion. The quiz tests understanding of the data state after each step. This helps beginners see how Flask routes map to CRUD actions and how data changes over time.

Practice

1. What does the 'CRUD' acronym stand for in Flask web development?

easy

A. Cache, Route, User, Data

B. Connect, Run, Upload, Download

C. Code, Render, Use, Deploy

D. Create, Read, Update, Delete

Solution

1. Step 1: Understand CRUD basics

   CRUD is a common term in web development describing four basic operations on data.

2. Step 2: Match each letter to its meaning

   C stands for Create, R for Read, U for Update, and D for Delete.

3. Final Answer:

   Create, Read, Update, Delete -> Option D

4. Quick Check:

   CRUD = Create, Read, Update, Delete [OK]

Hint: Remember CRUD as the four main data actions [OK]

Common Mistakes:

• Confusing CRUD with unrelated terms
• Mixing up the order of operations
• Thinking CRUD refers to Flask-specific commands

2. Which HTTP method is typically used in Flask to update an existing resource in a CRUD API?

easy

A. PUT

B. POST

C. GET

D. DELETE

Solution

1. Step 1: Identify HTTP methods for CRUD

   GET is for reading, POST for creating, PUT for updating, DELETE for deleting.

2. Step 2: Match update operation

   Updating a resource uses the PUT method in RESTful APIs like Flask.

3. Final Answer:

   PUT -> Option A

4. Quick Check:

   Update = PUT method [OK]

Hint: Update uses PUT method in REST APIs [OK]

Common Mistakes:

• Using POST instead of PUT for updates
• Confusing GET with update actions
• Using DELETE for updating data

3. Given this Flask route code snippet, what will be the output when a DELETE request is sent to /item/5?

from flask import Flask, jsonify
app = Flask(__name__)
items = {1: 'apple', 5: 'banana'}

@app.route('/item/', methods=['DELETE'])
def delete_item(id):
    if id in items:
        del items[id]
        return jsonify({'message': 'Deleted'}), 200
    else:
        return jsonify({'error': 'Not found'}), 404

medium

A. {"error": "Not found"} with status 404

B. {"message": "Deleted"} with status 200

C. SyntaxError due to missing return statement

D. 500 Internal Server Error

Solution

1. Step 1: Check if item with id 5 exists

   The dictionary items contains key 5 with value 'banana'.

2. Step 2: Analyze DELETE request handling

   Since id 5 exists, it is deleted and a JSON message 'Deleted' with status 200 is returned.

3. Final Answer:

   {"message": "Deleted"} with status 200 -> Option B

4. Quick Check:

   Item 5 exists, so deletion returns success message [OK]

Hint: Check if key exists before delete to decide response [OK]

Common Mistakes:

• Assuming item does not exist and returning 404
• Forgetting to delete the item before returning
• Confusing status codes for success and error

4. Identify the error in this Flask route for creating a new item:

@app.route('/item', methods=['POST'])
def create_item():
    data = request.json
    items.append(data['name'])
    return jsonify({'message': 'Item added'}), 201

medium

A. Missing import of request from flask

B. Using append on a dictionary instead of a list

C. Incorrect HTTP method for creating resource

D. Returning wrong status code

Solution

1. Step 1: Check for necessary imports

   The code uses request.json but does not import request from flask.

2. Step 2: Verify data structure usage

   Assuming items is a list, append is valid; HTTP method POST is correct; status 201 is correct.

3. Final Answer:

   Missing import of request from flask -> Option A

4. Quick Check:

   request must be imported to access request.json [OK]

Hint: Always import request to access JSON data in Flask [OK]

Common Mistakes:

• Forgetting to import request
• Using append on a dict instead of list
• Using GET instead of POST for creation

5. You want to implement a Flask route to update an item only if it exists, otherwise return a 404 error. Which code snippet correctly performs this update using JSON data sent in a PUT request? A)

@app.route('/item/', methods=['PUT'])
def update_item(id):
    data = request.json
    items[id] = data['name']
    return jsonify({'message': 'Updated'}), 200

B)

@app.route('/item/', methods=['PUT'])
def update_item(id):
    if id not in items:
        return jsonify({'error': 'Not found'}), 404
    data = request.json
    items[id] = data['name']
    return jsonify({'message': 'Updated'}), 200

C)

@app.route('/item/', methods=['POST'])
def update_item(id):
    data = request.json
    if id in items:
        items[id] = data['name']
    return jsonify({'message': 'Updated'}), 200

D)

@app.route('/item/', methods=['PUT'])
def update_item(id):
    data = request.json
    if id in items:
        items[id] = data['name']
    else:
        items[id] = 'default'
    return jsonify({'message': 'Updated'}), 200

hard

A. Updates without checking existence, always returns 200

B. Uses POST method incorrectly for update

C. Checks existence, updates if found, else returns 404

D. Adds default if not found instead of 404 error

Solution

1. Step 1: Verify HTTP method and existence check

   Checks existence, updates if found, else returns 404 uses PUT method and checks if id exists before updating.

2. Step 2: Confirm correct response for missing item

   If id not found, it returns 404 error, which is correct behavior for update.

3. Final Answer:

   Checks existence, updates if found, else returns 404 -> Option C

4. Quick Check:

   Update with existence check returns 404 if missing [OK]

Hint: Always check if item exists before update to avoid errors [OK]

Common Mistakes:

• Not checking if item exists before update
• Using POST instead of PUT for update
• Adding default values instead of error on missing item