Python sleep (): So fügen Sie Ihrem Code Zeitverzögerungen hinzu

Mussten Sie jemals Ihr Python-Programm auf etwas warten lassen? Meistens möchten Sie, dass Ihr Code so schnell wie möglich ausgeführt wird. Aber es gibt Zeiten, in denen es in Ihrem besten Interesse ist, Ihren Code eine Weile schlafen zu lassen.

Sie können beispielsweise den Aufruf von Pythonsleep()verwenden, um eine Verzögerung in Ihrem Programm zu simulieren. Möglicherweise müssen Sie warten, bis eine Datei hochgeladen oder heruntergeladen oder eine Grafik geladen oder auf den Bildschirm gezeichnet wurde. Möglicherweise müssen Sie sogar zwischen Aufrufen einer Web-API oder zwischen Abfragen einer Datenbank eine Pause einlegen. Das Hinzufügen von Pythonsleep()-Aufrufen zu Ihrem Programm kann in jedem dieser und vielen weiteren Fällen hilfreich sein!

In diesem Tutorial erfahren Sie, wie Sie Pythonsleep()-Aufrufe hinzufügen mit:

time.sleep()
Dekorateure
Themen
Async IO
Grafische Benutzeroberflächen

Dieser Artikel richtet sich an fortgeschrittene Entwickler, die ihr Python-Wissen erweitern möchten. Wenn das nach dir klingt, dann lass uns anfangen!

Free Bonus:Get our free "The Power of Python Decorators" guide, das Ihnen 3 erweiterte Dekorationsmuster und -techniken zeigt, mit denen Sie in sauberere und pythonischere Programme schreiben können.

Hinzufügen eines Python`sleep()`-Aufrufs mit`time.sleep()`

Python verfügt über eine integrierte Unterstützung, um Ihr Programm in den Ruhezustand zu versetzen. Das Modultime verfügt über eine Funktionsleep(), mit der Sie die Ausführung des aufrufenden Threads für die von Ihnen angegebenen Sekunden anhalten können.

Hier ist ein Beispiel für die Verwendung vontime.sleep():

>>>

>>> import time
>>> time.sleep(3) # Sleep for 3 seconds

Wenn Sie diesen Code in Ihrer Konsole ausführen, sollte es zu einer Verzögerung kommen, bevor Sie eine neue Anweisung in die REPL eingeben können.

Note: In Python 3.5 haben die Kernentwickler das Verhalten vontime.sleep() geringfügig geändert. Der Systemaufruf des neuen Pythonsleep()dauert mindestens die von Ihnen angegebene Anzahl von Sekunden, selbst wenn der Ruhezustand durch ein Signal unterbrochen wird. Dies gilt jedoch nicht, wenn das Signal selbst eine Ausnahme auslöst.

Sie können testen, wie lange der Schlaf dauert, indem Sie dastimeit-Modul von Python verwenden:

$ python3 -m timeit -n 3 "import time; time.sleep(3)"
3 loops, best of 3: 3 sec per loop

Hier führen Sie das Modultimeit mit dem Parameter-n aus, dertimeit angibt, wie oft die folgende Anweisung ausgeführt werden soll. Sie können sehen, dasstimeit die Anweisung dreimal ausgeführt hat und dass die beste Laufzeit 3 Sekunden betrug, was erwartet wurde.

Die Standardanzahl, mit dertimeit Ihren Code ausführt, beträgt eine Million. Wenn Sie den obigen Code mit dem Standardwert-n ausführen würden, würde Ihr Terminal bei 3 Sekunden pro Iteration ungefähr 34 Tage lang hängen bleiben! Das Modultimeit verfügt über mehrere andere Befehlszeilenoptionen, die Sie indocumentation überprüfen können.

Lassen Sie uns etwas Realistischeres schaffen. Ein Systemadministrator muss wissen, wann eine seiner Websites ausfällt. Sie möchten den Statuscode der Website regelmäßig überprüfen können, können den Webserver jedoch nicht ständig abfragen, da dies die Leistung beeinträchtigt. Eine Möglichkeit, diese Überprüfung durchzuführen, besteht darin, den Systemaufruf von Pythonsleep()zu verwenden:

