Afficher un compte à rebours par seconde dans une fenêtre graphique (ici Tkinter) n'est pas si facile, parce que ça nécessite un thread.

Voilà une solution possible

#! /usr/bin/env python 
# -*- coding: utf-8 -*- 
from __future__ import division
 
import Tkinter
import threading
import time
 
###############################################################################
def sec2hms(sd):
    """sec2hms(sd): transforme les secondes sd en chaine "hh:mm:ss" pour affichage"""
    h=0
    m=0
    s=sd
    if s >= 60:
        m = s//60
        s -= m*60
        if m >= 60:
            h = m//60
            m -= h*60
    return "%02d:%02d:%02d" % (h, m, s)
 
##################################################################
class Comptearebours(threading.Thread):
 
    def __init__(self, h, m, s):
        threading.Thread.__init__(self)
        self.t = h*3600 + m*60 + s
        self.encore = True
 
    def run(self):
        global app
        t1 = int(time.time())
        app.varsaisie.set(sec2hms(self.t))
        while self.encore:
            t2 = int(time.time())
            if t2>t1:
                self.t -= t2-t1
                if self.t <= 0:
                    self.t = 0
                    self.encore = False
                app.varsaisie.set(sec2hms(self.t))
                t1 = t2
            time.sleep(0.01)
 
    def stop(self):
        self.encore = False
 
##################################################################
class Application(Tkinter.Frame):
 
    def __init__(self, master=None):
 
        Tkinter.Frame.__init__(self, master)
 
        self.grid()
        self.varsaisie = Tkinter.StringVar()
        self.varsaisie.set("")
        self.saisie=Tkinter.Entry(self,  background="white", width=50, textvariable=self.varsaisie)
        self.saisie.grid(row=0,column=0,padx=3, pady=6)
 
        self.depart = Tkinter.Button(self, text="  Départ  ", command=lambda:self.partir(self))
        self.depart.grid(row=1, column=0, padx=3, pady=3, sticky="e")
 
        self.stop = Tkinter.Button(self, text="  stop  ", command=lambda:self.stopper(self))
        self.stop.grid(row=1, column=1, padx=3, pady=3, sticky="w")
 
        self.saisie.focus_set()
 
    def partir(self,event):
        self.chrono = Comptearebours(0,0,20)
        self.chrono.setDaemon(True)
        self.chrono.start()
 
    def stopper(self,event):
        self.chrono.stop()
 
##############################################################################
# lancement, affichage au centre de l'écran et exécution de la calculatrice
#
if __name__ == "__main__":
    fen=Tkinter.Tk()
    fen.title(u"Compte à rebours")
    app=Application(fen)
    fen.mainloop()

Vous pouvez intégrer l'ensemble de ce code par copier-coller.

Au lancement, il vient une petite fenêtre qui comporte 3 éléments: une zone de texte pour l'affichage et 2 boutons “départ” et “stop”.

On clique sur le bouton départ, et il s'affiche le temps de départ sous la forme “hh:mm:ss”.

Toutes les secondes, un nouvel affichage est déclenché avec le temps décroissant.

L'affichage s'arrête à 00:00:00 (le thread s'arrête tout seul) ou si l'utilisateur clique sur le bouton “stop”.

On appelle le thread qui fait le compte à rebours dans la méthode “partir” (ligne 71) avec comme paramètres les heures, minutes et secondes de départ. Pour l'essai, j'ai mis comme temps de départ h=0, m=0, s=20 (donc 20 sec qui s'affichent “00:00:20”), mais on peut mettre ce qu'on veut.

Si nécessaire, il serait facile de modifier le code pour que l'affichage commence à 00:00:00 et s'incrémente jusqu'à un temps donné au départ.

Amusez-vous bien!