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.

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