# Escrever código para a função cache. É um decorador que deve # lembrar o que a função decorada retornou, e devolver o valor guardado # em chamadas subsequentes com os mesmos argumentos. # Pode-se assumir que todos os argumentos são hasháveis. # Usar apenas a biblioteca padrão do Python.
Por que ordenar kwargs ao construir a chave do cache de memoização?
É necessário usar OrderedDict em vez de um dicionário comum para um cache de memoization sem limite de tamanho e política de substituição?
Quais são as limitações e problemas do cache em memória, especialmente ao escalar microserviços para vários trabalhadores?
# Escrever código para a função cache. É um decorador que deve # lembrar o que a função decorada retornou, e devolver o valor guardado # em chamadas subsequentes com os mesmos argumentos. # # Pode-se assumir que todos os argumentos são hasháveis. # Usar apenas a biblioteca padrão do 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")
# Escrever código para a função cache. É um decorador que deve # recordar o que a função decorada retornou, e devolver o valor guardado # em chamadas subsequentes com os mesmos argumentos. # Pode-se assumir que todos os argumentos são hasháveis. # Usar apenas a biblioteca padrão do 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")
# Escreva o código para a função cache. É um decorador que deve # lembrar-se do que a função decorada retornou, e retornar o valor guardado # em chamadas subsequentes com os mesmos argumentos. # # Pode-se assumir que todos os argumentos são hasháveis. # Usar apenas a biblioteca padrão do Python.
Como evitar colisões de cache entre diferentes funções chamadas com os mesmos argumentos, por exemplo add(2, 3) e multiply(2, 3)?
# # Pode-se considerar que todos os argumentos são hasháveis. # Use apenas a biblioteca padrão do 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")
# Pode-se considerar que todos os argumentos são hasháveis. # Use apenas a biblioteca padrão do 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")
