# Escribir código para la función cache. Es un decorador que debe # recordar lo que devolvió la función decorada y devolver el valor almacenado # en llamadas posteriores con los mismos argumentos. # Se puede suponer que todos los argumentos son hashables. # Utilizar solo la biblioteca estándar de Python.
¿Por qué ordenar kwargs al construir la clave de la caché de memoización?
¿Es necesario usar OrderedDict en lugar de un diccionario normal para una caché de memoización sin límite de tamaño y política de reemplazo?
¿Qué limitaciones y problemas tiene la caché en memoria, especialmente al escalar microservicios a varios trabajadores?
# Escribir código para la función cache. Es un decorador que debe # recordar lo que devolvió la función decorada, y devolver el valor almacenado # en llamadas posteriores con los mismos argumentos. # # Se puede asumir que todos los argumentos son hashables. # Usar solo la biblioteca estándar de 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")
# Escribir código para la función cache. Es un decorador que debe # recordar lo que devolvió la función decorada y devolver el valor almacenado # en llamadas posteriores con los mismos argumentos. # Se puede asumir que todos los argumentos son hashables. # Utilizar solo la biblioteca estándar de 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")
# Escribir código para la función cache. Es un decorador que debe # recordar lo que devolvió la función decorada y devolver el valor almacenado # en llamadas posteriores con los mismos argumentos. # # Se puede asumir que todos los argumentos son hashables. # Utilizar solo la biblioteca estándar de Python.
¿Cómo evitar colisiones en la caché entre diferentes funciones que se llaman con los mismos argumentos, por ejemplo add(2, 3) y multiply(2, 3)?
# Se puede considerar que todos los argumentos son hashables. # Utiliza solo la biblioteca estándar de 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")
# # Se puede considerar que todos los argumentos son hashables. # Utiliza solo la biblioteca estándar de 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")
