Comment remplir une chaîne regex avec des paramètres

Question

Je voudrais remplir les variables regex avec des chaînes de caractères.

import re

hReg = re.compile("/robert/(?P<action>([a-zA-Z0-9]*))/$")
hMatch = hReg.match("/robert/delete/")
args = hMatch.groupdict()

La variable args est maintenant un dict avec {"action" : "delete"}.

Comment puis-je inverser ce processus ? Avec args dict et motif regex, comment puis-je obtenir la chaîne "/robert/delete/" ?

est-il possible d'avoir une fonction comme celle-ci ?

def reverse(pattern, dictArgs):

Merci.

Answer 1

Cette fonction devrait le faire

def reverse(regex, dict):
    replacer_regex = re.compile('''
        \(\?P\<         # Match the opening
            (.+?)       # Match the group name into group 1
        \>\(.*?\)\)     # Match the rest
        '''
        , re.VERBOSE)

    return replacer_regex.sub(lambda m : dict[m.group(1)], regex)

En gros, vous faites correspondre le bloc (\?P...) et le remplacez par une valeur du dict.

EDIT : regex est la chaîne regex dans mon exemple. Vous pouvez l'obtenir à partir de patter par

regex_compiled.pattern

EDIT2 : ajout d'un regex verbeux

Answer 2

En fait, je pense que c'est faisable pour certains cas étroits, mais assez complexe "dans le cas général".

Vous devrez écrire une sorte de machine à états finis, analysant votre chaîne regex, et séparant différentes parties, puis prenant les mesures appropriées pour ces parties.

Pour les symboles réguliers - il suffit de mettre les symboles "tels quels" dans la chaîne de résultats. Pour les groupes nommés - mettez les valeurs de dictArgs à leur place. Pour les blocs optionnels, mettez certaines de leurs valeurs.

Et ainsi de suite.

Une expression requalifiée peut souvent correspondre à un grand (ou même infini) ensemble de chaînes de caractères, donc cette fonction "inverse" ne serait pas très utile.

Answer 3

Dans le prolongement de la réponse de @Dimitri, il est possible de procéder à une plus grande désinfection.

retype = type(re.compile('hello, world'))
def reverse(ptn, dict):
    if isinstance(ptn, retype):
        ptn = ptn.pattern
    ptn = ptn.replace(r'\.','.')
    replacer_regex = re.compile(r'''
        \(\?P         # Match the opening
        \<(.+?)\>
        (.*?)
        \)     # Match the rest
        '''
        , re.VERBOSE)
#     return replacer_regex.findall(ptn)
    res = replacer_regex.sub( lambda m : dict[m.group(1)], ptn)
    return res