Flask-Caching for response caching - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the caching extension in Flask.

Flask

from flask_caching import [1]

Drag options to blanks, or click blank then click option'

ACacheManager

BCache

CCacheControl

DCacheExtension

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'CacheControl' which is unrelated to Flask-Caching.

Using 'CacheManager' which does not exist in this package.

The correct class to import for Flask-Caching is Cache.

2fill in blank

medium

Complete the code to initialize caching with Flask app.

Flask

cache = [1](app)

Drag options to blanks, or click blank then click option'

ACache

BCacheControl

CCacheManager

DCacheExtension

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong class name like 'CacheControl'.

Forgetting to pass the app instance.

To initialize caching, create a Cache object passing the Flask app.

3fill in blank

hard

Fix the error in the decorator to cache the response for 60 seconds.

Flask

@cache.[1](timeout=60)
def get_data():
    return 'Hello, cached!'

Drag options to blanks, or click blank then click option'

Acache_response

Bcache_response_for

Ccache_it

Dcached

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-existent decorator names like 'cache_response'.

Confusing with other caching libraries.

The correct decorator method is cached to cache the function's response.

4fill in blank

hard

Fill both blanks to configure Flask-Caching with simple cache type and 300 seconds timeout.

Flask

app.config['CACHE_TYPE'] = '[1]'
app.config['CACHE_DEFAULT_TIMEOUT'] = [2]

Drag options to blanks, or click blank then click option'

Asimple

Bredis

C300

D60

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'redis' without having Redis installed or configured.

Setting timeout to 60 instead of 300.

Use 'simple' for basic in-memory caching and set timeout to 300 seconds.

5fill in blank

hard

Fill all three blanks to create a cached route that returns JSON with a 120 seconds cache timeout.

Flask

@app.route('/data')
@cache.[1](timeout=[2])
def data():
    return [3]({'message': 'Hello, world!'})

Drag options to blanks, or click blank then click option'

Acached

B120

Cjsonify

Dcache_response

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong decorator name like 'cache_response'.

Returning a dict directly instead of using jsonify.

Setting timeout to wrong values.

The route uses the cached decorator with timeout 120 seconds and returns JSON using jsonify.

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