Flask-Caching for response caching - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Flask route with caching?

Consider this Flask app snippet using Flask-Caching. What will be the output if you call the /time route twice within 10 seconds?

Flask

from flask import Flask
from flask_caching import Cache
import time

app = Flask(__name__)
app.config['CACHE_TYPE'] = 'SimpleCache'
app.config['CACHE_DEFAULT_TIMEOUT'] = 10
cache = Cache(app)

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

A The first call returns an error, the second returns the timestamp.

B Each call returns a different timestamp string.

C Both calls return the exact same timestamp string.

D Both calls return an empty string.

💡 Hint

Think about what caching does to the function output within the timeout period.

The @cache.cached() decorator caches the output of the route for the default timeout (10 seconds). So repeated calls within that time return the cached response, which is the same timestamp string.

📝 Syntax

intermediate

Which option correctly initializes Flask-Caching with Redis backend?

You want to use Redis as the cache backend in Flask-Caching. Which code snippet correctly sets this up?

A

app.config['CACHE_TYPE'] = 'redis'
app.config['CACHE_REDIS_URL'] = 'redis://localhost:6379/0'
cache = Cache(app)

B

app.config['CACHE_TYPE'] = 'RedisCache'
app.config['CACHE_REDIS_URL'] = 'redis://localhost:6379/0'
cache = Cache(app)

C

app.config['CACHE_TYPE'] = 'Redis'
app.config['CACHE_REDIS_URL'] = 'redis://localhost:6379/0'
cache = Cache(app)

D

app.config['CACHE_TYPE'] = 'redis'
app.config['REDIS_URL'] = 'redis://localhost:6379/0'
cache = Cache(app)

💡 Hint

Check the exact string Flask-Caching expects for Redis backend type and the config key for Redis URL.

Flask-Caching expects 'redis' (all lowercase) for CACHE_TYPE and 'CACHE_REDIS_URL' for the Redis connection string. Option A matches this exactly.

🔧 Debug

advanced

What controls the cache timeout in this decorated route?

Given this Flask route using Flask-Caching with both CACHE_DEFAULT_TIMEOUT=5 and decorator timeout=5, what determines the actual cache duration?

Flask

from flask import Flask
from flask_caching import Cache
import time

app = Flask(__name__)
app.config['CACHE_TYPE'] = 'SimpleCache'
app.config['CACHE_DEFAULT_TIMEOUT'] = 5
cache = Cache(app)

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

A The CACHE_DEFAULT_TIMEOUT overrides the decorator's timeout parameter.

B The route function is not executed after the first call.

C SimpleCache does not respect the timeout parameter.

D The decorator's timeout=5 controls the cache duration for this route.

💡 Hint

Consider how the timeout parameter in the @cache.cached() decorator interacts with the app's CACHE_DEFAULT_TIMEOUT.

The @cache.cached(timeout=5) decorator explicitly sets the timeout to 5 seconds for this route, taking precedence over the app.config['CACHE_DEFAULT_TIMEOUT']. Repeated calls within 5 seconds return the cached response; after 5 seconds, the function re-executes and returns a new timestamp.

🧠 Conceptual

advanced

What happens if you use @cache.cached() on a route with dynamic URL parameters?

You decorate a Flask route with @cache.cached() but the route has a dynamic parameter like /user/<id>. What is the caching behavior?

Flask

from flask import Flask
from flask_caching import Cache
import time

app = Flask(__name__)
app.config['CACHE_TYPE'] = 'SimpleCache'
cache = Cache(app)

@app.route('/user/<id>')
@cache.cached()
def user_profile(id):
    return f"User {id} profile at {time.time()}"

A The cache key ignores the dynamic parameter, so all user IDs share the same cached response.

B The cache key includes the dynamic parameter, so each user ID caches separately.

C The cache decorator raises an error because dynamic parameters are not supported.

D The cache is disabled automatically for routes with dynamic parameters.

💡 Hint

Think about how Flask-Caching generates cache keys by default for routes with parameters.

By default, @cache.cached() generates cache keys based on the request path, which includes dynamic path parameters (<id>). Thus, /user/1 and /user/2 have different paths (/user/1 vs. /user/2) and therefore different cache keys, caching separately.

❓ state_output

expert

What is the output count after these cached Flask route calls?

Given this Flask app, what is the value of counter after calling /increment route 3 times quickly?

Flask

from flask import Flask
from flask_caching import Cache

app = Flask(__name__)
app.config['CACHE_TYPE'] = 'SimpleCache'
app.config['CACHE_DEFAULT_TIMEOUT'] = 60
cache = Cache(app)

counter = 0

@app.route('/increment')
@cache.cached()
def increment():
    global counter
    counter += 1
    return str(counter)

A counter is 1, and all 3 calls return '1'.

B counter is 3, and calls return '1', '2', '3' respectively.

C counter is 0, and all calls return '0'.

D counter is 3, but all calls return '3'.

💡 Hint

Remember what caching does to function execution and state changes.

The @cache.cached() decorator caches the entire response of the route. On the first call, counter increments from 0 to 1 and returns '1'. This response is cached. Subsequent calls within the cache timeout return the cached response without executing the function again, so counter does not increment further and remains 1.