import time
import urllib.request
import urllib.error

def uptime_bot(url):
    while True:
        try:
            conn = urllib.request.urlopen(url)
        except urllib.error.HTTPError as e:
            # Email admin / log
            print(f'HTTPError: {e.code} for {url}')
        except urllib.error.URLError as e:
            # Email admin / log
            print(f'URLError: {e.code} for {url}')
        else:
            # Website is up
            print(f'{url} is up')
        time.sleep(60)

if __name__ == '__main__':
    url = 'http://www.google.com/py'
    uptime_bot(url)

Hier erstellen Sieuptime_bot(), dessen Argument eine URL ist. Die Funktion versucht dann, diese URL miturllib zu öffnen. WennHTTPError oderURLError vorhanden sind, fängt das Programm diese ab und druckt den Fehler aus. (In einer Live-Umgebung würden Sie den Fehler protokollieren und wahrscheinlich eine E-Mail an den Webmaster oder Systemadministrator senden.)

Wenn keine Fehler auftreten, druckt Ihr Code aus, dass alles in Ordnung ist. Unabhängig davon, was passiert, wird Ihr Programm 60 Sekunden lang in den Ruhezustand versetzt. Dies bedeutet, dass Sie nur einmal pro Minute auf die Website zugreifen. Die in diesem Beispiel verwendete URL ist fehlerhaft und gibt daher einmal pro Minute Folgendes an Ihre Konsole aus:

HTTPError: 404 for http://www.google.com/py

Aktualisieren Sie den Code, um eine bekanntermaßen gute URL wiehttp://www.google.com zu verwenden. Anschließend können Sie es erneut ausführen, um zu sehen, ob es erfolgreich funktioniert. Sie können auch versuchen, den Code zu aktualisieren, um eine E-Mail zu senden oder die Fehler zu protokollieren. Weitere Informationen dazu finden Sie unterSending Emails With Python undLogging in Python.

Hinzufügen eines Python`sleep()`-Aufrufs mit Dekorateuren

Es gibt Zeiten, in denen Sie eine fehlgeschlagene Funktion erneut versuchen müssen. Ein beliebter Anwendungsfall hierfür ist, wenn Sie einen Dateidownload erneut versuchen müssen, weil der Server ausgelastet war. Normalerweise möchten Sie nicht zu oft eine Anfrage an den Server stellen. Daher ist es wünschenswert, zwischen jeder Anfrage einen Pythonsleep()-Aufruf hinzuzufügen.

Ein weiterer Anwendungsfall, den ich persönlich erlebt habe, ist der, bei dem ich den Status einer Benutzeroberfläche während eines automatisierten Tests überprüfen muss. Die Benutzeroberfläche wird möglicherweise schneller oder langsamer als gewöhnlich geladen, je nachdem, auf welchem Computer ich den Test ausführe. Dies kann die Anzeige auf dem Bildschirm ändern, wenn mein Programm etwas überprüft.

In diesem Fall kann ich dem Programm sagen, dass es einen Moment schlafen soll und dann ein oder zwei Sekunden später erneut prüfen soll. Dies kann den Unterschied zwischen einem bestandenen und einem nicht bestandenen Test bedeuten.

In beiden Fällen können Siedecorator verwenden, um einen Pythonsleep()-Systemaufruf hinzuzufügen. Wenn Sie mit Dekorateuren nicht vertraut sind oder sie auffrischen möchten, lesen SiePrimer on Python Decorators. Schauen wir uns ein Beispiel an:

import time
import urllib.request
import urllib.error

def sleep(timeout, retry=3):
    def the_real_decorator(function):
        def wrapper(*args, **kwargs):
            retries = 0
            while retries < retry:
                try:
                    value = function(*args, **kwargs)
                    if value is None:
                        return
                except:
                    print(f'Sleeping for {timeout} seconds')
                    time.sleep(timeout)
                    retries += 1
        return wrapper
    return the_real_decorator

