Chronomètre utilisant Python et Tkinter

Introduction

Dans ce projet, nous allons créer une application de chronomètre simple en utilisant Python et Tkinter. Le chronomètre aura les fonctionnalités de démarrer, d'arrêter, de réinitialiser et de quitter. Nous utiliserons la bibliothèque Tkinter pour les composants d'interface graphique utilisateur (GUI) et la bibliothèque time pour les opérations liées au temps.

👀 Aperçu

🎯 Tâches

Dans ce projet, vous allez apprendre :

• Comment importer les bibliothèques nécessaires pour les opérations liées à l'interface graphique et au temps
• Comment définir une classe StopWatch qui étend la classe Frame
• Comment créer des composants d'interface graphique pour le chronomètre
• Comment mettre à jour le temps écoulé et l'afficher dans l'interface graphique
• Comment implémenter les fonctionnalités de démarrage, d'arrêt et de réinitialisation du chronomètre
• Comment créer une fonction principale pour initialiser l'objet StopWatch et ajouter des boutons pour l'interaction

🏆 Réalisations

Après avoir terminé ce projet, vous serez capable de :

• Créer une application d'interface graphique utilisant Tkinter en Python
• Travailler avec les opérations liées au temps en Python
• Implémenter les fonctionnalités d'un chronomètre

Créer les fichiers du projet

Tout d'abord, créez un nouveau fichier nommé stopwatch.py et ouvrez-le dans votre éditeur de code préféré.

cd ~/projet
touch stopwatch.py

Importer les bibliothèques nécessaires

Dans le fichier stopwatch.py, commençons par importer les bibliothèques requises. Nous avons besoin de Tkinter pour les composants d'interface graphique, de ttk pour les widgets thématiques et de time pour les opérations liées au temps. Ajoutez le code suivant au début du fichier :

from tkinter import *
from tkinter import ttk
import time

Définir la classe StopWatch

Ensuite, définissez une classe nommée StopWatch qui étend la classe Frame. Nous utiliserons cette classe pour créer la fonctionnalité du chronomètre. Ajoutez le code suivant après les instructions d'importation :

class StopWatch(Frame):
    def __init__(self, parent=None, **kw):
        Frame.__init__(self, parent, kw)
        self._start = 0.0
        self._elapsedtime = 0.0
        self._running = 0
        self.timestr = StringVar()

        self.makeWidgets()

Créer les composants d'interface graphique

Dans la classe StopWatch, ajoutez une méthode nommée makeWidgets qui crée et positionne les composants d'interface graphique. Cette méthode sera appelée depuis le constructeur. Ajoutez le code suivant à l'intérieur de la classe StopWatch :

    def makeWidgets(self):
        l = ttk.Label(self, textvariable=self.timestr)
        self._setTime(self._elapsedtime)
        l.pack(fill=X, expand=NO, pady=2, padx=2)

Mettre à jour le temps écoulé

Ajoutez une méthode nommée _update à l'intérieur de la classe StopWatch. Cette méthode calculera le temps écoulé et mettra à jour l'interface graphique. Ajoutez le code suivant à l'intérieur de la classe StopWatch :

    def _update(self):
        self._elapsedtime = time.time() - self._start
        self._setTime(self._elapsedtime)
        self._timer = self.after(50, self._update)

Réglage de l'heure

Ajoutez une méthode nommée _setTime à l'intérieur de la classe StopWatch. Cette méthode formatera l'heure et mettra à jour la variable timestr. Ajoutez le code suivant à l'intérieur de la classe StopWatch :

    def _setTime(self, elap):
        minutes = int(elap / 60)
        hours = int(minutes / 60)
        seconds = int(elap - minutes * 60.0)
        hseconds = int((elap - minutes * 60.0 - seconds) * 100)
        self.timestr.set('%02d:%02d:%02d:%02d' % (hours, minutes, seconds, hseconds))

Implémenter la fonctionnalité de démarrage

Ajoutez une méthode nommée Start à l'intérieur de la classe StopWatch. Cette méthode démarrera le chronomètre. Ajoutez le code suivant à l'intérieur de la classe StopWatch :

    def Start(self):
        if not self._running:
            self._start = time.time() - self._elapsedtime
            self._update()
            self._running = 1

Implémenter la fonctionnalité d'arrêt

Ajoutez une méthode nommée Stop à l'intérieur de la classe StopWatch. Cette méthode arrêtera le chronomètre. Ajoutez le code suivant à l'intérieur de la classe StopWatch :

    def Stop(self):
        if self._running:
            self.after_cancel(self._timer)
            self._elapsedtime = time.time() - self._start
            self._setTime(self._elapsedtime)
            self._running = 0

Implémenter la fonctionnalité de réinitialisation

Ajoutez une méthode nommée Reset à l'intérieur de la classe StopWatch. Cette méthode réinitialisera le chronomètre. Ajoutez le code suivant à l'intérieur de la classe StopWatch :

    def Reset(self):
        self._start = time.time()
        self._elapsedtime = 0.0
        self._setTime(self._elapsedtime)

Créer la fonction principale

Ajoutez une fonction main en dehors de la classe StopWatch. Cette fonction créera la fenêtre principale de l'application, initialisera l'objet StopWatch et ajoutera des boutons pour démarrer, arrêter, réinitialiser et quitter. Ajoutez le code suivant après la classe StopWatch :

def main():
    root = Tk()
    sw = StopWatch(root)
    sw.pack(side=TOP)

    Button(root, text='Start', command=sw.Start).pack(side=LEFT)
    Button(root, text='Stop', command=sw.Stop).pack(side=LEFT)
    Button(root, text='Reset', command=sw.Reset).pack(side=LEFT)
    Button(root, text='Quit', command=root.quit).pack(side=LEFT)

    root.mainloop()


if __name__ == '__main__':
    main()

Exécuter le projet

Enfin, basculez sur le bureau et exécutez le projet en utilisant la commande suivante :

python stopwatch.py

Résumé

Félicitations ! Vous avez réussi à créer une application de chronomètre en utilisant Python et Tkinter. Nous avons parcouru les étapes de création des fichiers du projet, de l'importation des bibliothèques nécessaires, de la définition de la classe StopWatch, de la création des composants graphiques, de la mise à jour du temps écoulé, de l'implémentation des fonctionnalités de démarrage, d'arrêt et de réinitialisation, et de la création de l'application principale. Vous pouvez désormais exécuter le projet et utiliser les boutons pour contrôler le chronomètre.