• Implementing a Cache Using a Python Dictionary
• Caching Strategies
• Diving Into the Least Recently Used (LRU) Cache Strategy
• Peeking Behind the Scenes of the LRU Cache

caching is an optimization technique
can use in applications to keep recent or often-used data in memory locations which are faster or computationally cheaper to access than their source
apps such as a newsreader use caching to keep recent remotely-accessed files locally

import requests

cache = dict()

def get_article_from_server(url):
    print("Fetching article from server...")
    response = requests.get(url)
    return response.text

def get_article(url):
    print("Getting article...")
    if url not in cache:
        cache[url] = get_article_from_server(url)

    return cache[url]

get_article("https://realpython.com/sorting-algorithms-python/")
get_article("https://realpython.com/sorting-algorithms-python/")

$ pip install requests
$ python caching.py
Getting article...
Fetching article from server...
Getting article...

Measuring Efficiency With Big O Notation

the @lru_cache decorator is used for implementing the LRU strategy
can use this decorator to wrap functions and cache their results up to a maximum number of entries

• Playing With Stairs
• Timing Your Code
• Using Memoization to Improve the Solution
• Unpacking the Functionality of @lru_cache

• 0 - 1 - 2 - 3
• 0 - 1 - 3
• 0 - 2 - 3
• 0 - 3

# stairs.py

def steps_to(stair):
    if stair == 1:
        # You can reach the first stair with only a single step
        # from the floor.
        return 1
    elif stair == 2:
        # You can reach the second stair by jumping from the
        # floor with a single two-stair hop or by jumping a single
        # stair a couple of times.
        return 2
    elif stair == 3:
        # You can reach the third stair using four possible
        # combinations:
        # 1. Jumping all the way from the floor
        # 2. Jumping two stairs, then one
        # 3. Jumping one stair, then two
        # 4. Jumping one stair three times
        return 4
    else:
        # You can reach your current stair from three different places:
        # 1. From three stairs down
        # 2. From two stairs down
        # 2. From one stair down
        #
        # If you add up the number of ways of getting to those
        # those three positions, then you should have your solution
        return (
            steps_to(stair - 3)
            + steps_to(stair - 2)
            + steps_to(stair - 1)
        )

print(steps_to(4))

from timeit import repeat

setup_code = "from __main__ import steps_to"
stmt = "steps_to(30)"
times = repeat(setup=setup_code, stmt=stmt, repeat=3, number=10)
print(f"Minimum execution time: {min(times)}")

1. imports the name of steps_to() so that timeit.repeat() knows how to call it
2. prepares the call to the function with the stair number to reach
   as shown in this case is 30
   this is the statement that will be executed and timed
3. calls timeit.repeat() with the setup code and the statement
   syntax of repeat()

   timeit.repeat(stmt='pass', setup='pass', timer=timeit.default_timer, repeat=3, number=1000000)

   the number param is the number of times to call the statement
   the repeat param is the number of times to repeat the number of calls made by number
   above ten calls are made to steps_to()
   those calls are repeated three times
4. identifies and prints the shortest time returned

from functools import lru_cache
from timeit import repeat

@lru_cache
def steps_to(stair):
    if stair == 1:
        ...

from functools import lru_cache
from timeit import repeat

@lru_cache(maxsize=16)
def steps_to(stair):
    if stair == 1:

print(steps_to.cache_info())

3.9998849388211966e-07
CacheInfo(hits=81, misses=30, maxsize=16, currsize=16)

can use .cache_clear() to clear the cache

• Evicting Cache Entries Based on Both Time and Space
• Caching Articles With the New Decorator

below is a script which monitors a website
the example monitors Real Python and prints the number of characters in any article that contains the word python
the monitor runs every five seconds

import feedparser
import requests
import ssl
import time

# this is a workaround to an issue when feedparser tries to access content served over HTTPS
if hasattr(ssl, "_create_unverified_context"):
    ssl._create_default_https_context = ssl._create_unverified_context

def get_article_from_server(url):
    print("Fetching article from server...")
    response = requests.get(url)
    return response.text

# this function runs continuously
def monitor(url):
    maxlen = 45
    # monitor
    while True:
        print("\nChecking feed...")
        # loads and parses the feed from Real Python
        feed = feedparser.parse(url)
        # goes through the first 5 entries on the list
        for entry in feed.entries[:5]:
            if "python" in entry.title.lower():
                truncated_title = (
                    entry.title[:maxlen] + "..."
                    if len(entry.title) > maxlen
                    else entry.title
                )
                print(
                    "Match found:",
                    truncated_title,
                    len(get_article_from_server(entry.link)),
                )

        time.sleep(5)

monitor("https://realpython.com/atom.xml")

$ pip install feedparser requests

can cache the article's contents and avoid hitting the network every five seconds
could use @lru_cache decorator but decorator won't recognize any updates to articles
the first time an article is accessed, the decorator will store its content and return the same data every time after
can set the cache entries to expire

to solve the issue can update the cache implementation so it expires after a specific time
can implement this idea into a new decorator that extending @lru_cache
timed_lru_cache.py

from functools import lru_cache, wraps
from datetime import datetime, timedelta

def timed_lru_cache(seconds: int, maxsize: int = 128):
    def wrapper_cache(func):
        #  wraps the decorated function with the lru_cache decorator
        # allows using the cache functionality already provided by lru_cache
        func = lru_cache(maxsize=maxsize)(func)
        # lifetime of the cache
        func.lifetime = timedelta(seconds=seconds)
        # expiration date-time
        func.expiration = datetime.utcnow() + func.lifetime

        @wraps(func)
        def wrapped_func(*args, **kwargs):
            # check if cache entry is still valid
            if datetime.utcnow() >= func.expiration:
                func.cache_clear()
                func.expiration = datetime.utcnow() + func.lifetime

            return func(*args, **kwargs)

        return wrapped_func

    return wrapper_cache

from timed_lru_cache import timed_lru_cache
import feedparser
import requests
import ssl
import time

from functools import lru_cache, wraps
from datetime import datetime, timedelta

if hasattr(ssl, "_create_unverified_context"):
    ssl._create_default_https_context = ssl._create_unverified_context

@timed_lru_cache(10)
def get_article_from_server(url):
    print("Fetching article from server...")
    response = requests.get(url)
    return response.text

def monitor(url):
    maxlen = 45
    while True:
        print("\nChecking feed...")
        feed = feedparser.parse(url)

        for entry in feed.entries[:5]:
            if "python" in entry.title.lower():
                truncated_title = (
                    entry.title[:maxlen] + "..."
                    if len(entry.title) > maxlen
                    else entry.title
                )
                print(
                    "Match found:",
                    truncated_title,
                    len(get_article_from_server(entry.link)),
                )

        time.sleep(5)

monitor("https://realpython.com/atom.xml")