Je travaille actuellement sur du code python, et il utilise le package "re" python pour rechercher un élément avec un modèle d'expression régulière dans une liste d'éléments donnée.

Pendant que je regardais le code, j'ai rencontré quelque chose que je ne peux pas comprendre sur les accolades de l'expression régulière.

Le fragment de code est comme ça.

regex = re.search("mov .* ptr \[(?P<dst>([(rax)|(rbx)|(rcx)|(rdx)|(rsi)|(rdi)|(r9)|(r10)|(r11)|(r12)|(r13)|(r14)|(r15)]{3}))\], (?P<src>([(rax)|(rbx)|(rcx)|(rdx)|(rsi)|(rdi)|(r9)|(r10)|(r11)|(r12)|(r13)|(r14)|(r15)]{3}))$", f)

F est une entrée donnée et ressemble à ceci.

Regex devient 1, j'ai imprimé le contenu de f, et ça se voit comme ça.

"mov qword ptr [rsi], rdi"

Ce que je ne peux pas comprendre, c'est les accolades dans l'expression régulière, qui dans ce cas "{3}". Pour autant que je comprends, les accolades avec un seul chiffre «n» sont utilisées pour indiquer que l'expression précédente doit apparaître exactement «n» fois pour correspondre (trois fois dans mon cas). (par exemple, ab {3} entraînerait l'abbb pour correspondre)

Donc, si c'est correct, je pense que l'un des "(rax), (rbx), (rcx), etc." doit apparaître exactement trois fois pour correspondre, mais en ce qui concerne le contenu de f montré ci-dessus, c'est-à-dire pas le cas.

Je me demandais donc quel point je manquais et comment je pouvais comprendre les accolades dans l'expression régulière ci-dessus.

0
Jamie 8 août 2016 à 11:02

3 réponses

Meilleure réponse

L'expression rationnelle fournie utilise les crochets de manière incorrecte. Les crochets indiquent un ensemble de caractères, et donc un {3} après ces caractères indique que toute combinaison de trois de ces caractères correspondra. Vous pouvez voir la documentation ici, sous {{X1 }}.

Je pense que l'expression correcte serait quelque chose comme:

regex = re.search(
    'mov .* ptr '
    '\[(?P<dst>(rax|rbx|rcx|rdx|rsi|rdi|r9|r10|r11|r12|r13|r14|r15))\], '
    '(?P<src>(rax|rbx|rcx|rdx|rsi|rdi|r9|r10|r11|r12|r13|r14|r15))$', f)
2
Karin 8 août 2016 à 08:18

Ce que vous avez là est une expression régulière fausse. Il ne fait pas exactement ce que celui qui l'a écrit voulait le faire.

Pour le démontrer, je lui ai fourni une entrée non valide:

$ python2
...
>>> s = ("mov .* ptr \[(?P<dst>([(rax)|(rbx)|(rcx)|(rdx)|"
... "(rsi)|(rdi)|(r9)|(r10)|(r11)|(r12)|(r13)|(r14)|"
... "(r15)]{3}))\], (?P<src>([(rax)|(rbx)|(rcx)|(rdx)|"
... "(rsi)|(rdi)|(r9)|(r10)|(r11)|(r12)|(r13)|(r14)|(r15)]{3}))$")
>>> import re
>>> r2 = re.search(s, "mov qword ptr [r5i], rdi")
>>> r2
<_sre.SRE_Match object at 0x800684ca8>
>>> r2.group('dst')
'r5i'
>>> r2 = re.search(s, "mov qword ptr [(5i], rdi")
>>> r2.group('dst')
'(5i'
>>>

Il est difficile de dire ce qui a traversé l'esprit de celui qui a écrit l'expression, et comment ils ont trouvé ce qu'ils ont finalement utilisé. Vous avez cependant raison de dire que {3} signifie "répéter exactement trois fois".

0
torek 8 août 2016 à 08:19

Les autres y ont répondu correctement, je vous montre juste un moyen de visualiser / tester vos modèles d'expression régulière.

Regular expression visualization

Démo Debuggex

0
Gábor Fekete 8 août 2016 à 08:27