Discussion :

[elfyx]

Bonjour,

Voilà, j'ai démarré un projet où j'ai besoin de convertir des conditions if elseif else vers un autre format plus linéaire je dirai.
Je pars du principe que j'ai catch la ligne "if ..." car c'est à partir de cet instant que mes problèmes apparaissent.

Exemple :
input -> Type STRING -> "if ((dataA) and ((dataB) or (dataC))) then"

L'output souhaité doit grouper les data. Un peu à l'image d'une équation mathématique (A * (B + C)) qui donnerait AB + AC, le + serait le "or" et le * le "and".

output souhaité :
item 1 - dataA
item 1 - dataB
item 2 - dataA
item 2 - dataC


J'ai pensé à récupérer les informations dans un premier temps les data avec des regex python, puis j'avais dans l'idée de compter les parenthèses pour arriver à connaitre la hiérarchie des "and" et "or", mais je ne suis pas convaincu du chemin que je suis en train de prendre et cela fait plus de 2 jours que je suis dessus, donc je me suis dis qu'il était temps d'obtenir quelques avis ou pistes pour m'aider à trouver la solution.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
import re
string_to_parse = "if ((dataA) and ((dataB) or (dataC))) then"
PATTERN_ANDOR = r'(\(+([\S\s]+?)\)+\s(and|or|then))'
 
if "and" in string_to_parse and "or" in string_to_parse:
  print("\n\nENTER AND/OR\n")
  PATTERN_ANDOR = r'(\(+([\S\s]+?)\)+\s(and|or|then))'
  list = re.findall(PATTERN_ANDOR, string_to_parse, flags=re.MULTILINE)
  print(f"List : {list}\n")
  for elmt in list:
    print(f"Elmt : {elmt}")
    print(f"String : {elmt[0]} | occ ( : {elmt[0].count('(')} | occ ) : {elmt[0].count('(')} | link : {elmt[2]}\n")
    str_count_parenthesis_before = elmt[0].split(elmt[1])
    print(str_count_parenthesis_before)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
Le résultat de l'exécution à date donne :
 
python3 test.py
 
ENTER AND/OR
 
List : [('((dataA) and', 'dataA', 'and'), ('((dataB) or', 'dataB', 'or'), ('(dataC))) then', 'dataC', 'then')]
 
Elmt : ('((dataA) and', 'dataA', 'and')
String : ((dataA) and | occ ( : 2 | occ ) : 2 | link : and
 
['((', ') and']
Elmt : ('((dataB) or', 'dataB', 'or')
String : ((dataB) or | occ ( : 2 | occ ) : 2 | link : or
 
['((', ') or']
Elmt : ('(dataC))) then', 'dataC', 'then')
String : (dataC))) then | occ ( : 1 | occ ) : 1 | link : then
 
['(', '))) then'

J'espère avoir assez détaillé mon besoin, merci d'avance pour vos idées/réponses ou orientation sur mon problème

[wiztricks]

Salut,

Parser une expression numérique (ou booléenne) pour en faire un peu ce qu'on veut... n'a rien à voir avec la programmation Python et a été le sujet d'une littérature abondante car c'est une des bases des compilateurs industriels développé depuis les années 70s (du siècle dernier).
Évidement, il y de quoi faire avec les expressions régulières la dedans mais c'est un poil plus compliqué.

- W

[Sve@r]

Bonjour

Un peu à l'image d'une équation mathématique (A * (B + C)) qui donnerait AB + AC

Marre de voir le mot "équation" placé à tort et à travers dès qu'on expose un peu de maths. Ca ce n'est pas une équation. Une équation c'est une égalité (du latin "aequatio" qui signifie "égaler" et qui a donné "equal" en anglais). Pour qu'il y ait équation, il faut qu'il y ait le signe "=". Plus des variables qui empêchent la simplification (parce que 2+3=5 ce n'est pas non plus une équation).
Ca c'est un développement, qui est l'exact opposé de la factorisation.

le + serait le "or" et le * le "and".

Oui, c'est exactement ainsi qu'on le définit en algèbre de Boole.

j'avais dans l'idée de compter les parenthèses pour arriver à connaitre la hiérarchie des "and" et "or", mais je ne suis pas convaincu du chemin que je suis en train de prendre

Je ne vois pas trop en quoi A*B+A*C serait plus avantageux que A*(B+C). Mais si ton but est de supprimer les parenthèses, il y a un truc qui pourrait marcher : transformer une expression linéaire style (2+3)*4 en notation polonaise inversée, dans laquelle les parenthèses n'existent plus et qui serait ici 2, 3, +, 4, *
Et il existe un algo qui permet de le faire (algorithme de Shunting-yard).
Donc A*(B+C) donnerait A, B, C, +, * et qui est tout aussi lisible pour qui sait lire la NPI.

[elfyx]

Désolé si j’ai utilisé des termes à mauvais escient..
Pourquoi A*B + A*C serait plus facile à évaluer car le contenu de A, B et C sont des chaînes de caractères, en aucun cas j’aurai un calcul mathématique à faire à la fin.
A pourrait contenir «*serpent*»
B pourrait contenir «*arbre*»
C pourrait contenir «*pomme*»

Mais effectivement, mon besoin serait de développer la formule car plus simple ensuite pour le traitement que j’ai à faire.
Je vais regarder du côté de ta proposition de l’algo «*Shunting-yard*».