Python functools lru_cache
LRU_CACH, un outil de bibliothèque standard fourni par Python, peut être utilisé pour y parvenir. Un décorateur appelé lru_cache () utilise l'approche de la mémorisation pour raccourcir la durée où une fonction est exécutée pour les mêmes entrées.
Pour examiner l'efficacité du cache et optimiser l'argument MaxSize, la méthode enveloppée propose la méthode cache_info () qui crée un tuple étiqueté comprenant. Étant donné que LRU_CACHE est par défaut en cache chaque appel à la méthode qu'il résume, le cache peut continuer à se développer indéfiniment pendant que un programme est en cours d'exécution.
Vous n'avez probablement pas besoin de vous soucier du cache de devenir trop important si la gamme d'arguments que votre fonction accepte est limitée (par exemple, les seuls nombres 1 à 100). Pour éviter d'utiliser toute la mémoire, vous voudrez peut-être limiter le cache dans certaines circonstances aux possibilités de X maximum.
Le «LRU» dans LRU_CACHE est originaire d'ici. LRU ou le moins fréquemment utilisé est un terme utilisé pour décrire comment les objets du cache sont instantanément supprimés. Toutes les données sont supprimées et enregistrées pour les éléments caches les plus récents.
Syntaxe du LRU_CACH à Python
Une telle fonction de module Functools qui aide à diminuer le temps d'exécution de la fonction en appliquant la technique de la mémorisation est le LRU_CACHE (). Ce qui suit est la syntaxe du lru_cache fournie par Python:
@lru_cache (maxSize = 128, typed = false)
Le décorateur @lru_cache prend deux paramètres:
Max_size: la capacité de stockage maximale du cache est indiquée par cette option après laquelle les éléments plus anciens sont supprimés. Lorsqu'il est défini sur zéro, aucune donnée ne sera jamais supprimée du cache, ce qui la fait grandir éternellement. Si beaucoup de données sont mises en cache, cela entraînera des problèmes.
Types: cet argument est booléen. Avoir des entrées différentes dans le cache pour divers types de paramètres de fonction est indiqué lorsque la valeur est définie sur true.
Exemple 1: Programme pour imprimer la série Fibonacci
Comme son nom l'indique, le cache maintient la paire d'entrées / résultats les plus actuelles en éliminant d'abord les enregistrements les moins récents / les plus anciens. À l'aide du cache LRU, nous allons imprimer la séquence Fibonacci. Par exemple, la série simple Fibonacci est 1, 1, 2, 3, 5, 8, etc. Depuis 1 + 1 = 2, 1 + 2 = 3, et ainsi de suite. Comparons les fois où la fonction prend en utilisant le LRU_CACH et quand il n'est pas utilisé en utilisant le temps.
à partir de functools import lru_cacheheure d'importation
def fib_without_cache (n):
Si n < 4:
retour n
return fib_without_cache (n-1) + fib_without_cache (n-4)
commencer = le temps.temps()
fib_without_cache (60)
fin = temps.temps()
print ("Exécution de temps sans lru_cache est", fin-begin)
@lru_cache (maxsize = 128)
def fib_with_cache (n):
Si n < 4:
retour n
return fib_with_cache (n-1) + fib_with_cache (n-2)
commencer = le temps.temps()
fib_with_cache (60)
fin = temps.temps()
print ("L'exécution du temps avec LRU_CACHE IS", End-Begin)
Ici, à partir du module Python Functools, nous avons importé le LRU_CACH. Le temps est également importé dans ce script pour l'exécution du temps. Ensuite, nous avons une définition de fonction qui a donné le nom "fib_without_cache". La fonction a été créée pour calculer la série Fibonacci sans le LRU_CACH. À l'intérieur de la fonction avec la condition IF, nous avons calculé la série Fibonacci en appliquant sa formule.
Après cela, nous avons créé un objet «commencer» où la fonction temporelle est invoquée. Le temps en secondes est transmis à la fonction "fib_without_cache". Avec l'objet final, nous avons terminé l'exécution du temps. La série Fibonacci est imprimée sans le LRU_CACH par la commande d'impression. La série Fibonacci a été mise en œuvre sans la fonction lru_cache, comme nous l'avons démontré.
Maintenant, nous déployons la fonction LRU_CACH. Nous définissons la valeur d'entrée max_size sur la fonction lru_cache. À l'aide du décorateur LRU_CACH, nous avons ensuite enveloppé la fonction "fib_with_cache". La série Fibonacci peut être déterminée très rapidement en faisant cela. La série Fibonacci est évaluée en appliquant sa formule. L'exécution de temps commence par l'objet débutant et se termine par l'objet final. Enfin, nous avons imprimé le résultat formé avec le décorateur LRU_CACH.
Vous pouvez voir la sortie de la série Fibonacci avec et sans le décorateur de cache LRU comme suit:
Exemple 2: Programme pour compter la voyelle de la chaîne
Nous comptons le nombre de voyelles que la chaîne fournie a en utilisant le décorateur LRU_CACH.
à partir de functools import lru_cache@lru_cache (maxSize = 50)
def count_vowels (chaîne):
chaîne = chaîne.Casefold ()
Retour Sum (String.Compter (voyelle) pour la voyelle dans «aeiou»)
print (count_vowels ("Hello geeks"))
Tout d'abord, nous avons inclus le LRU_CACH dans notre script, puis utilisé le décorateur LRU_CACH. À l'intérieur du décorateur LRU_CACH, nous avons passé le maxsize comme argument et avons fixé sa valeur sur 50. Ensuite, nous avons créé une fonction avec le nom «count_vowels» qui prend la variable «String» comme entrée. Nous définissons la méthode Casefold dans la variable de chaîne. La méthode Casefold convertit ici les caractères en minuscules donnés dans la chaîne.
Ensuite, nous avons la commande de retour qui donne la somme des voyelles trouvées dans la chaîne. À la déclaration d'impression, nous avons spécifié la chaîne «Hello Geeks».
Ce qui suit est une valeur entière obtenue qui est la somme de la voyelle trouvée dans la chaîne:
Conclusion
Nous avons couvert le LRU_CACH en Python avec sa syntaxe et ses exemples. La sortie et les paramètres sont enregistrés lorsqu'une fonction enfermée dans le LRU_CACH est appelée. La fonction est ensuite appelée, et si la même entrée est trouvée, la sortie de l'appel précédent est renvoyée sans effectuer de calculs.