Flask-Caching for response caching - Mini Project: Build & Apply

Flask-Caching for response caching

📖 Scenario: You are building a simple Flask web app that shows the current time. To make it faster and reduce server load, you want to cache the response for 10 seconds so repeated visits within that time show the cached time instead of recalculating.

🎯 Goal: Create a Flask app with a route /time that returns the current time. Use Flask-Caching to cache the response for 10 seconds.

📋 What You'll Learn

Create a Flask app instance named app

Set up Flask-Caching with a simple cache type

Create a route /time that returns the current time as a string

Cache the /time route response for 10 seconds using Flask-Caching

💡 Why This Matters

🌍 Real World

Caching responses in web apps improves speed and reduces server load, especially for data that doesn't change often.

💼 Career

Many web developer roles require knowledge of caching techniques to optimize app performance and scalability.

1

Set up the Flask app and import modules

Import Flask from flask and create a Flask app instance called app.

Flask

from flask import Flask

# Create the Flask app instance called app
# Your code here

Hint

Use app = Flask(__name__) to create the app instance.

2

Configure Flask-Caching

Import Cache from flask_caching. Create a Cache instance called cache and initialize it with app using the simple cache type.

Flask

from flask import Flask
from flask_caching import Cache

app = Flask(__name__)

# Create Cache instance and initialize with app using simple cache
# Your code here

Hint

Use Cache(app, config={'CACHE_TYPE': 'SimpleCache'}) to set up caching.

3

Create the /time route with caching

Import datetime from datetime. Create a route /time using @app.route('/time'). Use @cache.cached(timeout=10) decorator to cache the response for 10 seconds. Inside the function time(), return the current time as a string using datetime.now().strftime('%H:%M:%S').

Flask

from flask import Flask
from flask_caching import Cache
from datetime import datetime

app = Flask(__name__)

cache = Cache(app, config={'CACHE_TYPE': 'SimpleCache'})

# Create /time route with caching for 10 seconds
# Your code here

Hint

Use @cache.cached(timeout=10) above the route function to cache the response for 10 seconds.

4

Add the app run block

Add the standard Flask app run block: if __name__ == '__main__': and inside it call app.run(debug=True).

Flask

from flask import Flask
from flask_caching import Cache
from datetime import datetime

app = Flask(__name__)

cache = Cache(app, config={'CACHE_TYPE': 'SimpleCache'})

@app.route('/time')
@cache.cached(timeout=10)
def time():
    return datetime.now().strftime('%H:%M:%S')

# Add the app run block below
# Your code here

Hint

This block runs the app when you execute the script directly.

Practice

1. What is the main purpose of using Flask-Caching in a Flask application?

easy

A. To handle database migrations automatically

B. To secure the application from unauthorized access

C. To store responses temporarily to speed up repeated requests

D. To manage user sessions and cookies

Solution

1. Step 1: Understand Flask-Caching role

   Flask-Caching is used to save the output of views temporarily.

2. Step 2: Identify the benefit

   Saving responses reduces processing time for repeated requests, speeding up the app.

3. Final Answer:

   To store responses temporarily to speed up repeated requests -> Option C

4. Quick Check:

   Flask-Caching = Response speedup [OK]

Hint: Caching saves repeated response time, boosting speed [OK]

Common Mistakes:

• Confusing caching with security features
• Thinking caching manages database or sessions
• Assuming caching permanently stores data

2. Which of the following is the correct way to cache a Flask view response for 60 seconds using Flask-Caching?

easy

A. @cache.cached(timeout=60)
def my_view():
return 'Hello World'

B. @cache.cache(timeout=60)
def my_view():
return 'Hello World'

C. @cache.cached(60)
def my_view():
return 'Hello World'

D. @cache.cache(60)
def my_view():
return 'Hello World'

Solution

1. Step 1: Identify correct decorator name

   The correct decorator is @cache.cached with a named argument timeout.

2. Step 2: Check syntax for timeout

   Timeout must be passed as a keyword argument: timeout=60.

3. Final Answer:

   @cache.cached(timeout=60)\ndef my_view():\n return 'Hello World' -> Option A

4. Quick Check:

   Decorator name and timeout keyword correct = A [OK]

Hint: Use @cache.cached(timeout=seconds) exactly [OK]

Common Mistakes:

• Using @cache.cache instead of @cache.cached
• Passing timeout as positional argument
• Omitting the timeout keyword

3. Given this Flask code snippet using Flask-Caching, what will be printed on the second request to /time within 10 seconds?

from flask import Flask
from flask_caching import Cache
import time

app = Flask(__name__)
cache = Cache(app, config={'CACHE_TYPE': 'simple'})

@app.route('/time')
@cache.cached(timeout=10)
def get_time():
    return str(time.time())

# Assume the first request prints 1680000000.0

medium

A. A new timestamp different from 1680000000.0

B. The string 'None'

C. An error because caching is not configured

D. The same timestamp 1680000000.0

Solution

1. Step 1: Understand caching behavior

   The first call caches the response (timestamp) for 10 seconds.

2. Step 2: Predict second request output within timeout

   Within 10 seconds, the cached response is returned, so the timestamp stays the same.

3. Final Answer:

   The same timestamp 1680000000.0 -> Option D

4. Quick Check:

   Cached response repeats within timeout = D [OK]

Hint: Cached output repeats until timeout expires [OK]

Common Mistakes:

• Expecting a new timestamp every request
• Assuming caching is disabled without error
• Confusing cache timeout with immediate refresh

4. What is wrong with this Flask-Caching setup code?

from flask import Flask
from flask_caching import Cache

app = Flask(__name__)
cache = Cache()

@cache.cached(timeout=30)
@app.route('/')
def home():
    return 'Welcome!'

cache.init_app(app)

medium

A. The order of decorators is incorrect; @app.route should be above @cache.cached

B. Cache must be initialized before defining cached routes

C. cache.init_app(app) should be called before using @cache.cached

D. No error; this code works correctly

Solution

1. Step 1: Check decorator order

   In Flask, @app.route must be the outer decorator, so it should be above @cache.cached.

2. Step 2: Understand decorator stacking

   Incorrect order causes the route not to register properly, breaking caching behavior.

3. Final Answer:

   The order of decorators is incorrect; @app.route should be above @cache.cached -> Option A

4. Quick Check:

   Decorator order matters = B [OK]

Hint: Place @app.route above @cache.cached [OK]

Common Mistakes:

• Swapping decorator order
• Thinking cache.init_app must be before decorators
• Assuming no error with wrong decorator order

5. You want to cache a Flask view response but only for requests with a query parameter ?user=admin. Which approach correctly applies Flask-Caching to cache only those responses?

hard

A. Use @cache.cached(timeout=30, query_string=True) and check user param inside view

B. Use @cache.cached(timeout=30, unless=lambda: request.args.get('user') != 'admin')

C. Use @cache.cached(timeout=30) and manually cache responses inside the view

D. Use @cache.memoize(timeout=30) without conditions

Solution

1. Step 1: Understand conditional caching

   Flask-Caching's unless parameter skips caching when condition is True.

2. Step 2: Apply condition for user param

   Using unless=lambda: request.args.get('user') != 'admin' caches only when user is 'admin'.

3. Final Answer:

   Use @cache.cached(timeout=30, unless=lambda: request.args.get('user') != 'admin') -> Option B

4. Quick Check:

   Conditional caching uses unless param = A [OK]

Hint: Use unless param to skip caching conditionally [OK]

Common Mistakes:

• Using query_string=True without filtering user
• Trying to cache manually inside view
• Using memoize without conditions