Verständnis der Python-Timer-Klasse mit Beispielen

Python verfügt über Tausende von Modulen und Bibliotheken, um die Anforderungen des Programmierers zu erfüllen. Um sie jedoch nützlich zu machen, müssen Sie sie zuerst verstehen und dann anwenden. Ohne die Vorkenntnisse bestimmter Module ist es ungewiss, was Sie tun möchten und was das Modul tatsächlich tut. Zeit ist einer der wichtigsten Faktoren bei Codierungsproblemen. Alle Codes sollen die menschliche Arbeit reduzieren, indem sie ihre leistungsstarken Algorithmen verwenden. Zeitmanagement hat einen großen Einfluss auf die Analyse der Leistung Ihres Codes. Deshalb werden wir heute ausführlich erfahren, wie der Timer in Python funktioniert.

Python Timer ist eine Klasse / Bibliothek zur Verwaltung der Zeitkomplexität Ihres Codes. Mit mehreren Zeitmodulen können Sie ein System in Ihrem Code erstellen, um die Zeit zu überprüfen, die das jeweilige Code-Snippet benötigt. Es gibt verschiedene Arten von Timer-Implementierungen in Python, je nach Benutzeranforderungen, nämlich die Python-Timer-Funktion (zum Überprüfen der Skriptausführungszeit), den Python-Threading-Timer (zum Überprüfen der Zeit, die ein Thread zum Beenden benötigt), den Python-Countdown-Timer (Erstellen Sie einen Countdown-Timer) und das grundlegende Python-Zeitmodul (um bei anderen Aktivitäten zu helfen).

Alle diese Timer-Implementierungen funktionieren unterschiedlich und konzentrieren sich darauf, dem Endbenutzer eine andere Verwendung zu bieten. In diesem Beitrag werden wir jede Timer-Implementierung im Detail durchgehen. Sie können das Inhaltsverzeichnis verwenden, um zur jeweiligen Python-Timer-Implementierung zu springen.

Grundlegende Python-Timer-Funktionen

Das wichtigste Modul in Python in Bezug auf die Zeit ist die Zeit. Dieses Modul enthält alle grundlegenden Funktionen, um die Zeit zu überprüfen und zu analysieren. Diese Analyse hilft Ihnen, die Leistung Ihres Codes und seine Effizienz zu verstehen. Wir werden jede der wichtigen Funktionen dieses Moduls zusammen mit seinen Beispielen durchgehen.

Im Folgenden finden Sie die grundlegenden Python-Timer-Funktionen, die das Zeitmodul verwenden –

• zeit.zeit()
• Zeit.thread_time()
• Zeit.process_time()
• Zeit.perf_counter()
• Zeit.monoton()

Funktion zeit.time

time.time() gibt die Zeit in Sekunden (float) nach der Epoche zurück. Allgemein, Die Epoche ist auf Januar eingestellt 1, 1970, 00:00:00 ( UTC), und die Anzahl der Sekunden nach dieser Epoche wird zurückgegeben. Diese Funktion hängt von der Computerzeit ab, um die Anzahl der Sekunden zu berechnen. Wenn Sie die Computerzeit zwischen der Python-Ausführung ändern, können Sie mit dieser Funktion seltsame Zahlen erhalten.

Beispiel –

import timestart = time.time() #start timefor i in range(1000000): passend = time.time()print("Elapsed time is {}".format(end-start))

Erklärung –

Zunächst beginnen wir mit dem Import des Zeitmoduls. Dieses Modul enthält alle grundlegenden Zeitfunktionen, die wir in diesem Abschnitt verwenden werden. Am Anfang des Codes deklarieren wir die Startvariable als time.time() . Dadurch wird die aktuelle CPU-Zeit in Float-Nummer aus der Epoche gespeichert. Wir verwenden diese Startvariable als Referenzpunkt, um die Zeit zu messen. Der nächste Teil enthält alle Codes, die Sie verwenden möchten (In diesem Beispiel haben wir eine for-Schleife verwendet). Notieren Sie auf ähnliche Weise die Endzeit der CPU (Standardzeit) und überprüfen Sie die Gesamtausführungszeit mithilfe von end – start .

Dadurch wird die vom Code benötigte Zeit in Sekunden gedruckt. Mit dieser Technik können Sie die Zeit überprüfen, die Ihr Code benötigt. Das einzige Problem bei dieser Methode ist, dass die CPU-Zeit geändert werden kann, während der Code ausgeführt wird. Dies führt zu problematischem Verhalten im Python-Timer.

