Discussion :

[Beginner.]

Salut,

J'envisage de coder une petite class pour construire des objets permettant par exemple d’exécuter une fonction à intervalle régulier... Il devrait y a avoir plusieurs méthodes/fonctionnalités pour pouvoir spécifier l'intervalle (évidemment) et le nombre d’exécution maximal (si il y en a un), pour démarrer et stopper, pour connaitre le nombre d’exécutions et le temps qui s'est "réellement"* écouler depuis le démarrage...

* Par "réellement" je veux dire qu'il ne faudra pas obtenir ce temps en multipliant le nombre d’exécutions par la durée de l'intervalle car comme vous le savez ce n'est évidement pas fiable car il n'y a aucune garantie que ces intervalles de temps soient respectés.


Enfin bref, au début je voulais faire cela pour des applications tkinter et donc utiliser la méthode after, je voulais un truc plus général que la class animations de matplotlib... Et alors je me suis rendu compte qu'il existait une class encore plus générale (en ce sens qu'on peut l'utiliser même en dehors de tkinter et matplotlib) à savoir la class threading.Timer qui semble proche de la fonction after de tkinter.

Du coup je me demande quel serait le meilleur module à utiliser pour faire ce je que veux ? Y a-t-il un moyen plus avantageux ? Y a-t-il des problèmes auxquels je ne penses pas ?

Merci.

[wiztricks]

Salut,

Du coup je me demande quel serait le meilleur module à utiliser pour faire ce je que veux ? Y a-t-il un moyen plus avantageux ? Y a-t-il des problèmes auxquels je ne penses pas ?

A la base, ça fait pareil: déclencher l'exécution d'une fonction/callable/callback après X secondes.
La différence est que le multitâche de tkinter est coopératif alors que celui des threads est préemptif.

Le subtil de la chose est qu'avec coopératif, lorsque le callback s’exécute, un autre callback ne pourra s'exécuter qu'après qu'il se sera terminé. Dans le préemptif, plusieurs callbacks pourront s’exécuter en même temps.

note: la terminologie vient du "multitâche" qu'on a commencé à réaliser sur des mono-CPU (c'est à la base des scheduler/ordonnanceurs de processus des système à temps partagé des années 70s): le "en même temps" était impossible... mais suspendre l'exécution d'un callback (pré-empter = avant qu'il ne soit terminé) pour en exécuter un autre...

Dans le "en même temps", il y a la synchronisation d'accès à l'état du programme qui sera implicite (rien à faire) dans le cas coopératif et qui devra être explicite (queue, lock,...) dans le cas préemptif.

Là ou ça se corse, c'est qu'avec CPython (et le GIL), l'accès aux structures de données de bases est protégé contre les accès concurrents. Sur les exemples "simples", on peut oublier d'être "explicite" et ça va marchoter (tant que le GIL sera là).

Avec un GUI, on a déjà un multitâche "intégré" qui apporte ses "timers": pas besoin de threads (plus coûteuses en mémoire et CPU - c'est ce qui fait l'intérêt d'asyncio qui offre un multitâche coopératif "à la GUI").

- W

[Beginner.]

Salut,

Merci. Je crois que j'ai ma réponse...
Pour les applications tkinter je vais m'en tenir à after...