Flask-Caching for response caching

Introduction

Flask-Caching helps your web app remember responses so it can send them faster next time. This saves time and makes your app feel quicker.

When your app shows data that doesn't change often, like a homepage or product list.

When you want to reduce the load on your server by not repeating heavy calculations.

When you want to speed up API responses for repeated requests.

When you want to improve user experience by making pages load faster.

When you want to save bandwidth by sending cached responses instead of generating new ones.

Syntax

Flask

from flask_caching import Cache

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

@app.route('/some')
@cache.cached(timeout=60)
def some_view():
    # generate response
    return 'Hello, cached!'

Use @cache.cached(timeout=seconds) above a view function to cache its response.

Configure cache type in Cache(app, config={...}). 'simple' stores cache in memory.

Examples

This caches the homepage response for 30 seconds.

Flask

from flask_caching import Cache

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

@app.route('/')
@cache.cached(timeout=30)
def home():
    return 'Welcome! This page is cached for 30 seconds.'

This caches the current time for 10 seconds, so repeated requests within 10 seconds get the same time.

Flask

@app.route('/time')
@cache.cached(timeout=10)
def time():
    import datetime
    return f"Current time: {datetime.datetime.now()}"

This example uses filesystem caching to store cache on disk instead of memory.

Flask

cache = Cache(app, config={'CACHE_TYPE': 'filesystem', 'CACHE_DIR': '/tmp/cache'})

@app.route('/data')
@cache.cached(timeout=120)
def data():
    return 'Data cached on disk for 2 minutes.'

Sample Program

This Flask app shows the current time on the homepage. The response is cached for 15 seconds, so refreshing the page within 15 seconds shows the same time. After 15 seconds, the cache expires and the time updates.

Flask

from flask import Flask
from flask_caching import Cache
import datetime

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

@app.route('/')
@cache.cached(timeout=15)
def index():
    now = datetime.datetime.now()
    return f"Hello! Current time is {now.strftime('%H:%M:%S')}"

if __name__ == '__main__':
    app.run(debug=True)

Important Notes

Cached responses are stored for the time you set in timeout. After that, the cache refreshes.

Use simple cache for development. For production, consider Redis or Memcached for better performance.

Remember to install Flask-Caching with pip install Flask-Caching before using it.

Summary

Flask-Caching stores responses to speed up your app.

Use @cache.cached(timeout=seconds) to cache view outputs.

Choose cache type based on your needs: simple, filesystem, Redis, etc.

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