Funktion zeit.Thread_time

time.thread_time() gibt die Summe aus System- und CPU-Zeit (float) im aktuell laufenden Thread zurück. Darüber hinaus enthält es nicht die Zeit, die Sie in der Funktion time.sleep() verbringen. Da die Funktion thread-spezifisch ist, können Sie mit dieser Funktion die Zeitdifferenzen aufzeichnen, solange die Zeitreferenzen zum selben Thread gehören.

Beispiel –

import timeimport threadingend = Nonestart = Nonedef hello(): global start, end start = time.thread_time() x = 0 while x < 10000000: pass x += 1 end = time.thread_time()t = threading.Thread(target = hello, args = ())t.start() t.join()print("The time spent is {}".format(end - start))

Erklärung –

Da thread_time die threadspezifische Zeit zurückgibt, müssen wir sicherstellen, dass Referenzen im selben Thread verwendet werden. Zu diesem Zweck haben wir den Thread der Funktion ‚hello‘ instanziiert und die Zeit berechnet, die der Thread darin benötigt. Stellen Sie jedoch sicher, dass Sie die aktuelle Zeit nicht abrufen können, indem Sie thread_time() aufrufen, da es einen Bruchwert zurückgibt. Sie können jedoch definitiv den Unterschied zwischen zwei aufeinanderfolgenden Referenzen überprüfen, solange sie in denselben Thread gehören.

Funktion zeit.Process_time

time.process_time() gibt die Zeitreferenz in Sekundenbruchteilen (Float) der Summe aus Systemzeit und CPU-Zeit des aktuellen Fortschritts zurück. Wie thread_time misst diese Funktion nicht die in der Funktion time.sleep() verbrachte Zeit. Darüber hinaus erstellt diese Funktion eine Referenz basierend auf dem Prozess. Infolgedessen ist nur der Zeitunterschied zwischen zwei aufeinanderfolgenden Referenzen sinnvoll.

Beispiel –

from time import process_time, sleepiterations = 100000start = process_time() for i in range(iterations): print(i, end=" ") # Stop the stopwatch / counter end = process_time()print(end, start)print("Elapsed time in seconds:", end-start)

Erklärung –

Wir beginnen mit dem Import der Funktion process_time und zeichnen die Start- und Endzeit zwischen dem Code auf. Der einzige Unterschied zwischen Legacy time.time() und time.proces_time() besteht darin, dass die Verarbeitungszeit die Zeitreferenzen des aktuellen Prozesses aufzeichnet, während time() die absolute Zeit des Systems aufzeichnet.

Funktion zeit.Perf_counter

Perf Counter steht für Performance Counter. Diese Funktion gibt den hochauflösenden Wert der Zeit zurück, der für einen kurzen Zeitraum gültig ist. Diese Funktion wird verwendet, um die genaue Zeitzählung zwischen zwei Referenzen zu erhalten. Da andere Python-Timer-Funktionen keine Ruhezeit enthalten, enthält perf_counter diese ebenfalls nicht. Gehen wir zu einem Beispiel –

Beispiel –

from time import perf_counter, sleep # integer input from user, 2 input in single linen = 3 # Start the stopwatch / counter start = perf_counter() for i in range(n): sleep(1)end = perf_counter() print("Elapsed time in seconds:", end-start) 

Erklärung –

Sie können den Perf-Zähler auf die gleiche Weise wie den Prozess- oder Thread-Timer verwenden. Der einzige Unterschied besteht darin, dass der Perf-Zähler einen hochpräzisen Wert der verstrichenen Zeit zurückgibt. Stellen Sie jedoch sicher, dass Sie dies zwischen kleinen Prozessen verwenden, da es eine hohe Präzision verwendet. Wir haben eine einfache Schleife verwendet, um die benötigte Zeit zu überprüfen.

Funktion zeit.monotonic

Monotonic ist ein Python-Timer, der nicht rückwärts gehen kann. Bei der Ausführung eines Python-Skripts kann die Zeit vom Benutzer geändert werden und kann einen großen Unterschied in der Implementierung des Timers in Python machen. Aber monotone Timer sorgt dafür, dass die Zeit, um die externen Änderungen anzupassen.

Beispiel –

