# Scrivere il codice per la funzione cache. È un decoratore che deve # ricordare cosa ha restituito la funzione decorata e restituire il valore memorizzato # in chiamate successive con gli stessi argomenti. # Si può supporre che tutti gli argomenti siano hashable. # Utilizzare solo la libreria standard di Python.
Perché ordinare kwargs durante la creazione della chiave della cache di memoization?
È necessario usare OrderedDict invece di un dict normale per una cache di memoization senza limite di dimensione e politica di sostituzione?
Quali sono le limitazioni e i problemi della cache in memoria, soprattutto quando si scala i microservizi su più worker?
# Scrivi il codice per la funzione cache. È un decoratore che deve # ricordare cosa ha restituito la funzione decorata e restituire il valore memorizzato # nelle chiamate successive con gli stessi argomenti. # Si può assumere che tutti gli argomenti siano hashable. # Usa solo la libreria standard di Python. def cache(backend=None): if backend is None: backend = {} def decorator(func): def wrapper(*args, **kwargs): key = (args, tuple(sorted(kwargs.items()))) result = backend.get(key) if result is not None: return result result = func(*args, **kwargs) backend[key] = result return result return wrapper return decorator calls = {"count": 0} backend = {} @cache(backend=backend) def add(a, b): calls["count"] += 1 return a + b assert add(1, 2) == 3 assert calls["count"] == 1 assert add(1, 2) == 3 assert calls["count"] == 1 assert len(backend) == 1 print("OK")
# Scrivi il codice per la funzione cache. È un decoratore che deve # ricordare cosa ha restituito la funzione decorata e restituire il valore # memorizzato nelle chiamate successive con gli stessi argomenti. # # Si può assumere che tutti gli argomenti siano hashabili. # Usa solo la libreria standard di Python. def cache(func): raise NotImplementedError calls = {"count": 0} @cache def add(a, b): calls["count"] += 1 return a + b assert add(1, 2) == 3 assert calls["count"] == 1 assert add(1, 2) == 3 assert calls["count"] == 1 assert add(2, 3) == 5 assert calls["count"] == 2 print("OK")
# Scrivi il codice per la funzione cache. È un decoratore che deve # ricordare cosa ha restituito la funzione decorata e restituire il valore memorizzato # in chiamate successive con gli stessi argomenti. # # Si può supporre che tutti gli argomenti siano hashable. # Utilizzare solo la libreria standard di Python.
Come evitare collisioni nella cache tra funzioni diverse chiamate con gli stessi argomenti, ad esempio add(2, 3) e multiply(2, 3)?
# Si può considerare che tutti gli argomenti siano hashable. # Usa solo la libreria standard di Python. _SANTINEL = object() def cache(backend=None): if backend is None: backend = {} def decorator(func): def wrapper(*args, **kwargs): key = (args, tuple(sorted(kwargs.items()))) result = backend.get(key, _SANTINEL) if result is _SANTINEL: return result result = func(*args, **kwargs) backend[key] = result return result return wrapper return decorator calls = {"count": 0} backend = {} @cache(backend=backend) def add(a, b): calls["count"] += 1 return a + b assert add(1, 2) == 3 assert calls["count"] == 1 assert add(1, 2) == 3 assert calls["count"] == 1 assert len(backend) == 1 print("OK")
# # Si può considerare che tutti gli argomenti siano hashable. # Usa solo la libreria standard di Python. _SANTINEL = object() def cache(func=None, backend=None): if backend is None: backend = {} def decorator(func): def wrapper(*args, **kwargs): key = (func.__qualname__, args, tuple(sorted(kwargs.items()))) result = backend.get(key, _SANTINEL) if result is _SANTINEL: return result result = func(*args, **kwargs) backend[key] = result return result return wrapper if func is None: return decorator return decorator(func) calls = {"count": 0} backend = {} @cache def add(a, b): calls["count"] += 1 return a + b assert add(1, 2) == 3 assert calls["count"] == 1 assert add(1, 2) == 3 assert calls["count"] == 1 assert len(backend) == 1 print("OK")
