Cache invalidation strategies in Django - Mini Project: Build & Apply

Cache Invalidation Strategies in Django

📖 Scenario: You are building a Django web application that shows a list of products. To improve performance, you want to cache the product list page. However, when products change, the cache must be invalidated so users see fresh data.

🎯 Goal: Build a simple Django view that caches the product list page and invalidates the cache when a product is updated.

📋 What You'll Learn

Create a dictionary called products with three products and their prices.

Create a variable called cache_timeout and set it to 300 seconds.

Write a Django view function called product_list that caches the product list page using cache.get and cache.set.

Add a function called invalidate_cache that deletes the cached product list when a product is updated.

💡 Why This Matters

🌍 Real World

Caching is used in web apps to speed up page loading by storing data temporarily. Cache invalidation ensures users see updated information after changes.

💼 Career

Understanding cache invalidation is important for backend developers working with Django or any web framework to build fast and reliable applications.

1

Create the initial product data

Create a dictionary called products with these exact entries: 'apple': 1.2, 'banana': 0.5, 'cherry': 2.5.

Django

# Create the products dictionary with exact entries
# Your code here

Hint

Use curly braces to create a dictionary with the exact keys and values.

2

Set the cache timeout duration

Create a variable called cache_timeout and set it to 300 (seconds).

Django

products = {'apple': 1.2, 'banana': 0.5, 'cherry': 2.5}
# Set cache_timeout to 300 seconds
# Your code here

Hint

Just assign the number 300 to the variable cache_timeout.

3

Create the cached product list view

Write a Django view function called product_list that uses cache.get('product_list') to get cached data. If cache is empty, create a string listing products and prices, then store it with cache.set('product_list', product_data, cache_timeout). Return the product data string.

Django

products = {'apple': 1.2, 'banana': 0.5, 'cherry': 2.5}
cache_timeout = 300
from django.core.cache import cache

def product_list(request):
    # Your code here

Hint

Use cache.get to check cache, build the string if missing, then use cache.set to save it.

4

Add cache invalidation function

Add a function called invalidate_cache that calls cache.delete('product_list') to remove the cached product list when a product is updated.

Django

products = {'apple': 1.2, 'banana': 0.5, 'cherry': 2.5}
cache_timeout = 300
from django.core.cache import cache

def product_list(request):
    product_data = cache.get('product_list')
    if product_data is None:
        product_data = '\n'.join(f"{name}: ${price}" for name, price in products.items())
        cache.set('product_list', product_data, cache_timeout)
    return product_data

def invalidate_cache():
    # Your code here

Hint

Use cache.delete with the same cache key to remove cached data.

Practice

1. What is the main purpose of cache invalidation in Django caching?

easy

A. To store data permanently without expiration

B. To keep cached data fresh and accurate

C. To increase the size of the cache

D. To disable caching completely

Solution

1. Step 1: Understand cache invalidation concept

   Cache invalidation means removing or updating cached data so it stays correct and up-to-date.

2. Step 2: Identify the purpose in Django caching

   In Django, cache invalidation ensures users see fresh data by removing outdated cache entries.

3. Final Answer:

   To keep cached data fresh and accurate -> Option B

4. Quick Check:

   Cache invalidation = fresh data [OK]

Hint: Cache invalidation means keeping data fresh [OK]

Common Mistakes:

• Thinking cache invalidation increases cache size
• Believing cache never expires
• Confusing cache invalidation with disabling cache

2. Which Django cache method is used to remove a specific cached item?

easy

A. cache.delete()

B. cache.clear()

C. cache.set()

D. cache.get()

Solution

1. Step 1: Recall Django cache methods

   cache.delete() removes a specific key from the cache, clearing that cached item.

2. Step 2: Differentiate from other methods

   cache.clear() removes all cache, cache.set() adds data, cache.get() retrieves data.

3. Final Answer:

   cache.delete() -> Option A

4. Quick Check:

   Remove specific cache = cache.delete() [OK]

Hint: Use cache.delete() to remove one cached item [OK]

Common Mistakes:

• Using cache.clear() to remove one item
• Confusing cache.set() with deletion
• Trying to delete cache with cache.get()

3. Given this code snippet, what will be the output if the cache key 'user_1' is deleted before retrieval?

from django.core.cache import cache
cache.set('user_1', 'Alice', timeout=300)
cache.delete('user_1')
result = cache.get('user_1', 'Not Found')
print(result)

medium

A. Not Found

B. Alice

C. None

D. Error

Solution

1. Step 1: Analyze cache.set and cache.delete calls

   The key 'user_1' is set to 'Alice' but then immediately deleted from cache.

2. Step 2: Check cache.get behavior after deletion

   Since 'user_1' was deleted, cache.get returns the default value 'Not Found'.

3. Final Answer:

   Not Found -> Option A

4. Quick Check:

   Deleted key returns default value [OK]

Hint: Deleted cache keys return default on get [OK]

Common Mistakes:

• Expecting 'Alice' after deletion
• Assuming cache.get returns None by default
• Thinking deletion causes error

4. Identify the error in this Django cache invalidation code:

from django.core.cache import cache
cache.set('page_data', 'content', timeout=600)
cache.delete('page_data')
cache.delete('page_data')

medium

A. cache.set() must be called after cache.delete()

B. cache.delete() requires a timeout argument

C. Deleting the same key twice causes an error

D. No error; deleting a non-existent key is safe

Solution

1. Step 1: Understand cache.delete behavior

   Deleting a key that does not exist does not cause an error in Django cache.

2. Step 2: Check the code sequence

   First delete removes 'page_data', second delete tries to remove it again safely without error.

3. Final Answer:

   No error; deleting a non-existent key is safe -> Option D

4. Quick Check:

   Deleting missing key is safe [OK]

Hint: Deleting missing cache keys is safe [OK]

Common Mistakes:

• Thinking deleting twice causes error
• Believing cache.delete needs timeout
• Assuming cache.set must follow delete

5. You want to ensure cached user profile data expires automatically after 10 minutes but also want to manually clear it when the user updates their profile. Which cache invalidation strategy combination is best?

hard

A. Use cache.clear() to remove all cache every 10 minutes

B. Only use cache.set() with timeout=600, no manual deletion

C. Use cache.set() with timeout=600 and call cache.delete() on profile update

D. Only use cache.delete() without timeout

Solution

1. Step 1: Understand automatic expiration

   Setting timeout=600 (10 minutes) makes cache auto-expire after that time.

2. Step 2: Understand manual invalidation need

   Calling cache.delete() on profile update removes stale cached data immediately.

3. Step 3: Combine both strategies

   Using both timeout and manual delete ensures fresh data and timely expiration.

4. Final Answer:

   Use cache.set() with timeout=600 and call cache.delete() on profile update -> Option C

5. Quick Check:

   Timeout + manual delete = best strategy [OK]

Hint: Combine timeout and manual delete for fresh cache [OK]

Common Mistakes:

• Relying only on timeout causes stale data after update
• Using cache.clear() removes all cache unnecessarily
• Deleting without timeout loses auto-expiration benefit