sleep() ist dein Dekorateur. Es akzeptiert einentimeout-Wert und die Häufigkeit, mit derretry verwendet werden soll, standardmäßig 3. Innerhalb vonsleep() befindet sich eine weitere Funktion,the_real_decorator(), die die dekorierte Funktion akzeptiert.

Schließlich akzeptiert die innerste Funktionwrapper() die Argumente und Schlüsselwortargumente, die Sie an die dekorierte Funktion übergeben. Hier passiert die Magie! Sie verwenden einewhile-Schleife, um den Aufruf der Funktion erneut zu versuchen. Wenn es eine Ausnahme gibt, rufen Sietime.sleep() auf, erhöhen denretries-Zähler und versuchen erneut, die Funktion auszuführen.

Schreiben Sie nunuptime_bot() neu, um Ihren neuen Dekorateur zu verwenden:

@sleep(3)
def uptime_bot(url):
    try:
        conn = urllib.request.urlopen(url)
    except urllib.error.HTTPError as e:
        # Email admin / log
        print(f'HTTPError: {e.code} for {url}')
        # Re-raise the exception for the decorator
        raise urllib.error.HTTPError
    except urllib.error.URLError as e:
        # Email admin / log
        print(f'URLError: {e.code} for {url}')
        # Re-raise the exception for the decorator
        raise urllib.error.URLError
    else:
        # Website is up
        print(f'{url} is up')

if __name__ == '__main__':
    url = 'http://www.google.com/py'
    uptime_bot(url)

Hier dekorieren Sieuptime_bot() mit einemsleep() von 3 Sekunden. Sie haben auch die ursprünglichewhile-Schleife sowie den alten Aufruf vonsleep(60) entfernt. Der Dekorateur kümmert sich jetzt darum.

Eine weitere Änderung, die Sie vorgenommen haben, besteht darin, einraiseinnerhalb der Ausnahmebehandlungsblöcke hinzuzufügen. Dies ist so, dass der Dekorateur richtig funktioniert. Sie könnten dem Dekorateur schreiben, um diese Fehler zu behandeln. Da diese Ausnahmen jedoch nur fürurllib gelten, ist es möglicherweise besser, den Dekorateur so zu belassen, wie er ist. Auf diese Weise funktioniert es mit einer größeren Vielfalt von Funktionen.

Note: Wenn Sie die Ausnahmebehandlung in Python auffrischen möchten, lesen SiePython Exceptions: An Introduction.

Es gibt einige Verbesserungen, die Sie an Ihrem Dekorateur vornehmen können. Wenn die Wiederholungsversuche nicht mehr ausgeführt werden und dennoch fehlschlagen, kann der letzte Fehler erneut ausgelöst werden. Der Dekorateur wartet auch 3 Sekunden nach dem letzten Fehler, was möglicherweise nicht der Fall sein soll. Probieren Sie diese als Übung aus!

Hinzufügen eines Python`sleep()`-Aufrufs mit Threads

Es gibt auch Zeiten, in denen Sie einen Pythonsleep()-Aufruf zu einemthread hinzufügen möchten. Möglicherweise führen Sie ein Migrationsskript für eine Datenbank mit Millionen von Datensätzen in der Produktion aus. Sie möchten keine Ausfallzeiten verursachen, aber Sie möchten auch nicht länger als nötig warten, um die Migration abzuschließen. Daher entscheiden Sie sich für die Verwendung von Threads.

Note: Threads sind eine Methode, umconcurrency in Python auszuführen. Sie können mehrere Threads gleichzeitig ausführen, um den Durchsatz Ihrer Anwendung zu erhöhen. Wenn Sie mit Threads in Python nicht vertraut sind, lesen SieAn Intro to Threading in Python.

Um zu verhindern, dass Kunden eine Verlangsamung bemerken, muss jeder Thread für eine kurze Zeit ausgeführt werden und dann in den Ruhezustand versetzt werden. Hierfür gibt es zwei Möglichkeiten:

