Python functools lru_cache
Lru_cache, uma ferramenta de biblioteca padrão fornecida pelo Python, pode ser usada para realizar isso. Um decorador chamado LRU_Cache () usa a abordagem de memórias para reduzir o tempo em que uma função é executada para as mesmas entradas.
Para examinar a eficácia do cache e otimizar o argumento MaxSize, o método embrulhado oferece o método cache_info () que cria uma tupla marcada composta por hits, falhas, maxsize e currsize. Como o lru_cache padroniza para armazenar em cache todas as chamadas para o método que ele encapsula, o cache pode continuar a se expandir indefinidamente enquanto um programa estiver em execução.
Você provavelmente não precisa se preocupar com o cache ficar muito grande se o intervalo de argumentos que sua função aceitar for limitado (por exemplo, os únicos números 1 a 100). Para evitar o uso de toda a memória, você pode querer limitar o cache em algumas circunstâncias às possibilidades máximas x.
O "LRU" em lru_cache se origina daqui. LRU ou menos frequentemente usado é um termo usado para descrever como os objetos no cache são removidos instantaneamente. Todos os dados são removidos e salvos para os itens X em cache mais recentes.
Sintaxe do Lru_cache em Python
Uma dessas funções do módulo Functools que ajuda a diminuir o tempo de execução da função aplicando a técnica de memórias é o LRU_CACHE (). A seguir, é apresentada a sintaxe do LRU_CACHE fornecido pelo Python:
@lru_cache (maxsize = 128, tiped = false)
O decorador @lru_cache leva dois parâmetros:
Max_size: a capacidade máxima de armazenamento do cache é indicada por esta opção após a qual os itens mais antigos são removidos. Quando está definido como zero, nenhum dado será removido do cache, o que faz com que ele cresça eternamente. Se muitos dados forem armazenados em cache, isso resultará em problemas.
Tipos: este argumento é booleano. Ter entradas diferentes no cache para vários tipos de parâmetros de função é indicado quando o valor é definido como true.
Exemplo 1: Programa para imprimir a série Fibonacci
Como o nome indica, o cache mantém o par de entradas/resultados mais atuais, eliminando os registros menos recentes/mais antigos primeiro. Com a ajuda do cache da LRU, imprimiremos a sequência de Fibonacci. Por exemplo, a série simples de Fibonacci é 1, 1, 2, 3, 5, 8, etc. Desde 1+1 = 2, 1+2 = 3 e assim por diante. Vamos comparar os tempos que a função leva ao usar o lru_cache e quando não é usado usando o tempo.
De functools importar lru_cachetempo de importação
def fib_without_cache (n):
se n < 4:
retornar n
Retornar FIB_WITHOUT_CACHE (N-1) + FIB_WITHOUT_CACHE (N-4)
BEGIN = Time.tempo()
fib_without_cache (60)
fim = tempo.tempo()
Print ("Execução de tempo sem lru_cache é", porte final)
@lru_cache (maxsize = 128)
def fib_with_cache (n):
se n < 4:
retornar n
Retornar FIB_WITH_CACHE (N-1) + FIB_WITH_CACHE (N-2)
BEGIN = Time.tempo()
fib_with_cache (60)
fim = tempo.tempo()
Print ("Execução de tempo com LRU_Cache IS", End-Begin)
Aqui, do módulo Python Functools, importamos o LRU_CACHE. O tempo também é importado neste script para a execução do tempo. Em seguida, temos uma definição de função que deu o nome "fib_without_cache". A função foi criada para calcular a série Fibonacci sem o Lru_cache. Dentro da função com a condição IF, calculamos a série Fibonacci aplicando sua fórmula.
Depois disso, criamos um objeto "BEGIN" onde a função de tempo é invocada. O tempo em segundos é passado para a função "fib_without_cache". Com o objeto final, terminamos a execução do tempo. A série Fibonacci é impressa sem o Lru_cache pelo comando de impressão. A série Fibonacci foi implementada sem a função LRU_CACHE, como demonstramos.
Agora, implantamos a função lru_cache. Definimos o valor de entrada max_size para a função lru_cache. Usando o decorador LRU_Cache, então embrulhamos a função "FIB_WITH_CACHE". A série Fibonacci pode ser determinada muito rapidamente, fazendo isso. A série Fibonacci é avaliada aplicando sua fórmula. A execução do tempo começa com o objeto inicial e termina com o objeto final. Por fim, imprimimos o resultado formado com o Decorador Lru_cache.
Você pode ver a saída da série Fibonacci com e sem o decorador de cache da LRU da seguinte maneira:
Exemplo 2: Programa para contar a vogal da string
Contamos o número de vogais que a string fornecida tem utilizando o decorador Lru_cache.
De functools importar lru_cache@lru_cache (maxsize = 50)
def count_vwels (string):
string = string.Casefold ()
soma de retorno (string.contagem (vogal) para vogal em 'aeiou')
Print (Count_vwels ("Hello Geeks")))
Primeiro, incluímos o lru_cache em nosso script e depois usamos o decorador LRU_Cache. Dentro do decorador LRU_CACHE, passamos o maxsize como um argumento e estabelecemos seu valor para 50. Em seguida, criamos uma função com o nome "count_vwels" que leva a variável "string" como uma entrada. Definimos o método de caixa na variável da string. O método de casefold aqui converte os caracteres para a minúsculas dadas na string.
Então, temos o comando de retorno que dá a soma das vogais encontradas na string. Para a declaração de impressão, especificamos a string "Hello Geeks".
A seguir, é obtido um valor inteiro que é a soma da vogal encontrada na string:
Conclusão
Cobrimos o lru_cache em python com sua sintaxe e exemplos. A saída e os parâmetros são salvos quando uma função incluída no lru_cache é chamada. A função é então chamada novamente e, se a mesma entrada for encontrada, a saída da chamada anterior será retornada sem executar nenhum cálculo.