Discussion :

[luluunix]

Bonjour à tous,

Je souhaiterais créer un objet qui puisse contenir, (passée en argument lors de sa création), une condition qui doit être vérifiable en temps réel à tout moment.

Exemple :

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
class Testeur() :
   def __init__ (self, condition) :
       self.condition = condition
       self.resultat = False
 
   def tester(self) :
       if self.condition :
          self.resultat = True
       else :
         self.resultat = False
 
 
a = 1
 
testeur = Testeur(condition = a < 0)
 
print("Le résultat est : ", testeur.tester()) ##doit afficher False
 
a = -2
 
print("Le résultat est : ", testeur.tester()) ##doit afficher True

Y-a-t-il une solution technique qui m'éviterait de devoir passer la condition en argument à chaque appel de la méthode "tester()" ?

Pour l'instant je m'aperçois que ce n'est pas la condition elle-même avec des alias ou des références d'objets qui sont passées en argument mais le résultat lui même en boolean.

Merci par avance pour vos conseils et pistes de réflexion.

A +

[wiztricks]

Salut,

Je n'aime pas "eval" lorsqu'on lui donne a manger des entrées/sorties. Interagir avec l’extérieur est un trou de sécurité ou dans les fonctionnalités mal couvertes de l'applicaction.
Ici, l'appel a "eval" est sans danger: on sait ce qu'on lui demande de faire: eval("a < 1").

Mais je n'ai pas de moins mauvaise solution.
Enfin, après il faut faire de la POO, c'est tout de suite plus complique.

En fait "a" est une variable "globale".
En Python, c'est un chemin d’accès a l'objet référence par "a" - notons ça /globals()['a']/.

Manque de bol, les assignations "a = object" font que l’accès, via le chemin /globals()['a']/", trouvera un autre objet.
"ré-évaluer la condition" passe par récupérer ce nouvel objet, i.e. parcourir le chemin: eval fait cela simplement.

Ceci dit, pas de soucis, le code est simple.
Pourquoi ça marche? Essentiellement parce que Python est un langage de scripting. Avec Bash, on peut évaluer des instructions a la volée. Python permet de compiler et d’exécuter a la volée.
note: on sait aussi faire ça en assembleur. ce n'est pas liée au langage mais a la machine abstraite qui est dessous.

C'est très surprenant.
Il faut juste éviter d'en abuser: a n'utiliser que dans les cas désespérés.

Enjoy!

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
class Testeur() :
    def __init__ (self, condition) :
        self.condition = condition
        self.resultat = False
 
    def tester(self) :
        self.resultat = eval(self.condition)
        return self.resultat
 
if __name__ == '__main__':
    a = 1
    testeur = Testeur(condition="a < 0")   
    print("Le resultat est : ", testeur.tester()) ##doit afficher False
    a = -2
    print("Le resultat est : ", testeur.tester()) ##doit afficher True

- W

[luluunix]

Merci beaucoup pour votre réponse qui est exactement ce qu'il me fallait !

J'en conclus que, si les conditions de "test" sont expréssément définies à l'avance, il n'y a pas de faille de sécurité dans une application ?

D'autre part, pour aller plus loin, dans un pareil cas, comment vous y prendriez-vous pour effectuer ce genre de fonction "proprement" avec la POO ?

[wiztricks]

Salut,

Pour ne pas utiliser "eval" dans ce cas la, Python dispose de la fonction lambda. Plutot qu'ecrire:

Code :

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

1
2
3
4
5
    condition = 'a < 0'
    a = 1
    assert eval(condition) is False
    a = -1
    assert eval(condition) is True

On peut faire:

Code :

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

1
2
3
4
5
    condition = lambda: a < 0
    a = 1
    assert condition() is False
    a = -1
    assert condition() is True

D'autre part, pour aller plus loin, dans un pareil cas, comment vous y prendriez-vous pour effectuer ce genre de fonction "proprement" avec la POO ?

Vous constatez que "class Testeur..." est sans rapport avec la solution qui relève plutôt de la programmation fonctionnelle.
- W

