Exception handling in routes in Flask - Step-by-Step Execution

Concept Flow - Exception handling in routes

Request comes in

↓

Route function starts

↓

Try block executes

↓

No error

↓

Return normal

↓

Send response

↓

End

When a request hits a route, the code inside a try block runs. If an error happens, the except block catches it and returns an error response.

Execution Sample

Flask

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

@app.route('/data')
def data_route():
    try:
        result = 10 / 0
        return jsonify({'result': result})
    except ZeroDivisionError:
        return jsonify({'error': 'Cannot divide by zero'}), 400

This route tries to divide 10 by 0, which causes an error. The except block catches it and returns a JSON error message with status 400.

Execution Table

Step	Action	Evaluation	Result
1	Request to /data route	Route function called	Enter data_route()
2	Try block starts	Execute 'result = 10 / 0'	Raises ZeroDivisionError
3	Exception caught	ZeroDivisionError caught by except	Prepare error JSON response
4	Return response	Return jsonify({'error': 'Cannot divide by zero'}), 400	Client receives error JSON with status 400
5	End	Route function ends	Response sent, request complete

💡 Exception raised during division, caught by except block, so normal flow stops and error response is sent

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
result	undefined	Exception raised, no value assigned	undefined	undefined

Key Moments - 2 Insights

Why doesn't the route crash when dividing by zero?

Because the ZeroDivisionError is caught in the except block (see execution_table step 3), so the error is handled gracefully.

What happens if no exception occurs in the try block?

The code after the try block runs normally and returns the successful JSON response (not shown here, but would be in execution_table step 2 if no error).

Visual Quiz - 3 Questions

Look at the execution table, what happens at step 2?

A The division 10 / 0 executes successfully

B ZeroDivisionError is raised during division

C The except block returns the error response

D The route function ends

💡 Hint

Check the 'Evaluation' column at step 2 in the execution_table

At which step does the route send the error response to the client?

A Step 1

B Step 2

C Step 4

D Step 5

💡 Hint

Look for 'Return response' action in the execution_table

If the division was 10 / 2 instead, how would the execution_table change?

A Step 2 would assign result = 5 and no exception occurs

B Step 3 would still catch an exception

C Step 4 would return an error response

D The route would crash

💡 Hint

Refer to variable_tracker and execution_table step 2 for normal execution

Concept Snapshot

Exception handling in Flask routes:
Use try-except inside route functions.
Try block runs code that may fail.
Except block catches errors and returns responses.
Prevents server crashes and sends user-friendly errors.
Example: catch ZeroDivisionError and return JSON error.

Full Transcript

In Flask, when a request comes to a route, the route function runs. We put risky code inside a try block. If an error like ZeroDivisionError happens, the except block catches it. Then the route returns a JSON error message with a status code, instead of crashing. This keeps the app stable and user-friendly. The execution table shows each step: starting the route, running the try block, catching the error, returning the error response, and ending the request.

Practice

1. What is the main purpose of using @app.errorhandler in a Flask route?

easy

A. To connect to a database automatically

B. To define a new route in the Flask app

C. To catch specific errors and return custom responses

D. To start the Flask application server

Solution

1. Step 1: Understand the role of @app.errorhandler

   This decorator is used to catch exceptions or errors that happen during request handling.

2. Step 2: Purpose in routes

   It allows you to return a custom message or page instead of a default error, improving user experience.

3. Final Answer:

   To catch specific errors and return custom responses -> Option C

4. Quick Check:

   Error handling = catch and respond [OK]

Hint: Errorhandler decorates functions to catch errors in routes [OK]

Common Mistakes:

• Confusing errorhandler with route decorator
• Thinking it starts the server
• Assuming it connects to databases

2. Which of the following is the correct syntax to handle a 404 error in Flask?

easy

A. @app.errorhandler(404)
def not_found(error):
return 'Page not found', 404

B. @app.route(404)
def not_found():
return 'Page not found'

C. @app.errorhandler('404')
def not_found(error):
return 'Page not found', 404

D. @app.errorhandler(404)
def not_found():
return 'Page not found'

Solution

1. Step 1: Check the decorator usage

   The correct decorator is @app.errorhandler(404) with the status code as an integer.

2. Step 2: Verify function signature and return

   The handler function should accept an error argument and return a response with the status code.

3. Final Answer:

   @app.errorhandler(404)\ndef not_found(error):\n return 'Page not found', 404 -> Option A

4. Quick Check:

   Correct decorator and function signature = A [OK]

Hint: Use integer status code and error parameter in handler [OK]

Common Mistakes:

• Using @app.route instead of @app.errorhandler
• Passing status code as string '404'
• Missing error parameter in handler function

3. Given this Flask code snippet, what will be the output when accessing /divide/10/0?

from flask import Flask
app = Flask(__name__)

@app.route('/divide/<int:a>/<int:b>')
def divide(a, b):
    try:
        result = a / b
        return str(result)
    except ZeroDivisionError:
        return 'Cannot divide by zero', 400

medium

A. ZeroDivisionError exception traceback

B. 0

C. 10

D. Cannot divide by zero with HTTP status 400

Solution

1. Step 1: Analyze the route and input

   The route divides a by b. Input is 10 and 0, so division by zero occurs.

2. Step 2: Check exception handling

   The ZeroDivisionError is caught, returning 'Cannot divide by zero' with status 400.

3. Final Answer:

   Cannot divide by zero with HTTP status 400 -> Option D

4. Quick Check:

   ZeroDivisionError caught returns message and 400 [OK]

Hint: Try-except catches zero division, returns error message [OK]

Common Mistakes:

• Expecting a crash or traceback
• Ignoring the exception handling block
• Assuming division returns 0

4. Identify the error in this Flask route error handling code:

@app.errorhandler(500)
def internal_error():
    return 'Internal Server Error', 500

medium

A. The handler function must accept an error parameter

B. The status code 500 is invalid for errorhandler

C. The return statement should not include status code

D. The decorator should be @app.route, not @app.errorhandler

Solution

1. Step 1: Check function signature for errorhandler

   Functions decorated with @app.errorhandler must accept one parameter for the error.

2. Step 2: Verify other parts

   Status code 500 is valid, return with status code is correct, and decorator usage is correct.

3. Final Answer:

   The handler function must accept an error parameter -> Option A

4. Quick Check:

   Errorhandler function needs error argument [OK]

Hint: Errorhandler functions always take an error argument [OK]

Common Mistakes:

• Omitting the error parameter in handler function
• Using wrong decorator for error handling
• Returning without status code

5. You want to handle both 404 and 500 errors in your Flask app with custom JSON responses. Which approach correctly implements this?

hard

A. Use one function with @app.errorhandler([404, 500]) to handle both errors

B. Define two separate functions with @app.errorhandler(404) and @app.errorhandler(500), returning JSON and status codes

C. Handle errors inside each route function with try-except blocks only

D. Set app.config['ERROR_404_JSON'] = True and Flask will auto-handle JSON errors

Solution

1. Step 1: Understand Flask errorhandler usage

   Flask requires separate functions for different error codes with their own decorators.

2. Step 2: Confirm JSON response and status code

   Each handler should return a JSON response and the correct HTTP status code for clarity.

3. Final Answer:

   Define two separate functions with @app.errorhandler(404) and @app.errorhandler(500), returning JSON and status codes -> Option B

4. Quick Check:

   Separate handlers per error code = A [OK]

Hint: Use separate errorhandler functions for each error code [OK]

Common Mistakes:

• Trying to handle multiple errors in one function decorator
• Relying only on try-except inside routes
• Assuming Flask auto-converts errors to JSON