# Kirjutage kood funktsioonile cache. See on dekoratsioon, mis # peaks mäletama, mida dekoreeritud funktsioon on tagastanud, ja # tagastama salvestatud väärtuse korduvatel kutsumistel sama argumentidega. # Võib eeldada, et kõik argumendid on hash'able. # Kasutage ainult Pythoni standardraamatukogu.
Miks sorteerida kwargs, luues memoization-vahemälu võtme?
Kas vajadētu kasutada OrderedDict asemel tavalise dict memoization-küti jaoks ilma suuruse piirangu ja väljaheitmise poliitikata?
Millised on in-memory vahemälu piirangud ja probleemid, eriti mikroteenuste skaleerimisel mitme tööjõu jaoks?
# Kirjutage kood funktsioonile cache. See peaks olema dekoratiivfunktsioon, # mis peaks mäletama, mida dekoreeritud funktsioon on tagastanud, ja # tagastama salvestatud väärtuse korduvatel kutsumistel sama argumentidega. # # Eeldatakse, et kõik argumendid on hash'able. # Kasutage ainult Pythoni standardraamatukogu. 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")
# Kirjutage kood funktsioonile cache. See peaks olema dekoratsioon, mis # mäletab, mida tagastas dekoratiivne funktsioon, ja tagastab salvestatud # väärtuse korduvatel kutsumistel sama argumentidega. # Eeldada võib, et kõik argumendid on hash'able. # Kasutage ainult Pythoni standardraamatukogu. 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")
# Kirjutage kood funktsioonile cache. See on dekoratsioon, mis # peaks mäletama, mida dekoreeritud funktsioon on tagastanud, ja # tagastama salvestatud väärtuse korduvatel väljakutsetel sama argumentidega. # # Võib eeldada, et kõik argumendid on hashable. # Kasutage ainult Pythoni standardraamatukogu.
Kuidas vältida vahemälu kokkupõrkeid erinevate funktsioonide vahel, mis kutsutakse sama argumentidega, näiteks add(2, 3) ja multiply(2, 3)?
# Võib eeldada, et kõik argumendid on hash'able. # Kasutage ainult Pythoni standardteeki. _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")
# # Võib eeldada, et kõik argumendid on hash'able. # Kasutage ainult Python'i standardteeki. _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")