Verwenden Sietime.sleep() wie zuvor.
Verwenden SieEvent.wait() aus dem Modulthreading.

Betrachten wir zunächsttime.sleep().

Verwenden von`time.sleep()`

Das PythonLogging Cookbook zeigt ein schönes Beispiel, dastime.sleep() verwendet. Daslogging-Modul von Python ist threadsicher, daher ist es für diese Übung etwas nützlicher als dieprint()-Anweisungen. Der folgende Code basiert auf diesem Beispiel:

import logging
import threading
import time

def worker(arg):
    while not arg["stop"]:
        logging.debug("worker thread checking in")
        time.sleep(1)

def main():
    logging.basicConfig(
        level=logging.DEBUG,
        format="%(relativeCreated)6d %(threadName)s %(message)s"
    )
    info = {"stop": False}
    thread = threading.Thread(target=worker, args=(info,))
    thread_two = threading.Thread(target=worker, args=(info,))
    thread.start()
    thread_two.start()

    while True:
        try:
            logging.debug("Checking in from main thread")
            time.sleep(0.75)
        except KeyboardInterrupt:
            info["stop"] = True
            logging.debug('Stopping')
            break
    thread.join()
    thread_two.join()

if __name__ == "__main__":
    main()

Hier verwenden Sie dasthreading-Modul von Python, um zwei Threads zu erstellen. Sie erstellen auch ein Protokollierungsobjekt, das diethreadName in stdout protokolliert. Als Nächstes starten Sie beide Threads und initiieren von Zeit zu Zeit eine Schleife, um vom Hauptthread aus zu protokollieren. Sie verwendenKeyboardInterrupt, um den Benutzer beim Drücken vonCtrl+[.kbd .key-c]#C # zu erwischen.

Versuchen Sie, den obigen Code in Ihrem Terminal auszuführen. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

 0 Thread-1 worker thread checking in
 1 Thread-2 worker thread checking in
 1 MainThread Checking in from main thread
752 MainThread Checking in from main thread
1001 Thread-1 worker thread checking in
1001 Thread-2 worker thread checking in
1502 MainThread Checking in from main thread
2003 Thread-1 worker thread checking in
2003 Thread-2 worker thread checking in
2253 MainThread Checking in from main thread
3005 Thread-1 worker thread checking in
3005 MainThread Checking in from main thread
3005 Thread-2 worker thread checking in

Während jeder Thread ausgeführt wird und dann in den Ruhezustand wechselt, wird die Protokollausgabe auf der Konsole gedruckt. Nachdem Sie ein Beispiel ausprobiert haben, können Sie diese Konzepte in Ihrem eigenen Code verwenden.

Verwenden von`Event.wait()`

Das Modulthreading bietetEvent(), die Sie wietime.sleep() verwenden können. Event() hat jedoch den zusätzlichen Vorteil, dass es schneller reagiert. Der Grund dafür ist, dass das Programm beim Setzen des Ereignisses sofort aus der Schleife ausbricht. Mittime.sleep() muss Ihr Code warten, bis der Aufruf von Pythonsleep()beendet ist, bevor der Thread beendet werden kann.

Der Grund, warum Sie hierwait() verwenden möchten, ist, dasswait()non-blocking ist, währendtime.sleep()blocking ist. Dies bedeutet, dass Sie bei Verwendung vontime.sleep() verhindern, dass der Hauptthread weiter ausgeführt wird, während er auf das Ende des Aufrufs vonsleep()wartet. wait() löst dieses Problem. Weitere Informationen dazu finden Sie in Pythonsthreading documentation.

So fügen Sie einen Pythonsleep()-Aufruf mitEvent.wait() hinzu:

import logging
import threading

def worker(event):
    while not event.isSet():
        logging.debug("worker thread checking in")
        event.wait(1)

