Evenement "changement de valeur d'une variable"

**Caplande** · 03/02/2024, 07h33

Bonjour,

J'imagine que ce sujet a déjà été abordé dans ce forum, mais difficile à formuler, les critères de recherche que j'ai utilisés ne m'ont donné aucun résultat.

Ma question est donc la suivante:

Est-il possible "d'écouter" une variable pour déclencher un événement lorsque sa valeur change ? Mes investigations sur le web semblent répondre par la négative, mais un seul contre-exemple suffirait à prouver le contraire.

Si quelqu'un a ce contre-exemple, ou peut m'expliquer pourquoi cette fonctionnalité ne peut exister, je lui en saurai gré.

Merci d'avance.

G CAPLANDE

**wiztricks** · 03/02/2024, 08h25

Salut,

Envoyé par Caplande

Est-il possible "d'écouter" une variable pour déclencher un événement lorsque sa valeur change ? Mes investigations sur le web semblent répondre par la négative, mais un seul contre-exemple suffirait à prouver le contraire.

Tout dépend de ce qu'on appelle "variable" et de l'objet auquel elle correspond.
Une réalisation de ce type de variable est par exemple les "variables" Tkinter qui font exactement ça.

- W
PS: En POO, ce genre d'objet réalise peu ou prou le pattern observer

**Sve@r** · 03/02/2024, 09h45

Envoyé par Caplande

Si quelqu'un a ce contre-exemple, ou peut m'expliquer pourquoi cette fonctionnalité ne peut exister, je lui en saurai gré.

Tout à fait.
En fait tout tient dans le rôle d'une variable. Une variable est avant tout faite pour mémoriser une information afin de pouvoir la réutiliser plus tard. Cette information est donc à l'initiative du développeur qui choisit de la mettre à jour selon les circonstances. Il connait donc les circonstances qui entrainent la mise à jour, il n'a donc pas besoin de "surveiller" la variable puisque c'est lui qui la met à jour.

Donc ton problème se situe, à mon avis, plus en amont. Un exemple : imagine que tu crées un capteur audio qui s'active quand il entend un son. Dans ce cas il met des variables à jour évidemment. Ce qu'il faut, c'est donc surveiller non pas la variable mais l'activation qui entraine sa mise à jour.
Ce mécanisme simpliste de surveillance non pas d'une variable mais d'un évènement peut s'élargir dans, comme l'a dit wiztricks, dans un "observateur" => ici expliqué de façon plus détaillée.

**Caplande** · 03/02/2024, 11h05

Merci à vous deux. Je vais me pencher sur le sujet.

CAPLANDE

**josmiley** · 03/02/2024, 19h07

J'aurais dit @property mais j'ai peut-être mal compris la question ...

**papajoker** · 04/02/2024, 22h28

bonjour

@property c'est uniquement pour des attributs de classe et ici on ne connait pas le contexte de la question donc pas possible de répondre.
A la place d'un setter, je suis plus pour un descripteur (même chose les 2). Et utiliser un setter n'est qu'une petite partie de la réponse

Exemple simple avec un descripteur : On attache des fonctions de callback à un attribut. Pour faire un peu étoffer, ici, on attache soit des fonctions, soit des méthodes.

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
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
#!/bin/env python
 
"""
Utiliser un descripteur ...
https://docs.python.org/fr/3/howto/descriptor.html
"""
 
import random
 
 
class EstObserve:
    def __init__(self, funcs=None, instances=None):
        """
        funcs : [function] : envoi notif vers function()
        instances: [str] : envoi notif vers instanceclasse.on_event()
        """
        if not funcs:
            funcs = []
        self.callbacks = funcs
        if not instances:
            instances = []
        self.instances = instances
 
    def __set_name__(self, owner, name):
        self.name = "__" + name
 
    def __get__(self, obj, objtype=None):
        return getattr(obj, self.name)
 
    def __set__(self, obj, value):
        # print(f" update ..{self.name[2:]} en : {value}")
        setattr(obj, self.name, value)
        for call in self.callbacks:
            call(self.name[2:], getattr(obj, self.name))
        for call in self.instances:
            try:
                getattr(obj, call).on_event(self.name[2:], value)
            except AttributeError:
                pass
 
 