[Drawingrom]

D'autre part, pour aller plus loin, dans un pareil cas, comment vous y prendriez-vous pour effectuer ce genre de fonction "proprement" avec la POO ?

Pas forcément avec la POO, mais en Python, je passerais la fonction de test au constructeur, potentiellement sous forme de lambda. Voici une forme générique.

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
22
23
 
#!/usr/bin/env python
#-*- coding: utf-8 -*-
 
 
class Testeur():
    def __init__(self, condition):
        self.condition = condition
        self.resultat = False
 
    def tester(self, *args):
        self.resultat = self.condition(*args)
        return self.resultat
 
def main():
    a = 1
    b = -10
    testeur = Testeur(lambda x: x < 0)
    print("Le resultat est : " +  str(testeur.tester(a)))
    print("Le resultat est : " +  str(testeur.tester(b)))
 
if __name__ == '__main__':
    main()

[Pierre Maurette]

Bonjour,
Je ne comprends pas bien votre classe, en particulier ce que vient faire l'attribut resultat. Il ne faut pas hésiter en Python à faire de la programmation fonctionnelle basique, une condition est, comme une comparaison, une fonction, et une fonction est un objet comme un autre. Je vous propose à triturer:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Testeur() :
    def __init__ (self, condition) :
        self.condition = condition
 
    def tester(self, x) :
        return self.condition(x)
 
for condition in (lambda x: x < 0 # strictement négatif
                , lambda x: x >= 10 and x < 20 # entre 10 et 19
                , lambda x: isinstance(x, float) or x + 122 == 133):# un float OU 11
    testeur = Testeur(condition = condition)
    for a in (10, 8, 0, -10, 11, 16, 20.0, 100):
        print(u"Pour %s le résultat est : %s" % (a, testeur.tester(a)))
    print 45 * '-'

Attention à éviter des trucs genre

Code :

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

1
2
3
4
if condition:
    a = True
else:
    a = False

au profit de

Code :

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

a = condition

Si condition (mal nommé alors) n'est pas un booléen, mais que vous comptez sur la traduction en booléen par python, utilisez bool(), voire not not ou autre:

Code :

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

1
2
for x in (-2, 0, 1.1, "0", "", "21", "0zorglub", "zorglub", "zorglub0"):
    print u"%s -> %s  %s" % (x, bool(x), not not x)

[luluunix]

Merci à tous pour vos réponses, je vais prendre le temps de les étudier.

En tout cas merci, mon problème est résolu et j'en ai appris plus que ce que j'espérais !

[fred1599]

J'ai lu toutes les réponses et en fait j'en ai déduis une question

Quel est la situation qui permettrait de déduire qu' une chaine doit être évalué comme une expression python?

J'ai beau cherché, je ne vois pas à part la lecture d'expressions dans un fichier, dans ce cas, la seule "solution simple" est celle de wiztricks avec eval.

L'autre solution, c'est de parser ligne par ligne, mais est-ce la lecture d'un fichier?

Alors pour aller plus loin dans les solutions, si on pouvait avoir les tenants et les aboutissants du projet, on pourrait peut-être éviter des choses assez sales et non sécuritaires comme l'utilisation de la fonction eval.

Qu'est-ce qu'on a à traiter (fichier, chaine de caractères, autres)?

Bref j'apporte tout de même une contribution...

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
from operator import lt, le, eq, ne, gt, ge
class Testeur:
 
    OPERATOR = {
                '<': lt, '<=': le, '>': gt, 
                '>=': ge, '==': eq, '!=': ne
               }
 
    ERRORS = {
              'operate': 'separate by space your expression',
              'key': '{} operator is not valid (<, <=, >, >=, ==)'
             }
 
    def __init__(self, condition):
        '''condition with this form a < b'''
        self.condition = condition
        self.parse()
 
    def parse(self):
        try:
            self.var, self.op, self.value = self.condition.split()
        except ValueError:
            raise ValueError(self.ERRORS['operate'])
 
    def tester(self):
        try:
            oper = self.OPERATOR[self.op]
        except KeyError:
            raise ValueError(self.ERRORS['key'])
        return oper(globals()[self.var], int(self.value))
 
