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.