def main():
    logging.basicConfig(
        level=logging.DEBUG,
        format="%(relativeCreated)6d %(threadName)s %(message)s"
    )
    event = threading.Event()

    thread = threading.Thread(target=worker, args=(event,))
    thread_two = threading.Thread(target=worker, args=(event,))
    thread.start()
    thread_two.start()

    while not event.isSet():
        try:
            logging.debug("Checking in from main thread")
            event.wait(0.75)
        except KeyboardInterrupt:
            event.set()
            break

if __name__ == "__main__":
    main()

In diesem Beispiel erstellen Siethreading.Event() und übergeben es anworker(). (Denken Sie daran, dass Sie im vorherigen Beispiel stattdessen ein Wörterbuch übergeben haben.) Als Nächstes richten Sie Ihre Schleifen ein, um zu überprüfen, obevent festgelegt ist oder nicht. Wenn dies nicht der Fall ist, druckt Ihr Code eine Nachricht und wartet ein wenig, bevor er erneut überprüft. Um das Ereignis festzulegen, können Sie [.keys] #Ctrl [.kbd .key-c] # C ## drücken. Sobald das Ereignis gesetzt ist, kehrt `+ worker ()` zurück und die Schleife wird unterbrochen, wodurch das Programm beendet wird.

Note: Wenn Sie mehr über Wörterbücher erfahren möchten, lesen SieDictionaries in Python.

Schauen Sie sich den obigen Codeblock genauer an. Wie würden Sie jedem Arbeitsthread eine andere Schlafzeit geben? Kannst du es herausfinden? Fühlen Sie sich frei, diese Übung selbst in Angriff zu nehmen!

Hinzufügen eines Python`sleep()`-Aufrufs mit asynchronem E / A.

In der Version 3.4 wurden Python asynchrone Funktionen hinzugefügt, und dieser Funktionsumfang wurde seitdem aggressiv erweitert. Asynchronous programming ist eine Art der parallelen Programmierung, mit der Sie mehrere Aufgaben gleichzeitig ausführen können. Wenn eine Aufgabe beendet ist, wird der Hauptthread benachrichtigt.

asyncio ist ein Modul, mit dem Sie einen Pythonsleep()-Aufruf asynchron hinzufügen können. Wenn Sie mit Pythons Implementierung der asynchronen Programmierung nicht vertraut sind, lesen SieAsync IO in Python: A Complete Walkthrough undPython Concurrency & Parallel Programming.

Hier ist ein Beispiel aus Pythons eigenendocumentation:

import asyncio

async def main():
    print('Hello ...')
    await asyncio.sleep(1)
    print('... World!')

# Python 3.7+
asyncio.run(main())

In diesem Beispiel führen Siemain() aus und lassen es zwischen zweiprint() Aufrufen eine Sekunde lang ruhen.

Hier ist ein überzeugenderes Beispiel aus demCoroutines and Tasks-Teil derasyncio-Dokumentation:

import asyncio
import time

async def output(sleep, text):
    await asyncio.sleep(sleep)
    print(text)

async def main():
    print(f"Started: {time.strftime('%X')}")
    await output(1, 'First')
    await output(2, 'Second')
    await output(3, 'Third')
    print(f"Ended: {time.strftime('%X')}")

# Python 3.7+
asyncio.run(main())

In diesem Code erstellen Sie einen Worker namensoutput(), der die Anzahl der Sekunden bissleep und dietext zum Ausdrucken benötigt. Anschließend verwenden Sie das Schlüsselwortawaitvon Python, um auf die Ausführung des Codesoutput()zu warten. await ist hier erforderlich, daoutput() alsasync-Funktion markiert wurde, sodass Sie es nicht wie eine normale Funktion aufrufen können.

Wenn Sie diesen Code ausführen, führt Ihr Programmawait dreimal aus. Der Code wartet 1, 2 und 3 Sekunden, was einer Gesamtwartezeit von 6 Sekunden entspricht. Sie können den Code auch so umschreiben, dass die Aufgaben parallel ausgeführt werden:

import asyncio
import time

async def output(text, sleep):
    while sleep > 0:
        await asyncio.sleep(1)
        print(f'{text} counter: {sleep} seconds')
        sleep -= 1

