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

В вашем фрагменте:

def __update(self):
    now = time.clock()
    diff = now - self.__start
    self.__start = now
    self.__total += diff
    mins,secs=divmod(self.__total,60)
    self.__time.set('{:02.0f}:{:02.0f}'.format(mins,secs))
    self.start_dt.set(datetime.datetime.now().strftime("%H:%M %m/%d/%Y"))
    self.__counter = self.after_idle(self.__update)

Функция перезапускается на холостом ходу без каких-либо ограничений. Это означает, что ваш процессор будет тратить каждый момент простоя, чтобы обновить время. Это приведет к загрузке процессора почти на 100%. Поскольку он использует только одно из четырех ядер, вы увидите свои (почти) 25%.

Просто используйте "умный", переменный цикл while; принцип

Если бы мы использовали time.sleep(), поскольку мы не используем реальное время процессора, у нас будет небольшое отклонение. Процессору всегда нужно немного времени для обработки команды, поэтому

time.sleep(1)

на самом деле будет что-то вроде

time.sleep(1.003)

Это, без дальнейших действий, приведет к накоплению отклонения, однако:

Мы можем сделать процесс умным. В настольных приложениях я всегда выполняю калибровку sleep() через каждую секунду или минуту, в зависимости от требуемой точности. То, что цикл использует как время для обработки, отводится от следующего цикла, поэтому накопление отклонений никогда не происходит.

В принципе:

import time

seconds = 0 # starttime (displayed)
startt = time.time() # real starttime
print("seconds:", seconds)

wait = 1

while True:
    time.sleep(wait)
    seconds = seconds + 1 # displayed time (seconds)
    target = startt + seconds # the targeted time
    real = time.time() # the "real" time
    calibration = real - target # now fix the difference between real and targeted
    nextwait = 1 - calibration # ...and retract that from the sleep of 1 sec
    wait = nextwait if nextwait >= 0 else 1  # prevent errors in extreme situation
    print("correction:", calibration)
    print("seconds:", seconds)

Поскольку вы используете секунды как единое целое, этого достаточно. Дополнительное бремя: неизмеримо.

Запустив этот фрагмент в терминале, вы увидите отображаемое время и фиксированное отклонение:

seconds: 0
correction: 0.02682352066040039
seconds: 1
correction: 0.036485910415649414
seconds: 2
correction: 0.06434035301208496
seconds: 3
correction: 0.07763338088989258
seconds: 4
correction: 0.037987709045410156
seconds: 5
correction: 0.03364992141723633
seconds: 6
correction: 0.07647705078125
seconds: 7

Использование after() вместо while?

Аналогично, вы можете использовать метод Tkinters after(), как описано здесь, используя тот же трюк с переменным временем для калибровки.

РЕДАКТИРОВАТЬ

По запросу: пример использования метода Tkinter after()

Если вы используете фиксированное время цикла, вы:

1. Это неизбежно приводит к потере ресурсов, поскольку время цикла (разрешение по времени) должно составлять небольшую часть отображаемой единицы времени.
2. Даже если вы сделаете это, как и ваши 200 мс, отображаемое время будет время от времени показывать разницу с реальным временем (почти) 200 мс, после чего последует слишком короткий переход к следующей отображаемой секунде.

Если вы используете after() и хотите использовать переменный временной цикл, как в приведенном выше примере без графического интерфейса ниже примера, предлагающего те же параметры, что и фрагмент кода в вашем ответе:

#!/usr/bin/env python3
from tkinter import *
import time

class TestWhile:

    def __init__(self):

        # state on startup, run or not, initial wait etc
        self.run = False
        self.showtime = 0
        self.wait = 1000
        # window stuff
        self.window = Tk()
        shape = Canvas(width=200, height=0).grid(column=0, row=0)
        self.showtext = Label(text="00:00:00", font=(None, 26))
        self.showtext.grid(column=0, row=1)
        self.window.minsize(width=200, height=50)
        self.window.title("Test 123(4)")
        # toggle button Run/Stop
        self.togglebutton = Button(text="Start", command = self.toggle_run)
        self.togglebutton.grid(column=0, row=2, sticky=NSEW, padx=5, pady=5)
        self.resetbutton = Button(text="reset", command = self.reset)
        self.resetbutton.grid(column=0, row=3, sticky=NSEW, padx=5, pady=5)
        self.window.mainloop()

    def format_seconds(self, seconds):
        mins, secs = divmod(seconds, 60)
        hrs, mins = divmod(mins, 60)
        return '{:02d}:{:02d}:{:02d}'.format(hrs, mins, secs)

    def reset(self):
        self.showtime = 0
        self.showtext.configure(text="00:00:00")

    def toggle_run(self):
        # toggle run
        if self.run:
            self.run = False
            self.togglebutton.configure(text="Run")
            self.showtime = self.showtime - 1
            self.resetbutton.configure(state=NORMAL)
        else:
            self.run = True
            self.togglebutton.configure(text="Stop")
            self.resetbutton.configure(state=DISABLED)
            # prepare loop, set values etc
            self.showtext.configure(text=self.format_seconds(self.showtime))
            self.fix = self.showtime
            self.starttime = time.time()
            # Let's set the first cycle to one second
            self.window.after(self.wait, self.fakewhile)

    def update(self):
        self.window.after(self.wait, self.fakewhile)
        self.showtext.configure(text=str(self.format_seconds(self.showtime)))
        self.targeted_time = self.starttime + self.showtime
        self.realtime = time.time() + self.fix
        diff = self.realtime - self.targeted_time
        self.wait = int((1 - diff) * 1000)
        print("next update after:", self.wait, "ms")

    def fakewhile(self):
        self.showtime = self.showtime + 1
        if self.run:
            self.update()


TestWhile()

Заметка

... что если вы обновляете GUI из второго потока, например, в приложении Gtk, вам всегда нужно обновлять с простоя.