a = 5
 
t = Testeur('a == 5')
print(t.tester()) # True
 
t = Testeur('a > 2')
print(t.tester()) # True
 
t = Testeur('a <= 2')
print(t.tester()) # False

[luluunix]

Eh bien en fait :

J'essaie de faire un programme qui crée des composants électroniques (diodes, résistances, ...).

J'ai des objets qui représentent des leds avec un attribut boolean "allume".



Pour chaque led, je veux définir une condition "arbitraire" : si intensité >= 0.5 mA, alors led.allume = True, avec une condition d'allumage différente pour chaque led.

Et je veux l'automatiser pour n'avoir qu'à faire led.tester() sans repasser la condition à chaque fois. Le problème à l'heure actuelle est celui de l'espace de nom.

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
 
class App() :
   def __init__ (self) :
      self.intensite = 0.5 #mA
      self.led1 = Led("self.intensite >= 0.5")
 
 
class Led() :
   def __init__ (self, condition) :
      self.condition = False
      self.allume = False
 
 
   def tester(self) :
      self.allume = eval(condition)
 
 
if __name__ = "__main__" :
    app = App()

Et Python répond que Led ne contient pas d'attribut "self.intensite". Comment alors accéder à self.intensite de l'espace de nom de App ?

Mis à part celà eval() répondait très bien à mon besoin. J'ai quand même la solution de passer la condition à chaque appel de led.tester() (ce qui serait à peine plus lourd à programmer mais tant qu'à faire autant apprendre des techniques élégantes).

J'ai essayé d'envoyer app.intensité au lieu de self.intensité, mais ça ne fonctionne pas, ce qui, après réflexion, me paraît logique.

[luluunix]

Merci pour votre proposition technique, je l'étudie dès maintenant.

[fred1599]

Ça marche pas un truc de ce genre ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class App() :
   def __init__ (self) :
      self.intensite = 0.5 #mA
      self.led1 = Led(self.intensite, 0.5)
      print(self.led1.allume) # Test si led est allumée
 
 
class Led() :
   def __init__ (self, intensite, limit) :
      self.allume = intensite >= limit
 
 
if __name__ == "__main__" :
    app = App()

[wiztricks]

Salut,

J'essaie de faire un programme qui crée des composants électroniques (diodes, résistances, ...).

J'ai des objets qui représentent des leds avec un attribut boolean "allume".

J’écrirai cela ainsi:

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class globs:
    current = 0
 
 
class Led:
 
    def __init__(self, number, threshold, condition=None):
        self._number = number
        self.threshold = threshold
        self.condition = condition or type(self)._condition
 
    @property
    def is_on(self):
        return self.condition(self)
 
    def _condition(self):
        print ('_condition')
        return self.threshold == globs.current
 
    def __str__(self):
        return 'Led %d: is_on: %s' % (self._number, self.is_on)
 
if __name__ == '__main__':
 
    def condition(self):
        return self.threshold <= globs.current
    leds = [ Led(1, 1),
             Led(2, 2, condition=condition),
             Led(3, 3, condition=condition)]
 
 
    for led in leds:
        print (led)
    print ('current >> 2')
    globs.current = 2
    for led in leds:
        print (led)

Mais ça ne fait pas un réseau électrique.

De toutes façons, il y a deux sujets: le modèle de réseau électrique que vous voulez construire et comment programmer cela (avec Python ou autre chose).

Si vous débutez, vous avez tendance a limiter les possibilités du modèle en fonction de votre savoir faire cote "codage".

Ce qui ne fera ni un bon modèle, ni un bon code.

- W

[luluunix]

Ça marche pas un truc de ce genre ?

Ca marcherait à l'instanciation de "Led" mais je ne pense pas qu'on puisse mettre à jour la condition en temps réel, à tout moment ?

De toutes façons, il y a deux sujets: le modèle de réseau électrique que vous voulez construire et comment programmer cela (avec Python ou autre chose).