from time import monotonic, sleep # integer input from user, 2 input in single linen = 3 # Start the stopwatch / counter start = monotonic() for i in range(n): sleep(1)end = monotonic() print("Elapsed time in seconds:", end-start) 

Erklärung –

Wir importieren zuerst die monotone Funktion aus dem Zeitmodul. Erstellen Sie dann zwei Referenzen mit den Namen start und end oben und unten im Code. Dadurch wird die Zeit zwischen den beiden Referenzen gemessen und alle externen Änderungen an den Systemzeiten vermieden.

Benutzerdefinierte Python-Timer-Klassen

Sie können Ihre eigene benutzerdefinierte Timer-Klasse erstellen, um die Dinge nach Ihren Wünschen zu erledigen. Ein Hauptvorteil beim Erstellen einer benutzerdefinierten Klasse besteht darin, dass Sie die gesamte Zeit in einer einzigen Zeile verwalten können. Sie müssen die Zeitklasse nicht jedes Mal importieren und die Referenzen aufzeichnen. Darüber hinaus können Sie Ihre Daten sichern und alle früheren Ausführungen aufzeichnen, um den besten Algorithmus für Sie auszuwählen.

In diesem Abschnitt wird eine benutzerdefinierte Klasse erstellt, um die Zeit zu verwalten und alle Zeitunterschiede in Ihren Codes zu protokollieren. Lassen Sie uns direkt eintauchen –

Timer.py –

Wir beginnen mit dem Import des Zeitmoduls. Initialisieren Sie dann die Python-Timer-Klasse und definieren Sie die Attribute und Methoden. Bisher haben wir nur das Basisattribut aufgenommen, um eine Startreferenz der Klasse beizubehalten. Um es komplexer zu machen, können Sie mehrere Attribute erstellen. Bisher sind drei Methoden unten aufgeführt –

1. start – (Optional) Zum Starten des Timers.
2. log – Um die aktuell verstrichene Zeit bezüglich der Startzeit zu protokollieren.
3. Meilenstein – Um den Timer zurückzusetzen und seine Zählung von 0 aus zu starten.

import timeclass Timer: def __init__(self): self.start = time.time() def start(self): self.start = time.time() def log(self): logger = time.time() - self.start print('Time log -',logger) def milestone(self): self.start = time.time()

example.py –

Beispiele für die Verwendung der obigen Klasse sind unten angegeben. Wie Sie sehen können, können Sie Ihren Code sauber halten, indem Sie eine benutzerdefinierte Timer-Klasse erstellen und die Flexibilität erhöhen.

import timertime = timer.Timer()for i in range(1000000):passp = 1time.log()for i in range(1000000):passp = 1time.log()

Ausgang –

Time log - 0.054854631423950195Time log - 0.10871052742004395

Python-Timer mit Threading

Wenn wir eine Operation ausführen möchten oder unsere Funktion nach einer bestimmten Zeit ausgeführt werden soll, verwenden wir die Python-Timer-Klasse. Die Timer-Klasse ist eine Unterklasse der Threading-Klasse. Technisch gesehen können Sie sagen, dass wir Timer-Objekte erstellen, wenn Aktionen (Funktionen) durch die Zeit begrenzt werden sollen.

Angenommen, wir möchten ein Quiz organisieren, bei dem der Teilnehmer jede Frage in 10 Sekunden beantworten muss. Hier können wir einen Timer erstellen, der im Hintergrund ausgeführt wird, und in der Zwischenzeit denkt der Teilnehmer über die Antwort nach. Lassen Sie uns nun verstehen, wie Sie ein Timer-Objekt erstellen.

Syntax der Timer-Klasse in Python

Wenn Sie nicht verstanden haben, was die Timer–Klasse tut, können Sie sich das so vorstellen – Eine Timer-Klasse ruft eine Funktion nach der angegebenen Anzahl von Sekunden auf.

Um einen Timer zu starten, müssen wir start() aufrufen(genau wie normale Threads), und um den Timer zu stoppen, während er sich noch im Hintergrund befindet, können wir cancel() aufrufen.

Um die Timer-Klasse zu verwenden, müssen wir die Threading-Klasse

threading importieren.Timer(interval, function, args=None, kwargs=None)

Parameters-

Interval – Die Zeit (in Sekunden), die Sie warten möchten, bevor Sie die nächste Funktion aufrufen. Es kann entweder in Float oder Integer sein. Zum Beispiel für 3 Sekunden, Intervall = 3.