async def main():
    task_1 = asyncio.create_task(output('First', 1))
    task_2 = asyncio.create_task(output('Second', 2))
    task_3 = asyncio.create_task(output('Third', 3))
    print(f"Started: {time.strftime('%X')}")
    await task_1
    await task_2
    await task_3
    print(f"Ended: {time.strftime('%X')}")

if __name__ == '__main__':
    asyncio.run(main())

Jetzt verwenden Sie das Konzept vontasks, das Sie mitcreate_task() erstellen können. Wenn Sie Aufgaben inasyncio verwenden, führt Python die Aufgaben asynchron aus. Wenn Sie den obigen Code ausführen, sollte er in 3 Sekunden statt in 6 Sekunden fertig sein.

Hinzufügen eines Python`sleep()`-Aufrufs mit GUIs

Befehlszeilenanwendungen sind nicht der einzige Ort, an dem Sie möglicherweise Pythonsleep()-Aufrufe hinzufügen müssen. Wenn Sie einGraphical User Interface (GUI)erstellen, müssen Sie gelegentlich Verzögerungen hinzufügen. Sie können beispielsweise eine FTP-Anwendung erstellen, um Millionen von Dateien herunterzuladen. Sie müssen jedoch zwischen den Stapeln einensleep()-Aufruf hinzufügen, damit Sie den Server nicht blockieren.

Der GUI-Code führt die gesamte Verarbeitung und Zeichnung in einem Hauptthread namensevent loop aus. Wenn Sietime.sleep() innerhalb des GUI-Codes verwenden, blockieren Sie dessen Ereignisschleife. Aus Sicht des Benutzers scheint die Anwendung einzufrieren. Der Benutzer kann mit dieser Anwendung nicht interagieren, während er mit dieser Methode schläft. (Unter Windows erhalten Sie möglicherweise sogar eine Warnung, dass Ihre Anwendung jetzt nicht mehr reagiert.)

Glücklicherweise gibt es nebentime.sleep() noch andere Methoden. In den nächsten Abschnitten erfahren Sie, wie Sie Pythonsleep()-Aufrufe sowohl in Tkinter als auch in wxPython hinzufügen.

Schlafen in Tkinter

tkinter ist Teil der Python-Standardbibliothek. Es steht Ihnen möglicherweise nicht zur Verfügung, wenn Sie eine vorinstallierte Version von Python unter Linux oder Mac verwenden. Wenn Sie einImportErrorerhalten, müssen Sie prüfen, wie Sie es Ihrem System hinzufügen können. Wenn Sie jedochinstall Python yourself verwenden, solltetkinter bereits verfügbar sein.

Sie beginnen mit einem Beispiel, dastime.sleep() verwendet. Führen Sie diesen Code aus, um zu sehen, was passiert, wenn Sie einen Pythonsleep()-Aufruf falsch hinzufügen:

import tkinter
import time

class MyApp:
    def __init__(self, parent):
        self.root = parent
        self.root.geometry("400x400")
        self.frame = tkinter.Frame(parent)
        self.frame.pack()
        b = tkinter.Button(text="click me", command=self.delayed)
        b.pack()

    def delayed(self):
        time.sleep(3)

if __name__ == "__main__":
    root = tkinter.Tk()
    app = MyApp(root)
    root.mainloop()

Sobald Sie den Code ausgeführt haben, drücken Sie die Taste in Ihrer GUI. Die Taste bleibt drei Sekunden lang gedrückt, bissleep() beendet ist. Wenn die Anwendung andere Schaltflächen hätte, könnten Sie diese nicht anklicken. Sie können die Anwendung auch nicht im Ruhezustand schließen, da sie nicht auf das Schließereignis reagieren kann.

Damittkinter richtig schlafen, müssen Sieafter() verwenden:

import tkinter

class MyApp:
    def __init__(self, parent):
        self.root = parent
        self.root.geometry("400x400")
        self.frame = tkinter.Frame(parent)
        self.frame.pack()
        self.root.after(3000, self.delayed)

    def delayed(self):
        print('I was delayed')

