Python Functools LRU_CACHE

Pythons Functools -modul omhandler høyere funksjoner eller de som fungerer på (og tar som parametere) eller returnerer de andre kallbare objektene som funksjoner. Functools -modulen tilbyr en rekke funksjoner inkludert Wraps (FUNC), LRU_CACHE (FUNC), CMP til Key (FUNC) og Cached Property (FUNC). Det er viktig å merke seg at disse metodene aksepterer parametere som er funksjoner. Memoisering er en ytelsesforbedrende metode som brukes av mange språk, og Python er intet unntak. Memoisering innebærer å hurtig.

LRU_CACHE, et standard bibliotekverktøy levert av Python, kan brukes til å oppnå dette. En dekoratør kalt lru_cache () bruker memoiseringsmetoden for å forkorte hvor lang tid en funksjon utføres for de samme inngangene.

For å undersøke effektiviteten til cachen og optimalisere MaxSize -argumentet, tilbyr den innpakkede metoden Cache_info () -metoden som skaper en merket tupel som omfatter treff, feil, maxSize og cursize. Fordi LRU_CACHE er standard for å cache hver samtale til metoden den innkapsler, kan hurtigbufferen fortsette å utvide seg på ubestemt.

Du trenger sannsynligvis ikke å være bekymret for at hurtigbufferen blir for stor hvis utvalget av argumenter som funksjonen din aksepterer er begrenset (for eksempel de eneste tallene 1 til 100). For å forhindre å bruke alt minnet, kan det være lurt å begrense hurtigbufferen under noen omstendigheter til de maksimale X -mulighetene.
"LRU" i LRU_CACHE stammer herfra. LRU eller minst ofte brukt er et begrep som brukes for å beskrive hvordan objektene i hurtigbufferen blir fjernet øyeblikkelig. Alle data fjernes og lagres for de nyeste X -hurtigbufrede elementene.

Syntaks av LRU_Cache i Python

En slik Functools -modulfunksjon som hjelper til med å redusere funksjonsutførelsestiden ved å bruke memoiseringsteknikk er LRU_CACHE (). Følgende er syntaks for LRU_CACHE levert av Python:

@Lru_Cache (MaxSize = 128, Typed = FALSE)

Dekoratøren @lru_cache tar to parametere:

MAX_SIZE: Caches maksimale lagringskapasitet er indikert med dette alternativet, hvoretter de eldre varene fjernes. Når det er satt til null, vil ingen data noen gang bli fjernet fra hurtigbufferen, noe som får den til å vokse evig. Hvis mye data blir hurtiget, vil dette resultere i problemer.

Typer: Dette argumentet er boolsk. Å ha forskjellige oppføringer i hurtigbufferen for forskjellige slags funksjonsparametere er indikert når verdien er satt til sann.

Eksempel 1: Program for å skrive ut Fibonacci -serien

Som navnet tilsier, opprettholder hurtigbufferen de mest aktuelle inngangene/resultatparet ved å eliminere de minst nylige/eldste postene først. Ved hjelp av LRU -cachen, skriver vi ut Fibonacci -sekvensen. For eksempel er den enkle Fibonacci -serien 1, 1, 2, 3, 5, 8, etc. siden 1+1 = 2, 1+2 = 3, og så videre. La oss sammenligne tidene funksjonen tar mens du bruker LRU_CACHE, og når den ikke brukes ved å bruke tid.

Fra Functools importerer LRU_CACHE
Importer tid
def fib_without_cache (n):
Hvis n < 4:
return n
Returner FIB_WithOUT_CACHE (n-1) + fib_without_cache (n-4)
Begynn = tid.tid()
fib_without_cache (60)
slutt = tid.tid()
Trykk ("Tidsutførelse uten LRU_CACHE IS", End-Begin)
@Lru_Cache (MaxSize = 128)
def fib_with_cache (n):
Hvis n < 4:
return n
Returner FIB_WITH_CACHE (n-1) + fib_with_cache (n-2)
Begynn = tid.tid()
fib_with_cache (60)
slutt = tid.tid()
Print ("Tidsutførelse med LRU_CACHE IS", End-Begin)

Her, fra Python Functools -modulen, importerte vi LRU_CACHE. Tiden importeres også i dette skriptet for tidsutførelsen. Deretter har vi en funksjonsdefinisjon som har gitt navnet "fib_without_cache". Funksjonen ble opprettet for å beregne Fibonacci -serien uten LRU_CACHE. Inne i funksjonen med IF -tilstanden beregnet vi Fibonacci -serien ved å bruke formelen.

Etter det opprettet vi et objekt “Begynn” der tidsfunksjonen påkalles. Tiden på sekunder sendes til "FIB_WithOUT_CACHE" ". Med sluttobjektet avsluttet vi tidsutførelsen. Fibonacci -serien er skrevet ut uten LRU_CACHE av Print -kommandoen. Fibonacci -serien ble implementert uten LRU_CACHE -funksjonen, som vi demonstrerte.

Nå distribuerer vi LRU_CACHE -funksjonen. Vi setter inndata Max_Size -verdien til LRU_CACHE -funksjonen. Ved hjelp av LRU_CACHE -dekoratøren pakket vi deretter inn "FIB_WITH_CACHE". Fibonacci -serien kan bestemmes veldig raskt ved å gjøre dette. Fibonacci -serien blir evaluert ved å bruke formelen. Tidsutførelsen starter med begynnelsesobjektet og slutter med sluttobjektet. Til slutt trykket vi resultatet som er dannet med LRU_CACHE Dekoratør.

Du kan se utgangen fra Fibonacci -serien med og uten LRU -cache -dekoratøren som følger:

Eksempel 2: Program for å telle vokalen fra strengen

Vi teller antall vokaler som den medfølgende strengen har ved å bruke LRU_CACHE -dekoratøren.

Fra Functools importerer LRU_CACHE
@Lru_Cache (MaxSize = 50)
def count_vowels (streng):
streng = streng.Casefold ()
Retursum (streng.Count (vokal) for vokal i 'aeiou')
print (count_vowels ("hallo geeks"))

Først inkluderte vi LRU_CACHE i skriptet vårt og brukte deretter LRU_CACHE Dekoratøren. Inne. Deretter opprettet vi en funksjon med navnet “Count_Vowels” som tar variabelen “String” som en inngang. Vi setter Casefold -metoden i strengvariabelen. Casefold -metoden konverterer her tegnene til små bokstaver gitt i strengen.

Deretter har vi returkommandoen som gir summen av vokalene som finnes i strengen. Til utskriftserklæringen spesifiserte vi "Hello Geeks" -strengen.

Følgende er en heltallverdi oppnådd som er summen av vokalen som finnes i strengen:

Konklusjon

Vi dekket LRU_Cache i Python med syntaks og eksempler. Utgangen og parametrene lagres når en funksjon vedlagt i LRU_CACHE kalles. Funksjonen kalles deretter igjen, og hvis den samme inngangen blir funnet, returneres utgangen fra forrige samtale uten å utføre noen beregninger.