Evenement "changement de valeur d'une variable"

Version imprimable

03/02/2024, 07h33
Caplande

Evenement "changement de valeur d'une variable"

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
03/02/2024, 08h25
wiztricks

Salut,

Citation:

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
03/02/2024, 09h45
Sve@r

Citation:

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.
03/02/2024, 11h05
Caplande

Evenement "changement de valeur d'une variable"

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

CAPLANDE
03/02/2024, 19h07
josmiley

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

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:

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()

06/02/2024, 06h04
Caplande

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 ?
06/02/2024, 08h27
wiztricks

Citation:

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

Citation:

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 :roll:
Code:

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:

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
Citation:

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.

Citation:

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

Citation:

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

Quel language ? A ma connaissance aucun :lol: 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.

Citation:

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.

Bonjour,

Citation:

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:

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

08/02/2024, 12h49
Sve@r

Citation:

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 :D

Citation:

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.

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é.

Citation:

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:

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

09/02/2024, 13h30
Sve@r

Citation:

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.
09/02/2024, 16h20
umfred

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

1 pièce(s) jointe(s)

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...
Pièce jointe 650584

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)...
09/02/2024, 18h25
papajoker

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 :mouarf: et des solutions dans un terminal existent. Si l'utilisation d'une interface graphique n'est pas un handicap pour le traitement, alors ok.
09/02/2024, 18h46
fred1599

Citation:

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 !
13/02/2024, 07h45
Caplande

Citation:

Envoyé par papajoker

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

Je me sens écrasé par tant de savoir... mais je m'accroche