Exception handling in routes in Flask - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of exception handling in Flask routes?

Exception handling in Flask routes helps catch errors during request processing to prevent the app from crashing and to provide meaningful error messages to users.

beginner

How do you catch exceptions inside a Flask route function?

You use a try-except block inside the route function to catch exceptions and handle them gracefully.

intermediate

What Flask decorator can be used to handle exceptions globally for all routes?

The @app.errorhandler decorator is used to define a function that handles specific exceptions or HTTP error codes globally.

intermediate

What is the benefit of using @app.errorhandler over try-except in each route?

Using @app.errorhandler centralizes error handling, reduces repeated code, and ensures consistent error responses across all routes.

beginner

How can you return a custom error message and status code when an exception occurs in a Flask route?

Inside the except block or error handler, return a Flask response with a message and a status code, e.g., return {'error': 'Not found'}, 404.

Which Flask decorator is used to handle exceptions globally?

A @app.errorhandler

B @app.route

C @app.catch

D @app.exception

The @app.errorhandler decorator is designed to catch exceptions or HTTP errors globally in Flask.

What happens if an exception is not caught in a Flask route?

A Flask returns a default 500 Internal Server Error response

B The app crashes immediately

C The request is retried automatically

D Nothing, the exception is ignored

If an exception is uncaught, Flask returns a 500 Internal Server Error response by default.

Where should you place try-except blocks for best practice in Flask apps?

A Only in the main app file

B Preferably in global error handlers using @app.errorhandler

C Inside each route function

D In the HTML templates

Global error handlers with @app.errorhandler centralize error handling and keep code clean.

How do you return a 404 error with a custom message in a Flask route?

A raise Exception('Not found')

B abort(200)

C return 'Not found'

D return {'error': 'Not found'}, 404

Returning a tuple with a dictionary and status code sends a custom JSON message with the 404 status.

What is commonly used to abort a request with an HTTP error in Flask?

A ValueError

B KeyError

C flask.abort

D flask.RequestException

The flask.abort function raises an HTTPException to abort a request with a specific HTTP status code.

Explain how to handle exceptions inside a Flask route and how to provide a custom error response.

Think about using try-except and returning a tuple with message and code.

Describe the use and benefits of the @app.errorhandler decorator in Flask.

Consider how centralizing error handling helps maintain your app.

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