if __name__ == "__main__":
    root = tkinter.Tk()
    app = MyApp(root)
    root.mainloop()

Hier erstellen Sie eine Anwendung mit einer Breite von 400 Pixel und einer Höhe von 400 Pixel. Es sind keine Widgets darauf. Alles was es tun wird, ist einen Rahmen zu zeigen. Dann rufen Sieself.root.after() auf, wobeiself.root eine Referenz auf das ObjektTk() ist. after() akzeptiert zwei Argumente:

Die Anzahl der Millisekunden zum Schlafen
Die Methode, die aufgerufen werden soll, wenn der Ruhezustand beendet ist

In diesem Fall druckt Ihre Anwendung nach 3 Sekunden eine Zeichenfolge nach stdout. Sie können sichafter() alstkinter-Version vontime.sleep() vorstellen, aber es bietet auch die Möglichkeit, eine Funktion aufzurufen, nachdem der Schlaf beendet ist.

Sie können diese Funktionalität verwenden, um die Benutzererfahrung zu verbessern. Durch Hinzufügen eines Aufrufs von Pythonsleep()können Sie die Anwendung schneller laden lassen und nach dem Start einen länger laufenden Prozess starten. Auf diese Weise muss der Benutzer nicht auf das Öffnen der Anwendung warten.

Schlafen in wxPython

Es gibt zwei Hauptunterschiede zwischen wxPython und Tkinter:

wxPython hat viel mehr Widgets.
wxPython soll auf allen Plattformen nativ aussehen und sich nativ anfühlen.

Das wxPython-Framework ist nicht in Python enthalten, daher müssen Sie es selbst installieren. Wenn Sie mit wxPython nicht vertraut sind, lesen SieHow to Build a Python GUI Application With wxPython.

In wxPython können Siewx.CallLater() verwenden, um einen Pythonsleep()-Aufruf hinzuzufügen:

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='Hello World')
        wx.CallLater(4000, self.delayed)
        self.Show()

    def delayed(self):
        print('I was delayed')

if __name__ == '__main__':
    app = wx.App()
    frame = MyFrame()
    app.MainLoop()

Hier unterteilen Siewx.Frame direkt und rufen dannwx.CallLater() auf. Diese Funktion verwendet dieselben Parameter wieafter()von Tkinter:

Die Anzahl der Millisekunden zum Schlafen
Die Methode, die aufgerufen werden soll, wenn der Ruhezustand beendet ist

Wenn Sie diesen Code ausführen, sollte ein kleines leeres Fenster ohne Widgets angezeigt werden. Nach 4 Sekunden wird die Zeichenfolge'I was delayed'auf stdout gedruckt.

Einer der Vorteile der Verwendung vonwx.CallLater() besteht darin, dass es threadsicher ist. Mit dieser Methode können Sie innerhalb eines Threads eine Funktion aufrufen, die sich in der Hauptanwendung von wxPython befindet.

Fazit

Mit diesem Tutorial haben Sie eine wertvolle neue Technik erhalten, die Sie Ihrer Python-Toolbox hinzufügen können! Sie wissen, wie Sie Verzögerungen hinzufügen können, um Ihre Anwendungen zu beschleunigen und zu verhindern, dass sie Systemressourcen verbrauchen. Sie können sogar die Aufrufe von Pythonsleep()verwenden, um Ihren GUI-Code effektiver neu zu zeichnen. Dies wird die Benutzererfahrung für Ihre Kunden viel besser machen!

Zusammenfassend haben Sie gelernt, wie Sie Pythonsleep()-Aufrufe mit den folgenden Tools hinzufügen:

time.sleep()
Dekorateure
Themen
asyncio
Tkinter
wxPython

Jetzt können Sie das Gelernte nehmen und Ihren Code in den Ruhezustand versetzen!

TOC

Python sleep (): So fügen Sie Ihrem Code Zeitverzögerungen hinzu