Recherche d'une regex toute simple (mais pas pour moi)

Version imprimable

13/04/2009, 17h11
rambc

Recherche d'une regex toute simple (mais pas pour moi)
Bonjour,
quelqu'un pourrait-il me donner un moyen via un regex de tester qu'une chaîne est de l'une des cinq formes suivantes ?
Code:

1 2 3 4 5 {--- (...){--- [...]{--- (...)[...]{--- [...](...){---
Les trois tirets indiquent que ce qui suit l'accolade peut-être n'importe quoi.

Les trois points de supsension ne peuvent contenir que des nombres, que des lettres non accentuées (majuscules et minuscules), ainsi que les signes '=' , '_' , ';' et '|' (sans les guillemets simples).

Bonjour,

C'est codé de façon très rustique, mais ça a l'air de fonctionner:
Code:

1 2 3 4 5 6 7 8 9 10 motif = r"^({)|($[0-9a-zA-Z=_;|]+${)|($[0-9a-zA-Z=_;|]+$\[[0-9a-zA-Z=_;|]+\]{)|(\[[0-9a-zA-Z=_;|]+\]{)|(\[[0-9a-zA-Z=_;|]+\]$[0-9a-zA-Z=_;|]+${)" L = ("{nyosnvygteonvyudsom", "(12azER){nyosnvygteonvyudsom", "(12azER=_;|)[12azER=_;|]{nyosnvygteonvyudsom", "[12azER=_;|]{nyosnvygteonvyudsom") for x in L: print re.match(motif,x)!=None
Ce qui renvoie "True" 4 fois.

Pour comprendre comment c'est codé, il suffit de décomposer (c'est comme ça que je les construis):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 motif = r" ^ ({) | ($[0-9a-zA-Z=_;|]+${) | ($[0-9a-zA-Z=_;|]+$\[[0-9a-zA-Z=_;|]+\]{) | (\[[0-9a-zA-Z=_;|]+\]{) | (\[[0-9a-zA-Z=_;|]+\]$[0-9a-zA-Z=_;|]+${) "
Il y a moyen de faire plus concis, parce qu'il y a des motifs qui se répètent, mais je n'ai plus le temps ce soir.

Attends tout de même d'autres propositions.

Tyrtamos

Citation:

Envoyé par tyrtamos

Il y a moyen de faire plus concis, parce qu'il y a des motifs qui se répètent, mais je n'ai plus le temps ce soir.

Attends tout de même d'autres propositions.

Ok.

Merci pour ta proposition qui semble bien fonctionner. :king:

PS : Pour le motif, j'ai fait comme ici :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
motif =  = re.compile(r'''
    ^                                               # debut de la chaine
    ({)                                             # cas du type {---
    |                                               # ou
    (\([0-9a-zA-Z=_;|]+\){)                         # cas du type (...){---
    |                                               # ou
    (\([0-9a-zA-Z=_;|]+\)\[[0-9a-zA-Z=_;|]+\]{)     # cas du type (...)[...]{---
    |                                               # ou
    (\[[0-9a-zA-Z=_;|]+\]{)                         # cas du type [...]{---
    |                                               # ou
    (\[[0-9a-zA-Z=_;|]+\]\([0-9a-zA-Z=_;|]+\){)     # cas du type (...)[...]{---
    $                                               # fin de la chaine
    ''' ,re.VERBOSE)

15/04/2009, 12h54
tyrtamos

A mon avis, le dernier '$' est inutile. De plus, il est affecté au dernier sous-motif, et impose que son '{' soit le dernier caractère de la ligne. De ce fait, le dernier sous-motif ne détecte plus '[xx](xx){xxx'. Si tu veux absolument mettre un '$', il faut entourer les 5 sous-motifs par un couple de parenthèses, et mettre '.+' devant '$' et après la parenthèse fermante ('.'=n'importe quel caractère et '+'=un ou plus).

Mais ça marche aussi bien sans ce '$'.

Tyrtamos
15/04/2009, 13h54
shadowsam
Tu dois pouvoir faire ca en une unique ligne en faisant un truc du genre :

Code:

motif = re.compile(r"($.*?$)?(\[.*?\])?{")

En décomposition ca donne:
- cherche 0 ou 1 occurrence de (...)
- puis cherche 0 ou 1 occurrence de [...]
- puis cherche {...
Je pense que c'est à ca que pensais Tyrtamos. J'ai essayé sur son exemple, ca retourne 4 fois True aussi.
15/04/2009, 13h57
shadowsam

Outch, ca ne passe pas ton dernier motif, cette expression. Parce que [] et () peuvent s'inverser et que je ne le prends pas en compte.

Je n'ai plus trop le temps de trouver mieux, la. Mais t'as l'idée générale, en tout cas.

Avec un peu de réflexion, il y a moyen de regrouper un peu, dans le genre de ce qu'a proposé shadowsam
Ce que tu cherches en fait c'est :

Code:

1
2
3
4
5
(...) (optionnel)
[...] (optionnel)
{---
OU
[...](...){---

C'est-à-dire, en regex :

Code:

1
2
3
4
5
6
7
(?:
  (?:\(\[a-zA-Z0-9=_;|]+\))?
  (?:\[\[a-zA-Z0-9=_;|]+\])?
) | (?:
  \[\[a-zA-Z0-9=_;|]+\]
  \(\[a-zA-Z0-9=_;|]+\)
) {

Pas besoin du ^ si on fait un match.

Mais à mon avis, dans ton cas, le plus efficace (si tu as besoin de performances) serait de vérifier caractère par caractère.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
expr = re.compile('[a-zA-Z0-9=_;|]')
 
def valide(chaine):
    bloc = False
    etat = [None, None] # None: Pas trouvé, False: Ouvert, True: Ouvert et fermé.
    corres = {'(': 0, ')': 0, '[': 1, ']': 1}
    for c in chaine:
        if bloc:
            if expr.match(c) is None: #Caractère non autorisé
                return False
            if c in ')]':
                if etat[corres[c]] is False: #Bonne correspondance
                    etat[corres[c]] = True
                    bloc = False
                else: #Mauvaise correspondance
                    return False
        else:
            if c in '([':
                if etat[corres[c]] is None: #Pas encore trouvé
                    etat[corres[c]] = False
                    bloc = True
                else: #Déjà trouvé
                    return False
            elif c == '{': #Fin du test, vérification de la fermeture
                return (False not in etat)
            else:
                return False
    return False

oiffrig, ton code fonctionne avec les changements suivants.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
import re
 
pattern_declaParam = re.compile('[a-zA-Z0-9=_;|]')
 
def testMeth(chaine):
# D'après :
# http://www.developpez.net/forums/d724077/autres-langages/python-zope/general-python/recherche-regex-toute-simple-moi/
 
# On doit avoir quelque chose du type avec = éventuellement à la place de {.
#    {...
# ou
#    (...){...
# ou
#    [...]{...
# ou
#    (...)[...]{...
# ou
#    [...](...){...
    bloc = False
    etat = [None, None] # None: Pas trouvé, False: Ouvert, True: Ouvert et fermé.
    corres = {'(': 0, ')': 0, '[': 1, ']': 1}
 
    for c in chaine:
        if bloc:
## CHANGEMENTS-DEBUT ##
            if c in ')]':
                if etat[corres[c]] is False: #Bonne correspondance
                    etat[corres[c]] = True
                    bloc = False
                else: #Mauvaise correspondance
                    return False
            elif pattern_declaParam.match(c) is None: # Caractère non autorisé
                return False
## CHANGEMENTS-FIN ##
 
        else:
            if c in '([':
                if etat[corres[c]] is None: #Pas encore trouvé
                    etat[corres[c]] = False
                    bloc = True
                else: #Déjà trouvé
                    return False
            elif c in '{=': #Fin du test, vérification de la fermeture
                return (False not in etat)
            else:
                return False
    return False
 
 
 
# Tests divers
if __name__ == '__main__':
    if True:
        tabloDeclaParam = []
# OK
        tabloDeclaParam.append("{nyosnvygteonvyudsom")
        tabloDeclaParam.append("(12azER){nyosnvygteonvyudsom")
        tabloDeclaParam.append("(12azER=_;|)[12azER=_;|]{nyosnvygteonvyudsom")
        tabloDeclaParam.append("[12azER=_;|]{nyosnvygteonvyudsom")
 
        tabloDeclaParam.append("=nyosnvygteonvyudsom")
        tabloDeclaParam.append("(12azER)=nyosnvygteonvyudsom")
        tabloDeclaParam.append("(12azER=_;|)[12azER=_;|]=nyosnvygteonvyudsom")
        tabloDeclaParam.append("[12azER=_;|]=nyosnvygteonvyudsom")
# PAS OK
        tabloDeclaParam.append("|nyosnvygteonvyudsom")
        tabloDeclaParam.append("(12a\"zER){nyosnvygteonvyudsom")
        tabloDeclaParam.append("(a=é)[12azER=_;|]{nyosnvygteonvyudsom")
        tabloDeclaParam.append("(a=r[12azER=_;|]{nyosnvygteonvyudsom")
        tabloDeclaParam.append("((12azER)=nyosnvygteonvyudsom")
 
        for decla in tabloDeclaParam:
            print decla + ' ===> ' + str(testMeth(decla))
            print '-'*60

Un grand merci à tous ! :king:

PS : pour clore ce post, je suis de moins en moins convaincu par les regex... Le seul endroit où j'en ai trouvé l'utilité c'est pour repérer des nombres romains : voir ici.