def ecouteur(name, data):
    print(f"\t# receveur: var {name} == {data}")
 
 
def ecouteur2(name, data):
    print(f"\t# est {'mineur' if data < 18 else 'majeur'}")
    # if data < 18: exit(8)
 
 
class DataBase:
    """ devrait exister une interface """
    def on_event(self, name, data):  # méthode obligatoire avec cette signature
        print("\t# update dans bd ...")
 
 
class Personne:
    age = EstObserve(
        funcs=[ecouteur, ecouteur2],
        instances=["db"]
    )
 
    def __init__(self, age) -> None:
        self.age = age
        self.db = DataBase()  # recoit notif si age change
 
 
if __name__ == "__main__":
    moi = Personne(18)
    for _ in range(10):
        moi.age = random.randint(16, 21)
        print(f" Nouvel Age est: {moi.age}")
        print()

**Caplande** · 06/02/2024, 06h04

Bonjour papajoker,

Très élaborée votre proposition, mais, si j'ai bien compris son fonctionnement, on revient au point de départ et à la remarque de Sve@r relative à la cause de l'événement.
J'ai donc mal formulé ma question:
Soit un programme quelconque dans lequel j'utilise une variable i (pour une itération par exemple). Je voudrais savoir s'il est possible d'attacher un événement à cette variable, événement qui se déclenche chaque fois qu'elle change de valeur.
Alors,bien évidemment si i est l'index d'une itération, je maîtrise la cause de son changement et je peux associer le callback à chaque boucle d'itération.
Mais si ce n'est le cas, ne peut-on associer un objet à i et activer sur cet objet un écouteur du type OnChange comme cela existe dans d'autres langages ?

**wiztricks** · 06/02/2024, 08h27

Envoyé par Caplande

Mais si ce n'est le cas, ne peut-on associer un objet à i et activer sur cet objet un écouteur du type "OnChange" comme cela existe dans d'autres langages ?

C'est le propos du pattern observer d'aider à réaliser ce type d'objet (ce qui a déjà été dit... et qui prend peut être du temps à comprendre). A défaut de le coder (avec des descriptor par exemple), vous pouvez chercher des bibliothèques externes qui réalisent ce pattern.

Quelque part, le langage avec lequel est écrit une application importe peu pour l'utilisateur final. Il en est de même pour les techniques plus ou moins avancées utilisées pour l'écrire: l'important est que ça marche avec une consommation de ressources raisonnable => si vous pouvez faire sans le truc magique qui...c'est que le besoin n'est que non-technique.

- W

**papajoker** · 06/02/2024, 15h50

Envoyé par Caplande

j'utilise une variable i (pour une itération par exemple). Je voudrais savoir s'il est possible d'attacher un événement à cette variable, événement qui se déclenche chaque fois qu'elle change de valeur.

Tu n'a même pas joué avec mon code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class Login:
    """ devrait exister une interface """
    def on_event(self, name, data):  # méthode obligatoire avec cette signature
        print("\t# update dans log ...")
#...
    espionné = Personne(18)
    for espionné.age in range(5):
        pass
 
    espionné.db = Login()  # tu peux renommer "db" en OnChange
    for espionné.age in range(5):
        pass

Si on veut écrire mon premier exemple en un peu plus générique, c'est :

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
...
class Listen():
    value = EstObserve(instances=["on_change"])
    def __init__(self, value, observer=None) :
        self.value = value
        self.on_change = observer
 
# fin du module "grande_oreille"
 
class Login:
    def on_event(self, name, data):
        print("\t# print dans log ...", name, data)
 
class Db:
    def on_event(self, name, data):
        print("\t# write dans Database ...", name, data)
 
 
espionné = Listen(0, Login())
for espionné.value in range(5):
    pass
print("-----")
espionné.on_change = Db()
for espionné.value in range(5):
    pass

Envoyé par Caplande

je peux associer le callback

.
callback et évènement sont deux choses différentes, il faudrait être précis ! avec pyQt j'utilise des évènements mais certainement pas dans un simple script python.