Funktion – Die Funktion, die Sie nach dem angegebenen Zeitintervall aufrufen möchten.

Eine allgegenwärtige Möglichkeit, *args und **kwargs Parameter zu beschreiben, besteht darin, ein Timer-Objekt zu erstellen, das die Funktion mit den Argumenten ‚args‘ und den Schlüsselwortargumenten ‚kwargs‘ ausführt, nachdem einige Sekunden vergangen sind. Argumente sollten in Form einer Liste und die Schlüsselwortargumente oder Kwargs in Form eines Wörterbuchs vorliegen.

Rückgabetyp-

Es ruft nur die in den Parametern angegebene Funktion auf.

Methoden in der Timer-Klasse

1. start() – Es bedeutet den Beginn der Ausführung des Timers.
2. Cancel () – Während der Ausführung des Timers können wir cancel aufrufen, wenn wir ihn stoppen möchten ().

Erstellen eines Timer-Objekts

ein. Die Grundlagen verstehen

Um die Funktionsweise des Timer-Objekts zu verstehen, erstellen wir ein kleines Programm, das uns hilft, die Grundlagen der Klasse zu verstehen.

# Importing the Timer subclass from the threading Classfrom threading import Timer# creating a basic function that will print "hello"def hello(): print ("hello, world")# creating the object of the Timer subclass# Here, 5 sec means that the execution of the function="hello" after 5 secondst = Timer(interval=5.0, function=hello)# starting the executiont.start() # after 30 seconds, "hello, world" will be printed

Output-hello, world

Sie werden die Funktionsweise des obigen Programms besser verstehen, wenn Sie versuchen, es auf Ihrem eigenen System auszuführen.

b. Verwenden der cancel-Methode

Lassen Sie uns sehen, wie Sie die cancel() -Funktion der Timer-Klasse verwenden.

# Importing the Timer subclass from the threading Classfrom threading import Timer# creating a basic function that will print "hello"def hello(): print ("hello world") # creating the object of the Timer subclass# Here, 5 sec means that the execution of the function="hello" after 5 secondst = Timer(interval=5.0, function=hello) # starting the executiont.start() # after 30 seconds, "hello, world" will be printedprint("Execution begins")# cancelling the execution of the 'hello' functiont.cancel()print("END")

Execution begins END

c. Verwendung des Parameters ‚args‘ der Python-Timer-Klasse

Wenn wir die Argumente für die Funktion angeben müssen, die aufgerufen werden muss, verwenden wir den Parameter args. Wir müssen das Argument args in einem Array angeben.

import threading# To take multiple inputs we can use *before the parameter.def print_name(*names): # From the array of names pick one name and print it for name in names: print("Hello",name)# In the args parameter, give an array of names t = threading.Timer(3, print_name,)# start the executiont.start()print("Execution begins...")

Execution begins...Hello AshwiniHello VandyHello Arijit

Nun, da wir viel über die Zeit gesprochen haben, lassen Sie uns als Bonus ein Programm erstellen, das als Countdown-Timer fungiert.

Countdown-Timer in Python

Mit dem Zeitmodul

# We will use the time moduleimport time# Create a function that will print the timedef create_countdown_timer(time): print(time,"......")time_in_sec=int(input("Please entert the time in seconds:"))for times in range(time_in_sec): # call the function and pass the current time left create_countdown_timer(time_in_sec-times) # call the function in every 1 second. time.sleep(1) print("Time is up")

Please entert the time in seconds:77 ......6 ......5 ......4 ......3 ......2 ......1 ......Time is up

Verwenden der Python-Timer-Klasse

# We will use the time moduleimport timefrom threading import Timer# Create a function that will print the timedef create_countdown_timer(time): print(time,"......")# Here you have to enter the time for which the timer will runtime_in_sec=int(input("Please enter the time in seconds:"))# For the first time we will call the function manuallycreate_countdown_timer(time_in_sec) for times in range(1,time_in_sec): # calling the Timer class every second t = Timer(1,create_countdown_timer,) t.start() time.sleep(1) print("\n Time is up") 

Please entert the time in seconds:1010 ......9 ......8 ......7 ......6 ......5 ......4 ......3 ......2 ......1 ......Time is up

Python-Timer als Kontextmanager

