Comment utiliser une variable à l'intérieur d'une expression régulière?

Je voudrais utiliser un variableintérieur regex, comment puis-je le faire Python?

TEXTO = sys.argv[1]

if re.search(r"\b(?=\w)TEXTO\b(?!\w)", subject, re.IGNORECASE):
    # Successful match
else:
    # Match attempt failed

A partir de python 3.6, vous pouvez également utiliser l' interpolation de chaînes littérales , "f-strings". Dans votre cas particulier, la solution serait:

if re.search(rf"\b(?=\w){TEXTO}\b(?!\w)", subject, re.IGNORECASE):
    ...do something

ÉDITER:

Puisqu'il y a eu quelques questions dans le commentaire sur la façon de traiter les caractères spéciaux, j'aimerais étendre ma réponse:

chaînes brutes («r»):

L'un des principaux concepts que vous devez comprendre lorsque vous traitez avec des caractères spéciaux dans les expressions régulières est de faire la distinction entre les littéraux de chaîne et l'expression régulière elle-même. C'est très bien expliqué ici :

En bref:

Disons qu'au lieu de trouver une limite de mot \baprès avoir TEXTOvoulu faire correspondre la chaîne \boundary. Le vous devez écrire:

TEXTO = "Var"
subject = r"Var\boundary"

if re.search(rf"\b(?=\w){TEXTO}\\boundary(?!\w)", subject, re.IGNORECASE):
    print("match")

Cela ne fonctionne que parce que nous utilisons une chaîne brute (l'expression régulière est précédée de 'r'), sinon nous devons écrire "\\\\ limite" dans l'expression régulière (quatre barres obliques inverses). De plus, sans '\ r', \ b 'ne serait plus converti en frontière de mot mais en retour arrière!

re.escape :

Met essentiellement un retour arrière devant tout caractère spécial. Par conséquent, si vous attendez un caractère spécial dans TEXTO, vous devez écrire:

if re.search(rf"\b(?=\w){re.escape(TEXTO)}\b(?!\w)", subject, re.IGNORECASE):
    print("match")

REMARQUE: Pour toute version> = python 3.7: !, ", %, ', ,, /, :, ;, <, =, >, @et `ne sont pas échappés. Seuls les caractères spéciaux ayant une signification dans une expression régulière sont toujours échappés. _n'est pas échappé depuis Python 3.3. (s. ici )

Accolades:

Si vous souhaitez utiliser des quantificateurs dans l'expression régulière à l'aide de chaînes f, vous devez utiliser des accolades doubles. Supposons que vous souhaitiez faire correspondre TEXTO suivi d'exactement 2 chiffres:

if re.search(rf"\b(?=\w){re.escape(TEXTO)}\d{{2}}\b(?!\w)", subject, re.IGNORECASE):
    print("match")

Vous devez construire l'expression régulière sous forme de chaîne:

TEXTO = sys.argv[1]
my_regex = r"\b(?=\w)" + re.escape(TEXTO) + r"\b(?!\w)"

if re.search(my_regex, subject, re.IGNORECASE):
    etc.

Notez l'utilisation de re.escapeafin que si votre texte comporte des caractères spéciaux, ils ne seront pas interprétés comme tels.

if re.search(r"\b(?<=\w)%s\b(?!\w)" % TEXTO, subject, re.IGNORECASE):

Cela insérera ce qui est dans TEXTO dans l'expression régulière sous forme de chaîne.

rx = r'\b(?<=\w){0}\b(?!\w)'.format(TEXTO)

Je trouve très pratique de créer un modèle d'expression régulière en enchaînant plusieurs modèles plus petits.

import re

string = "begin:id1:tag:middl:id2:tag:id3:end"
re_str1 = r'(?<=(\S{5})):'
re_str2 = r'(id\d+):(?=tag:)'
re_pattern = re.compile(re_str1 + re_str2)
match = re_pattern.findall(string)
print(match)

Production:

[('begin', 'id1'), ('middl', 'id2')]

Je suis d'accord avec tout ce qui précède à moins que:

sys.argv[1] était quelque chose comme Chicken\d{2}-\d{2}An\s*important\s*anchor

sys.argv[1] = "Chicken\d{2}-\d{2}An\s*important\s*anchor"

vous ne voudriez pas utiliser re.escape, car dans ce cas, vous aimeriez qu'il se comporte comme une expression régulière

TEXTO = sys.argv[1]

if re.search(r"\b(?<=\w)" + TEXTO + "\b(?!\w)", subject, re.IGNORECASE):
    # Successful match
else:
    # Match attempt failed

J'avais besoin de rechercher des noms d'utilisateur similaires les uns aux autres, et ce que Ned Batchelder a dit était incroyablement utile. Cependant, j'ai trouvé que j'avais une sortie plus propre lorsque j'ai utilisé re.compile pour créer mon terme de recherche:

pattern = re.compile(r"("+username+".*):(.*?):(.*?):(.*?):(.*)"
matches = re.findall(pattern, lines)

La sortie peut être imprimée à l'aide des éléments suivants:

print(matches[1]) # prints one whole matching line (in this case, the first line)
print(matches[1][3]) # prints the fourth character group (established with the parentheses in the regex statement) of the first line.

vous pouvez essayer une autre utilisation en utilisant formatgrammer suger:

re_genre = r'{}'.format(your_variable)
regex_pattern = re.compile(re_genre)  

Vous pouvez également utiliser le mot-clé format pour cela. La méthode format remplacera l'espace réservé {} à la variable que vous avez passée à la méthode format comme argument.

if re.search(r"\b(?=\w)**{}**\b(?!\w)".**format(TEXTO)**, subject, re.IGNORECASE):
    # Successful match**strong text**
else:
    # Match attempt failed

plus d'exemple

J'ai configus.yml avec des fichiers de flux

"pattern":
  - _(\d{14})_
"datetime_string":
  - "%m%d%Y%H%M%f"

dans le code python que j'utilise

data_time_real_file=re.findall(r""+flows[flow]["pattern"][0]+"", latest_file)