Сделать простой секундомер остановить

Question

Я пишу простой секундомер с python (используя pyqt5).Пока что функции запуска / паузы / возобновления работают нормально, но проблема в том, что когда я останавливаю счетчик и мне нужно начинать с 0, поток не может быть запущен снова. Я пробовал подкласс с здесь , но это не такза работой.

import threading
from PyQt5 import QtWidgets
from stpw_ui import Ui_MainWindow
from time import sleep

# code snippet from stack overflow to stop a thread
class StoppableThread(threading.Thread):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._stop_event = threading.Event()

    def stop(self):
        self._stop_event.set()

    def stopped(self):
        return self._stop_event.is_set()

class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
    def __init__(self):
        QtWidgets.QMainWindow.__init__(self)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        # buttons' actions
        self.ui.start.clicked.connect(self.stopwatch)
        self.ui.pause.clicked.connect(self.pse)
        self.ui.stop.clicked.connect(self.stp)
        self.ui.resume.clicked.connect(self.res)
        # self.ui.reset.clicked.connect(self.rst)

        self.t = StoppableThread(target=self.strt)

    def UpdateSec(self,s):
        self.ui.seconds.display(s)

    def UpdateMin(self,m):
        self.ui.minutes.display(m)

    def stopwatch(self):
        self.ui.stacked_buttons.setCurrentIndex(1)
        self.pause = False
        self.t.start()

    pause = False
    second = 0
    minute = 0

    def setpause(self,x):
        self.pause = x

    # start
    def strt(self):
        if (self.pause is True):
            sleep(0.1)
        while self.second <= 59 and self.pause == False:
            self.UpdateSec(self.second)
            self.second += 1
            sleep(1)
        if self.second==59:
            self.minute += 1
            self.UpdateMin(self.minute)
            self.second = 0
        self.strt()

    # pause
    def pse(self):
        self.ui.stacked_buttons.setCurrentIndex(2)
        self.setpause(True)


    # stop
    def stp(self):
        self.setpause(True)
        self.ui.stacked_buttons.setCurrentIndex(0)
        self.t.stop()

    # resume
    def res(self):
        self.ui.stacked_buttons.setCurrentIndex(1)
        self.setpause(False)

    # reset / ignore it for now
    # def rst(self):
    #    self.ui.stacked_buttons.setCurrentIndex(0)
    #    self.setpause(False)


if __name__ == '__main__':
    import sys
    app = QtWidgets.QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

Итак:

1. Как заставить работать кнопку остановки?(что я тут не так делаю?)
2. Есть ли лучший / простой подход к созданию секундомера?потому что мне кажется, что я слишком усложняю это.

Файл GUI (stpw_ui.py) доступен по адресу https://www.filedropper.com/stpwui

Answer 1

Не используйте sleep в GUI, потому что вы можете заморозить GUI.С другой стороны, использование потока является слишком сложным для этого вопроса, в графическом интерфейсе использование потока оправдано, только если задача тяжелая, но увеличение пары данных каждую секунду не является тяжелой задачей.

Вместо этого вы должны использовать QTimer для выполнения повторяющихся задач и QTime для получения истекшего времени.

Для логики должен быть реализован конечный автомат, в этом случае это будет StopWatch, который будет излучать необходимые сигналы для уведомленияизменения в графическом интерфейсе.

from PyQt5 import QtCore, QtWidgets
from stpw_ui import Ui_MainWindow

class State:
    STOPPED = 0
    PAUSE = 1
    RUNNING = 1 << 1

class StopWatch(QtCore.QObject, State):
    State = State
    QtCore.Q_ENUMS(State)

    secondChanged = QtCore.pyqtSignal(int)
    minuteChanged = QtCore.pyqtSignal(int)
    stateChanged = QtCore.pyqtSignal(State)

    def __init__(self, parent=None):
        super(StopWatch, self).__init__(parent)
        self._current_state = State.STOPPED
        self._time = QtCore.QTime()
        self._timer = QtCore.QTimer(self, interval=100, timeout=self.on_timeout)
        self._delta = 0
        self._seconds = 0
        self._minutes = 0

    def setCurrentState(self, state):
        self._current_state = state
        self.stateChanged.emit(state)

    @QtCore.pyqtSlot()
    def start(self):
        self._delta = 0
        self._timer.start()
        self._time.start()
        self.setCurrentState(State.RUNNING)

    @QtCore.pyqtSlot()
    def stop(self):
        if self._current_state != State.STOPPED:
            self._timer.stop()
            self.setCurrentState(State.STOPPED)

    @QtCore.pyqtSlot()
    def pause(self):
        if self._current_state == State.RUNNING:
            self._timer.stop()
            self.setCurrentState(State.PAUSE)
            self._delta += self._time.elapsed()

    @QtCore.pyqtSlot()
    def resume(self):
        if self._current_state == State.PAUSE:
            self._timer.start()
            self._time = QtCore.QTime()
            self._time.start()
            self.setCurrentState(State.RUNNING)

    @QtCore.pyqtSlot()
    def on_timeout(self):
        t = QtCore.QTime.fromMSecsSinceStartOfDay(self._delta + self._time.elapsed())
        s, m = t.second(), t.minute()
        if self._seconds != s:
            self._seconds = s
            self.secondChanged.emit(s)

        if self._minutes != m:
            self._minutes = m
            self.minuteChanged.emit(m)

class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.setupUi(self)

        self._stop_watch = StopWatch(self)

        self.start.clicked.connect(self._stop_watch.start)
        self.pause.clicked.connect(self._stop_watch.pause)
        self.stop.clicked.connect(self._stop_watch.stop)
        self.resume.clicked.connect(self._stop_watch.resume)

        self._stop_watch.secondChanged.connect(self.seconds.display)
        self._stop_watch.minuteChanged.connect(self.minutes.display)
        self._stop_watch.stateChanged.connect(self.on_stateChanged)

    @QtCore.pyqtSlot(StopWatch.State)
    def on_stateChanged(self, state):
        if state == StopWatch.RUNNING:
            self.stacked_buttons.setCurrentIndex(1)
        elif state == StopWatch.PAUSE:
            self.stacked_buttons.setCurrentIndex(2)
        elif state == StopWatch.STOPPED:
            self.stacked_buttons.setCurrentIndex(0)

if __name__ == '__main__':
    import sys
    app = QtWidgets.QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())