Kontextmanager sind die besten Möglichkeiten, um Speicherfehler und nachfolgende Abstürze zu vermeiden. Jeder muss von „with“ der Anweisung in Python gewusst haben. Diese Anweisung stellt sicher, dass wir uns nicht um viele Objekte kümmern müssen, um sie unabhängig voneinander zu schließen. Jeder könnte es mit der Kombination von with und open() Funktion verwendet haben. Um zur Hauptfrage zu gelangen, können wir Kontextmanager für Python-Timer erstellen?

Ja. Aufgrund mehrerer Überladungsfunktionen können wir in wenigen Zeilen problemlos einen eigenen Python-Timer als Kontextmanager erstellen. Beginnen wir mit einem Beispiel, in dem Sie die Laufzeit des Programms messen müssen. Ohne alle Variablen neu zu definieren, kann ein Kontextmanager wiederholt verwendet werden, um die Zeit mehrmals zu messen. Das folgende Programm demonstriert es.

Beispiel –

import timeclass Timer_Pythonpool(): """ Context manager as a python timer """ def __init__(self): self.start = None def __enter__(self): """ Notes the time at the start of the iteration """ self.start = time.time() return self def __exit__(self, exc_type, exc_value, exc_traceback): """ Prints the time taken at the end of the iteration """ print("Time to finish the task: ", time.time()-self.start) with Timer_Pythonpool() as timer: for i in range(1000000): x = 0 pass

Ausgang –

Time to finish the task: 0.05392050743103027

Erklärung –

Wir erstellen zunächst eine Klasse mit dem Namen „Timer_Pythonpool.“ Dann passen wir die Operatoren an, um sie als Kontextmanager nützlich zu machen. _Die Funktion _enter__ wird am Anfang des Kontexts ausgeführt, und __exit__ wird am Ende des Kontexts ausgeführt. Wenn Sie einen Referenzpunkt zwischen diesen beiden Funktionen erstellen, erhalten Sie die genaue Zeit, die der Kontext für die Ausführung benötigt.

Python Timer Decorators

Decorators sind die zusätzliche Unterstützung für jede Art von Funktion. Auch als Metaprogrammierung bezeichnet, können Sie Funktionen ändern / hinzufügen. Python-Timer-Dekorateure sind der einfachste Weg, die Timer-Funktionen in Python zu implementieren. Einmal deklariert, können Sie die Dekorateure in einer Zeile verwenden, ohne sie zu kennen. Darüber hinaus können Sie sie auf jede Funktion in Ihrem Code anwenden, um zu überprüfen, welcher Code die meiste Zeit für die Ausführung benötigt.

Syntax –

Um einen Verkettungsdekorator zu erstellen, müssen Sie mehrere verschachtelte Funktionen deklarieren. Benennen Sie die andere Funktion als Ihren Hauptdekoratornamen und fügen Sie sie einem beliebigen zufälligen Namen hinzu. Die innere Funktion ruft die Referenz der Funktion ab, die unter dem Dekorateur verwendet wird.

Beispiel –

import timedef check_time(func): def inner(*args, **kwargs): start = time.time() func(*args, **kwargs) end = time.time() print("Time taken to execute function is ", end-start) return inner@check_timedef task(): # do something for i in range(10000000): x = 0 passtask()

Ausgang –

Time taken to execute function is 0.24933218955993652

Erklärung –

Wie üblich beginnen wir mit dem Import des wichtigsten Moduls aus Python „time.“ Als nächstes erstellen wir einen Dekorateur mit dem Namen „check_time.“ Darin fügen wir eine verschachtelte innere Funktion hinzu, in der wir die Zeitreferenzen erstellen können. Diese beiden Referenzen werden so platziert, dass beide zwischen der Funktionsausführung platziert werden.

Außerdem erstellen wir eine Testfunktion mit dem Namen „task“, um zu überprüfen, ob unsere Aufgabe funktioniert. Fügen Sie dann einen Dekorateur hinzu. Jetzt wird der Dekorateur seine Magie tun und die Zeit drucken, die die Funktion benötigt.

Python Timer Cooldown

Python Timer Cooldown ist eine Möglichkeit, den Timer rückwärts zu messen. Durch Erstellen einer benutzerdefinierten Timer-Klasse können wir die Zeit an jedem Punkt Ihres Codes protokollieren. Sie können diese Klasse als Modul exportieren und als Abhängigkeit in Ihrem Code installieren. Dann können Sie es mit einer einzigen Zeile importieren –

