Cronômetro com Python e Tkinter

Introdução

Neste projeto, criaremos uma aplicação de cronômetro simples usando Python e Tkinter. O cronômetro terá funcionalidades para iniciar (start), parar (stop), reiniciar (reset) e sair (quit). Usaremos a biblioteca Tkinter para os componentes da interface gráfica do usuário (GUI) e a biblioteca time para operações relacionadas ao tempo.

👀 Pré-visualização

🎯 Tarefas

Neste projeto, você aprenderá:

• Como importar as bibliotecas necessárias para GUI e operações relacionadas ao tempo
• Como definir uma classe StopWatch que estende a classe Frame
• Como criar componentes GUI para o cronômetro
• Como atualizar o tempo decorrido e exibi-lo na GUI
• Como implementar funcionalidades para iniciar, parar e reiniciar o cronômetro
• Como criar uma função principal (main) para inicializar o objeto StopWatch e adicionar botões para interação

🏆 Conquistas

Após concluir este projeto, você será capaz de:

• Criar uma aplicação GUI usando Tkinter em Python
• Trabalhar com operações relacionadas ao tempo em Python
• Implementar funcionalidades para um cronômetro

Criar os arquivos do projeto

Primeiramente, crie um novo arquivo chamado stopwatch.py e abra-o no seu editor de código preferido.

cd ~/project
touch stopwatch.py

Importar as bibliotecas necessárias

No arquivo stopwatch.py, comece importando as bibliotecas necessárias. Precisamos de Tkinter para os componentes da GUI, ttk para widgets temáticos e time para operações relacionadas ao tempo. Adicione o seguinte código no início do arquivo:

from tkinter import *
from tkinter import ttk
import time

Definir a classe StopWatch

Em seguida, defina uma classe chamada StopWatch que estende a classe Frame. Usaremos esta classe para criar a funcionalidade do cronômetro. Adicione o seguinte código após as declarações de importação:

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

Criar os componentes da GUI

Dentro da classe StopWatch, adicione um método chamado makeWidgets que cria e posiciona os componentes da GUI. Este método será chamado a partir do construtor. Adicione o seguinte código dentro da 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)

Atualizar o tempo decorrido

Adicione um método chamado _update dentro da classe StopWatch. Este método calculará o tempo decorrido e atualizará a GUI. Adicione o seguinte código dentro da classe StopWatch:

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

Definir o tempo

Adicione um método chamado _setTime dentro da classe StopWatch. Este método formatará o tempo e atualizará a variável timestr. Adicione o seguinte código dentro da 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))

Implementar a funcionalidade de início

Adicione um método chamado Start dentro da classe StopWatch. Este método iniciará o cronômetro. Adicione o seguinte código dentro da classe StopWatch:

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

Implementar a funcionalidade de parada

Adicione um método chamado Stop dentro da classe StopWatch. Este método irá parar o cronômetro. Adicione o seguinte código dentro da 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

Implementar a funcionalidade de reset

Adicione um método chamado Reset dentro da classe StopWatch. Este método irá resetar o cronômetro. Adicione o seguinte código dentro da classe StopWatch:

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

Criar a função principal

Adicione uma função main fora da classe StopWatch. Esta função irá criar a janela principal da aplicação, inicializar o objeto StopWatch e adicionar botões para iniciar (start), parar (stop), resetar (reset) e sair (quit). Adicione o seguinte código após a 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()

Executar o projeto

Finalmente, mude para a Área de Trabalho (Desktop) e execute o projeto usando o seguinte comando:

python stopwatch.py

Resumo

Parabéns! Você criou com sucesso uma aplicação de cronômetro usando Python e Tkinter. Percorremos as etapas de criação dos arquivos do projeto, importando as bibliotecas necessárias, definindo a classe StopWatch, criando componentes da GUI (Graphical User Interface - Interface Gráfica do Usuário), atualizando o tempo decorrido, implementando a funcionalidade de iniciar (start), parar (stop) e resetar (reset), e criando a aplicação principal. Agora você pode executar o projeto e usar os botões para controlar o cronômetro.