Quel genre de regex pourrais-je utiliser pour faire correspondre cela?

Question

J'ai plusieurs cordes qui ressemblent à ce qui suit:

<some_text> TAG[<some_text>@11.22.33.44] <some_text> 

Je veux obtenir le ip_address et seul le ip_address de cette ligne. (Dans l'intérêt de cet exemple, supposons que l'adresse IP sera toujours dans ce format xx.xx.xx.xx)

Edit: J'ai peur de ne pas avoir été clair.

Les cordes ressemblera à quelque chose comme ceci:

<some_text> TAG1[<some_text>@xx.xx.xx.xx] <some_text> TAG2[<some_text>@yy.yy.yy.yy] <some_text> 

Notez que 'some_text' peut être une longueur variable. J'ai besoin d'associer différentes regex à différentes balises afin que lorsque r.group() est appelé, l'adresse IP sera retournée. Dans le cas ci-dessus, l'expression rationnelle ne serait pas différente mais c'est un mauvais exemple.

Les regex que j'ai essayés jusqu'à présent ont été inadéquats.

Idéalement, je voudrais quelque chose comme ceci:

r = re.search('(?<=TAG.*@)(\d\d.\d\d.\d\d.\d\d)', line) 

où la ligne est dans le format spécifié ci-dessus. Toutefois, cela ne fonctionne pas car vous devez disposer d'une assertion look-behind de largeur fixe.

De plus, j'ai essayé des groupes non-capture en tant que tels:

r = re.search('(?<=TAG\[)(?:.*@)(\d\d.\d\d.\d\d.\d\d)', line) 

Cependant, je ne peux pas utiliser cela parce que r.group() retournera some_text@xx.xx.xx.xx

Je comprends que r.group (1) retournera juste l'adresse IP. Malheureusement, le script que j'écris nécessite que toute mon regex renvoie le résultat correct après avoir appelé r.group().

Quel type de regex pourrais-je utiliser pour cette situation?

Le code est en python.

Note: Tous les some_text peuvent être de longueur variable

Answer 1

Je ne pense pas que ce soit possible - r.group() renverra toujours toute la chaîne qui correspond, donc vous êtes obligé d'utiliser lookbehind, qui, comme vous le dites, doit avoir une largeur fixe. Au lieu de cela, je suggérerais de modifier le script que vous écrivez à la place. Je devine que vous avez une charge entière d'expressions rationnelles qui correspond, et vous ne voulez pas avoir à spécifier pour chacune d'entre elles "celle-ci utilise r.group (0)", "celle-ci utilise r.group (3) », etc.

dans ce cas, vous pouvez utiliser l'installation de groupes nommés Python: vous pouvez nommer un groupe dans une expression régulière comme ceci:

(?P<name>CONTENTS) 

alors récupérer ce qui correspond à r.group("name").

Ce que je suggère de faire dans votre script est: correspondre à l'expression régulière, puis tester si r.group("usethis") est défini.Si oui, utilisez cela; Si ce n'est pas le cas, utilisez r.group() comme précédemment.

De cette façon, vous pouvez faire face à des situations embarrassantes comme celle-ci en spécifiant le nom de groupe usethis dans l'expression rationnelle - mais vos autres expressions rationnelles n'ont pas besoin de le savoir ou de s'en soucier.

Answer 2

Pourquoi voulez-vous utiliser des groupes ou regarder behinds du tout? Quel est le problème avec re.search('TAG\[.*@(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\]')?

Answer 3

Essayez re.search('(?<=@)\d\d\.\d\d\.\d\d\.\d\d(?=\])', line).

En fait, re.search('\d\d\.\d\d\.\d\d\.\d\d', line) peut vous fournir ce dont vous avez besoin si la seule occurrence du format xx.xx.xx.xx dans les chaînes en cours de vérification se trouve dans ces sections d'adresse IP.

EDIT: Comme indiqué dans mon commentaire, pour trouver toutes les occurrences du motif voulu dans une chaîne, il suffit de faire re.findall(pattern_to_match, line). Donc dans ce cas, re.findall('\d\d\.\d\d\.\d\d\.\d\d', line) (ou plus généralement, re.findall('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', line)).

EDIT 2: De votre commentaire, cela devrait fonctionner (avec tagname étant le tag de l'adresse IP que vous voulez actuellement).

r = re.search(tagname + '\[.+?@(?P<ip>\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})', line) 

Et alors vous simplement faites référence avec r.group("ip") comme psmears dit.

... En fait, il y a un moyen facile de rendre l'expression rationnelle un peu plus concise.

r = re.search(tagname + r'\[.+?@(?P<ip>(?:\d{1,3}\.?){4})', line) 

En fait, vous pouvez même le faire:

r = re.findall('(?P<tag>\S+)\[.+?@(?P<ip>(?:\d{1,3}\.?){4})', line) 

qui vous renvoie une liste contenant les balises et leurs adresses IP associées, et donc vous ne revérifier une chaîne une fois que vous avez trouvé les correspondances si vous vouliez vous référer à l'adresse IP d'un tag différent de la même chaîne.

... En fait, aller deux pas plus loin (plus loin?), Vous pouvez effectuer les opérations suivantes:

r = dict((m.group("tag"), m.group("ip")) for m in re.finditer('(?P<tag>\S+)\[.+?@(?P<ip>(?:\d{1,3}\.?){4})', line)) 

Ou en Python 3:

r = {(m.group("tag"), m.group("ip")) for m in re.finditer('(?P<tag>\S+)\[.+?@(?P<ip>(?:\d{1,3}\.?){4})', line)} 

Et puis r serait dict avec les étiquettes comme clés et les adresses IP comme valeurs respectives.

Answer 4

Presque mais je pense que vous devez changer le. * Au début. *? puisque vous pouvez avoir plusieurs balises sur une seule ligne (je crois - comme il est dans l'exemple)

re.search('TAG(\d+)\[.*?@(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})]') 

L'ID Tag sera dans la première backreference et l'adresse IP sera dans la deuxième référence arrière