import timeclass Timer: """ Timer class """ def __init__(self): self.start = time.time() ''' Restarts the timer. ''' def restart(self): self.start = time.time() ''' Returns the time elapsed and resets the counter. ''' def get_new_time(self): value = time.time() - self.start self.restart() return value ''' Prints the time elapsed and resets the counter. ''' def print_new_time(self): print (self.get_new_time()) ''' Returns the time elapsed (Does not reset the counter). ''' def get_time(self): return time.time() - self.start self.restart() ''' Prints the time elapsed (Does not reset the counter). ''' def print_time(self): print(self.get_time()) ''' Returns the time elapsed in HH:mm:ss (Does not reset the counter). ''' def get_time_hhmmss(self): end = time.time() m, s = divmod(end - self.start, 60) h, m = divmod(m, 60) time_str = "%02d:%02d:%02d" % (h, m, s) return time_strtimer = Timer() #Initialize the timer#wash clothes for 5 secondstimer.print_time() #Print the time elapsed since Initialization (in seconds)#dry clothes for 3 secondstimer.print_new_time() #Print the time elapsed since Initialization and reset the timer#burn clothes for 10 secondsprint(str('Task done for ' + str(timer.get_time()) + ' seconds.'))

Andere Python-Timer-Module

Python enthält Tausende von Modulen und Millionen von Codeausschnitten. Wir können immer die Open-Source-Module verwenden, um Python-Timer zu verwenden. Github ist der größte Ort, um solche Module zu finden. Lassen Sie uns direkt in diese Module springen –

1. termdown: Ein fortgeschrittener Python-Timer, der mit verschiedenen ASCII-Zeichen erstellt wurde. Mit diesem Skript können Sie einen einfachen Countdown-Timer in Ihrem Terminal erstellen und am Ende einen Befehl ausführen. Am wichtigsten ist, hat es Unterstützung für Voice-Countdown.
2. MobTimer.Python: Ein GUI-basierter Timer in Python. Dieses Skript erstellt Vollbild-basierte Timer mit mehreren Optionen. Mit diesem Programm können Sie mehrere Timer gleichzeitig auf Ihrem Bildschirm ausführen.
3. Timer: Dies ist der einfachste GUI-basierte Timer in Python (Tkinter). Funktionen wie mehrere Timer, Beschriftungen und Multithreading machen es gegenüber anderen Programmen rentabler.
4. codetiming: Diese Timer-Klasse zeichnet alle Ihre letzten Ausführungszeiten für einen bestimmten benannten Prozess auf. Sie können die minimale Zeit, maximale Zeit, Zwischenzeit und mittlere Zeit für den spezifischen Prozess zusammen mit Datensätzen überprüfen. Dieses Modul kann auf verschiedene Arten verwendet werden, nämlich als Kontextmanager und als Dekorator.
5. cTimer: cTime ist ein Nanosekunden-Präzisions-Timer in Python. Dieses Modul verwendet die C-Sprach-API, um die Zeit genau aufzuzeichnen. Wenn Sie nach einem Hardcore-Präzisionszeiterfassungsmodul suchen, ist dies das Beste. (Hinweis: In den letzten Updates von Python wurde das Zeitmodul mit Funktionen zur Aufzeichnung der Zeit in Nanosekunden hinzugefügt)

Muss lesen:

• Konvertieren von Zeichenfolgen in Kleinbuchstaben in
• Berechnen der Quadratwurzel
• Benutzereingabe / Input () -Funktion | Tastatureingabe
• Bestes Buch zum Erlernen von Python

Fazit

Meistens verwendet jeder Timer für drei Zwecke. Die erste besteht darin, die Zeit für die Ausführung Ihres Codes aufzuzeichnen. Und zweitens, um mithilfe eines Timers eine Erinnerung für etwas hinzuzufügen. Glücklicherweise können beide in Python erstellt werden. Durch die Verwendung verschiedener Module und Bibliotheken können Sie sicherstellen, dass Sie die Zeit punktgenau aufzeichnen.

Last but not least ist der Timer eine Unterklasse der Threading-Klasse in Python. Wenn wir eine Funktion nach einem bestimmten Zeitintervall ausführen möchten, können wir die Python-Timer-Klasse verwenden. Im Parameter args , der standardmäßig None ist, können wir die Argumente angeben, die wir der Callback-Methode geben möchten.

Versuchen Sie, die Programme auf Ihrer Seite auszuführen, und lassen Sie uns wissen, wenn Sie Fragen haben.