Si vous débutez, vous avez tendance a limiter les possibilités du modèle en fonction de votre savoir faire cote "codage".

Ce qui ne fera ni un bon modèle, ni un bon code.

C'est pour ça que je demande si quelqu'un a une meilleure solution technique que moi pour le problème énoncé.

En tout cas j'étudie votre solution et notamment la partie "décorateur" car, avouons le, votre code est très technique et je vais essayer de le décortiquer.

En d'autres termes, vous conseillez d'acquérir un très bon niveau en Python avant de commencer à développer un quelconque projet, plutôt qu'un niveau "débutant +" ?

[josmiley]

Perso je pige pas pourquoi la condition doit être extérieure à l'objet.

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
class Led(object):
 
    def __init__(self,th):
        self.th = th
 
    @property
    def state(self):
        return App.intensite >= self.th
 
class App(object):
    intensite = 0
    led1 = Led(10)
    led2 = Led(5)
 
 
 
App.intensite = 9
print(App.led1.state)
print(App.led2.state)

effectivement c'est plus complexe que ça, faudrait lier chaque led à un noeud du circuit car je suppose que l'intensité n'est pas la même partout.

[wiztricks]

En d'autres termes, vous conseillez d'acquérir un très bon niveau en Python avant de commencer à développer un quelconque projet, plutôt qu'un niveau "débutant +" ?

Je dirais qu'avec Internet vous avez la possibilité de récupérer et étudier des codes écrits par d'autres. Ces "lectures" sont, a mon sens, bien plus enrichissantes que les gribouillages de pages blanches.

C'est pour ça que je demande si quelqu'un a une meilleure solution technique que moi pour le problème énoncé.

"meilleure solution technique" n'existe pas en dehors d'un contexte non technique. La capacité du codeur a comprendre ce que fait son code en fait partie. Autrement dit, un code qui fonctionne peut être acceptable même si vous n'en êtes pas si fier lorsque vous le relirez dans 6 mois.

effectivement c'est plus complexe que ça, faudrait lier chaque led à un noeud du circuit car je suppose que l'intensité n'est pas la même partout.

Ah ben on est loin des fonctionnalités de VHDL

- W

[fred1599]

Ca marcherait à l'instanciation de "Led" mais je ne pense pas qu'on puisse mettre à jour la condition en temps réel, à tout moment ?

Euh soit j'ai pas pigé, soit vous ne comprenez pas ma solution, mais en gros la solution a cette question me semble simple, vous pouvez modifier à tout moment la valeur des variables intensite et limit, quel est le problème?

[wiztricks]

Euh soit j'ai pas pigé, soit vous ne comprenez pas ma solution, mais en gros la solution a cette question me semble simple, vous pouvez modifier à tout moment la valeur des variables intensite et limit, quel est le problème?

Certes, mais avec:

Code :

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

1
2
3
class Led() :
   def __init__ (self, intensite, limit) :
      self.allume = intensite >= limit

Il faut re-creer l'instance pour prendre en compte la mise a jour, non?
- W

[fred1599]

Oui, tout à fait, mais est-ce gênant ?

Mais maintenant qu'on sait ce que veut l'auteur, la conception peut être modifiée d'une façon optimale.

[luluunix]

Merci à tous pour vos participations et vos idées.

Je pense que pour l'instant j'utiliserai la fonction "eval" en attendant d'avoir bien compris les tenants et les aboutissants des autres solutions proposées.

Ce sujet est donc résolu, grâce à vous.

[stalacta]

Bonjour, je n'ai pas tout lu mais j'aurais une solution à la question de départ :

Code :

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

1
2
3
4
5
6
7
8
9
class Testeur :
    def __init__(self,condition) :
        """condition doit être une chaîne de caractères"""
        self.condition=condition
    def tester(self) :
        try : exec("a="+self.condition)
        except : raise SyntaxError("La sythaxe de la chaîne passée en paramètre n'est pas bonne ou un objet n'est pas défini.")
        if type(a) is not bool : raise TypeError("L'objet renvoyé n'est pas un boléen.")
        return a