Mais si ce n'est le cas, ne peut-on associer un objet à i et activer sur cet objet un écouteur du type OnChange comme cela existe dans d'autres langages ?

Donc en fait, tu poses des questions mais tu ne testes pas par toi même ? Il y a quand même un code python donné par le lien de Sve@r

un écouteur du type OnChange comme cela existe dans d'autres langages ?

Quel language ? A ma connaissance aucun

par contre, on peut parfois trouver des choses type on_change() dans de très nombreuses bibliothèques (c'est la base en gui et html), ici c'est a toi d'écrire cette bibliothèque ou, utiliser une de disponible en python.

utilise une variable i (pour une itération par exemple). événement qui se déclenche chaque fois qu'elle change de valeur

rien compris à ta demande (Il serait 1000 fois plus simple de comprendre ton besoin réel). Si on fait une itération, on change de variable à chaque fois... ou alors, c'est ce que j'ai codé.
Note : de plus en python nous avons quelques types immuables, il ne changent donc pas de valeur, mais sont remplacés.

**MPython Alaplancha** · 08/02/2024, 09h52

Bonjour,

Envoyé par Caplande

Soit un programme quelconque dans lequel j'utilise une variable i (pour une itération par exemple). Je voudrais savoir s'il est possible d'attacher un événement à cette variable, événement qui se déclenche chaque fois qu'elle change de valeur.
Alors,bien évidemment si i est l'index d'une itération, je maîtrise la cause de son changement et je peux associer le callback à chaque boucle d'itération.
Mais si ce n'est le cas, ne peut-on associer un objet à i et activer sur cet objet un écouteur du type OnChange comme cela existe dans d'autres langages ?

Les interfaces graphiques disposent de mécanisme permettant de lier un type de variable à un callback. Par exemple avec kivy, on peut créer un objet de type numérique(ou autre) et le lier à une fonction. Ça pourrait ressembler à :

Code :

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

1
2
3
4
5
6
7
8
class Truc(Label):
    c = NumericProperty(0) 
    def __init__(self):
        super().__init__()
        self.bind(c=self.callback) 
 
    def callback(self,instance, value):
        #est appellé à chaque fois que self.c change de valeur

**Sve@r** · 08/02/2024, 12h49

Envoyé par Caplande

Alors,bien évidemment si i est l'index d'une itération, je maîtrise la cause de son changement et je peux associer le callback à chaque boucle d'itération.

C'est effectivement une remarque inévitable au vu de ton exemple

Envoyé par Caplande

Mais si ce n'est le cas, ne peut-on associer un objet à i et activer sur cet objet un écouteur du type OnChange comme cela existe dans d'autres langages ?

On en revient aux fondamentaux. Si ce n'est pas le cas, déjà pourquoi ce ne sera pas le cas ? Quelle situation pourrait amener une variable à changer sans que tu ne puisses identifier la cause de ce changement et donc associer ladite cause à ce "onChange" ? Parce que de mon côté j'essaye d'imaginer des cas mais je n'en trouve pas.

**fred1599** · 08/02/2024, 13h38

Hello,

Encore une fois la question du PO n'est pas claire, mais elle le devient beaucoup plus dans sa réponse suivante, et à mon sens la réponse donnée par @josmiley semble être une des solutions que j'avais imaginé.

Soit un programme quelconque dans lequel j'utilise une variable i (pour une itération par exemple). Je voudrais savoir s'il est possible d'attacher un événement à cette variable, événement qui se déclenche chaque fois qu'elle change de valeur.
Alors,bien évidemment si i est l'index d'une itération, je maîtrise la cause de son changement et je peux associer le callback à chaque boucle d'itération.
Mais si ce n'est le cas, ne peut-on associer un objet à i et activer sur cet objet un écouteur du type OnChange comme cela existe dans d'autres langages ?

En étayant les propos de @josmiley, je voyais bien ce type d'écouteur sous forme de @property.

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
import random
 
class ValueChangeListener:
    def __init__(self, initial_value=None):
        self._value = initial_value
 
    @property
    def value(self):
        return self._value
 
    @value.setter
    def value(self, new_value):
        if new_value != self._value:
            self._value = new_value
            self.on_value_change(new_value)
 
    def on_value_change(self, new_value):
        print(f"Value changed to: {new_value}")
 
 
first_value, *values = [random.randint(1, 10) for _ in range(5)]
listener = ValueChangeListener(first_value)
for i in values:
    listener.value = i
 
# Value changed to: 6
# Value changed to: 5
# Value changed to: 6
# Value changed to: 9

**Sve@r** · 09/02/2024, 13h30

Envoyé par fred1599

En étayant les propos de @josmiley, je voyais bien ce type d'écouteur sous forme de @property.

Oui bien sûr. Tu utilises les propriétés syntaxiques de Python et de ses setters pour réécrire l'affectation. Un lecteur peu au fait de ces subtilités verra dans listener.value = i une simple affectation classique alors qu'en réalité ça appelle une fonction de façon cachée, fonction que tu peux donc décorer à loisir pour y rajouter tous les traitements que tu veux. Certes ça répond à la problématique "comment checker une affectation" (parce que "changer de valeur" ça se traduit par "affecter une nouvelle valeur à la place de l'ancienne")... mais ça ne répond pas à la problématique que j'ai soulevée (et qui me semble intéressante) : quelles circonstances peuvent amener un évènement à faire modifier une variable sans que l'on ne puisse alors surveiller l'évènement au lieu de surveiller la variable ? Parce que je sens que si le PO ne peut pas répondre à cette question, cela pourrait signifier qu'il a mal perçu certains points de son projet.

Dit autrement : quelle que soit la ligne du code où il est écrit cette fameuse affectation de cette fameuse variable, on pourra toujours y rajouter une instruction avant (ou après), instruction contenant le code (ici un callback) que l'on veut associer à cette affectation.

**umfred** · 09/02/2024, 16h20

pour info, il a trouvé (me semble-t-il) une réponse satisfaisante à sa demande sur https://openclassrooms.com/forum/sujet/tkinter-fe9ed

**Sve@r** · 09/02/2024, 16h53

Ah ben oui évidemment !!! Mais sa question là-bas n'a rien, mais alors rien du tout à voir avec celle d'ici.
Là bas il veut partir de Tk, faire exécuter un programme externe dans une boucle de traitement de n éléments (n photos) et dans Tk afficher le traitement en cours (style "traitement photo 1", "traitement photo 2" etc). C'est totalement à l'ouest de "surveiller une variable" quoi !!!
En fait on se trouve dans un cas typique de problème XY. Au lieu de partir sur "comment dans tk afficher le déroulé d'un traitement externe" il est parti sur des "callback sur variables etc" bref...
Nom : projet.png
Affichages : 80
Taille : 15,6 Ko

Nom : projet.png
Affichages : 80
Taille : 15,6 Ko

Et le plus triste c'est que son souci fait partie des soucis connus des GUI (comment mettre à jour une GUI lors de tâches externes) que Qt permet de résoudre via les Qthread. Certainement que Tk permet une solution analogue (à base là aussi de thread probablement)...

**papajoker** · 09/02/2024, 18h25

Merci umfred

Si je comprends (merci Caplande de nous avoir jamais donné le contexte), il voulait simplement faire une barre de progression (d'un traitement de photos)

Passer a Tk est quand même extrême

et des solutions dans un terminal existent. Si l'utilisation d'une interface graphique n'est pas un handicap pour le traitement, alors ok.

**fred1599** · 09/02/2024, 18h46

Si l'utilisation d'une interface graphique n'est pas un handicap pour le traitement, alors ok

Au départ il n'était pas question d'interface graphique, d'ailleurs sur l'autre forum il le précise. Qui puis est il indique se sentir obligé d'utiliser une IHM...

Bref, le PO n'a jamais proposé de codes indiquant que l'une ou l'autre des solutions proposées ne correspondaient pas à ce qu'il souhaitait et surtout pourquoi ça ne correspondait pas, ce qui rend difficile la compréhension de son problème.

C'est un problème XY peut-être, moi quand je vois pas de code, je me sens un peu baladé par les belles paroles du PO !