Comment utiliser les expressions régulières Python pour mémoriser du code

En Python, les expressions régulières sont un outil de traitement de texte très puissant. Il peut être utilisé pour faire correspondre et remplacer des formats spécifiques dans le texte, rendant ainsi le traitement du texte plus efficace et plus pratique.

Lors de l'écriture de code à grande échelle, nous rencontrons souvent des situations où la mémorisation est requise. La mémorisation fait référence à la mise en cache des résultats générés lors de l'exécution de la fonction afin que les résultats mis en cache puissent être directement utilisés dans les appels ultérieurs, évitant ainsi les calculs répétés et améliorant l'efficacité de l'exécution du code. En Python, nous pouvons utiliser des décorateurs pour implémenter des fonctions de mémorisation, et les expressions régulières peuvent nous aider à mieux gérer les caches de mémorisation.

Cet article expliquera comment utiliser les expressions régulières Python pour mémoriser le code. Tout d’abord, nous devons comprendre l’usage de base des décorateurs.

1. Bases de Decorator

Decorator est une structure syntaxique qui peut ajouter des fonctionnalités supplémentaires à une fonction sans changer le code de la fonction. Il s'agit généralement d'une fonction qui prend la fonction décorée comme paramètre, et sa valeur de retour est une nouvelle fonction. Cette nouvelle fonction effectuera automatiquement certaines opérations supplémentaires lorsque la fonction décorée est appelée.

Ce qui suit est un exemple simple de décorateur qui peut calculer le temps d'exécution d'une fonction :

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print('Function "{}" takes {}s to execute.'.format(func.__name__, end_time - start_time))
        return result
    return wrapper

@timer
def foo():
    time.sleep(1)
    return 'Done'

foo()

Dans le code ci-dessus, un minuteur de décorateur est défini, qui accepte une fonction comme paramètre et renvoie un nouveau wrapper de fonction. Lorsque la fonction wrapper exécute la fonction décorée, elle calcule d'abord le temps d'exécution de la fonction, puis génère le temps d'exécution et renvoie enfin le résultat de l'exécution de la fonction décorée.

Lorsque vous utilisez un décorateur, il vous suffit d'ajouter la syntaxe du nom @decorator avant la fonction décorée.

2. Implémentation de la mémorisation

Ci-dessous, nous présenterons comment utiliser les décorateurs pour implémenter la fonction de mémorisation. Plus précisément, nous voulons pouvoir mettre en cache les paramètres d'entrée et les résultats de sortie d'une fonction afin que les appels ultérieurs puissent utiliser les résultats mis en cache directement sans recalcul. Afin de réaliser cette fonction, nous pouvons utiliser une structure de données spéciale en Python - le dictionnaire. Nous utilisons les paramètres d'entrée de la fonction comme clés du dictionnaire, les résultats de sortie de la fonction comme valeurs du dictionnaire et les enregistrons dans une variable globale. Chaque fois que la fonction décorée est appelée, vérifiez d'abord si le résultat de sortie correspondant existe déjà dans le dictionnaire. S'il existe, le résultat mis en cache sera renvoyé directement. Sinon, le calcul de la fonction sera effectué et le résultat de sortie sera ajouté au dictionnaire. .

Ce qui suit est un exemple simple de décorateur memoize :

import functools

memory = {}

def memoize(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        key = (args, tuple(kwargs.items()))
        if key not in memory:
            memory[key] = func(*args, **kwargs)
        return memory[key]
    return wrapper

@memoize
def add(x, y):
    print('Adding {} and {}...'.format(x, y))
    return x + y

print(add(2, 3))    # Adding 2 and 3... 5
print(add(2, 3))    # 5

Dans le code ci-dessus, un décorateur memoize est défini. Sa fonction est de sauvegarder la paire clé-valeur du cache dans la mémoire des variables globales afin qu'elle puisse être vérifiée lors des appels ultérieurs. . Des résultats mis en cache existent. Lorsque la fonction décorée est appelée, les paramètres d'entrée sont d'abord convertis en tuples et dictionnaires, puis utilisés comme paires clé-valeur pour déterminer s'il existe un résultat mis en cache. Si elle n'existe pas, la fonction décorée est appelée pour calculer le résultat et le résultat est ajouté au dictionnaire cache. S'il existe, le résultat mis en cache est renvoyé directement. Pour les fonctions décorées, nous utilisons functools.wraps pour implémenter l'héritage de docstring et de nom de fonction.

Le code ci-dessus convient à l'utilisation de types de données ordinaires comme paramètres d'entrée de fonction, mais dans le développement réel, nous pouvons rencontrer des types de données plus complexes, tels que des listes, des tuples, des ensembles, etc. À ce stade, nous devons utiliser des expressions régulières pour convertir le type de données en chaîne afin qu'il puisse être utilisé comme clé pour la mise en cache des paires clé-valeur.

3. Utilisation d'expressions régulières

L'expression régulière est une expression qui peut être utilisée pour faire correspondre et traiter des chaînes. En Python, nous pouvons utiliser des expressions régulières en utilisant le module re. Voici un exemple d'expression régulière simple :

import re

pattern = r'd+'
text = '123abc456def789'
match = re.search(pattern, text)
print(match.group())    # 123

Dans le code ci-dessus, nous définissons un modèle d'expression régulière contenant d+, ce qui signifie faire correspondre un ou plusieurs nombres. Ensuite, nous utilisons la fonction re.search pour faire correspondre le modèle dans le texte de la chaîne et renvoyer un objet Match. L'objet Match contient des informations telles que la chaîne correspondante, les positions de début et de fin, etc. Nous pouvons obtenir la chaîne correspondante via la méthode de groupe.

Lors de la mise en œuvre de la fonction de mémorisation, nous pouvons convertir les paramètres d'entrée en chaînes et utiliser des expressions régulières pour extraire des nombres, des lettres, des symboles et d'autres informations dans les paramètres en tant que clés pour la mise en cache des paires clé-valeur. Voici un exemple de code :

import re
import functools

memory = {}

def memoize(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_str = ', '.join(map(str, args))
        kwargs_str = ', '.join('{}={}'.format(k, v) for k, v in kwargs.items())
        key_str = args_str + ', ' + kwargs_str
        match = re.search(r'd+', key_str)
        key = match.group()
        if key not in memory:
            memory[key] = func(*args, **kwargs)
        return memory[key]
    return wrapper

@memoize
def add(x, y):
    print('Adding {} and {}...'.format(x, y))
    return x + y

print(add(2, 3))    # Adding 2 and 3... 5
print(add(2, 3))    # 5

print(add(2, 4))    # Adding 2 and 4... 6
print(add(2, 4))    # 6

print(add(1, y=2))  # Adding 1 and 2... 3
print(add(1, y=2))  # 3

Dans le code ci-dessus, nous convertissons les paramètres d'entrée en chaînes et utilisons des expressions régulières pour en extraire des nombres en tant que clés de paires clé-valeur. Si la clé correspondante existe déjà dans le dictionnaire cache, le résultat est renvoyé directement ; sinon, le calcul de la fonction est effectué et le résultat est ajouté au dictionnaire cache.

4. Résumé

Cet article explique comment utiliser les expressions régulières Python pour mémoriser du code. En utilisant des décorateurs et des expressions régulières, nous pouvons mieux gérer le cache des résultats d'exécution des fonctions, éviter les calculs répétés et améliorer l'efficacité de l'exécution du code. Dans les applications pratiques, nous devons également prendre en compte des problèmes tels que l’expiration du cache et le contrôle de la capacité afin de mieux utiliser la technologie de mémorisation.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!