So fügen Sie Verzögerungen zum Code hinzu

Dieses Tutorial zeigt Ihnen, wie Sie die Funktion sleep() aus dem integrierten Zeitmodul von Python nutzen, um Ihrem Code Pausen hinzuzufügen.

Wenn Sie ein simples Python-Programm ausführen, erfolgt die Abarbeitung des Codes sequenziell – eine Anweisung nach der anderen – ohne jede Verzögerung. In manchen Situationen kann es jedoch notwendig sein, die Ausführung des Codes zu pausieren. Die sleep()-Funktion, die im Python-Zeitmodul enthalten ist, bietet hier eine einfache Lösung.

In diesem Tutorial werden Sie die Syntax der sleep()-Funktion in Python kennenlernen und anhand von Beispielen sehen, wie sie angewendet wird. Legen wir los!

Die Syntax von time.sleep() in Python

Das in die Python-Standardbibliothek integrierte Zeitmodul stellt verschiedene hilfreiche zeitbezogene Funktionen zur Verfügung. Importieren Sie zunächst das Zeitmodul in Ihre Arbeitsumgebung:

import time

Da die Funktion sleep() Teil des Zeitmoduls ist, können Sie diese nun mit folgender allgemeiner Syntax aufrufen und nutzen:

time.sleep(n)

Hierbei ist n die Anzahl der Sekunden, die gewartet werden soll. Es kann sich hierbei um eine ganze Zahl oder eine Fließkommazahl handeln.

Manchmal sind nur Verzögerungen im Millisekundenbereich nötig. In diesen Fällen können Sie die Dauer in Millisekunden in Sekunden umrechnen und diese im Aufruf der sleep()-Funktion angeben. Um beispielsweise eine Verzögerung von 100 Millisekunden einzufügen, verwenden Sie time.sleep(0.1).

▶ Alternativ können Sie auch nur die sleep()-Funktion aus dem Zeitmodul importieren:

from time import sleep

Wenn Sie die obige Importmethode wählen, können Sie die Funktion sleep() direkt aufrufen – ohne time.sleep() zu verwenden.

Nachdem Sie nun die Syntax der Python-Funktion sleep() verstanden haben, sehen wir uns einige Codebeispiele an, um die Funktion in Aktion zu erleben. Sie können die in diesem Tutorial verwendeten Python-Skripte aus dem Ordner „python-sleep“ in diesem GitHub-Repository herunterladen. 👩🏽‍💻

Verzögerung der Codeausführung mit sleep()

Als erstes Beispiel nutzen wir die Funktion sleep(), um die Ausführung eines einfachen Python-Programms zu verzögern.

Im folgenden Codeabschnitt:

• Wird die erste print()-Anweisung ohne Verzögerung ausgeführt.
• Danach fügen wir mit der Funktion sleep() eine Pause von 5 Sekunden ein.
• Die zweite print()-Anweisung wird erst nach Beendigung der sleep()-Operation ausgeführt.

# /python-sleep/simple_example.py
import time

print("Jetzt ausgeben")
time.sleep(5)
print("Ausgabe nach 5 Sekunden Pause")

Führen Sie nun die Datei simple_example.py aus und beobachten Sie die Ausgabe:

$ python3 simple_example.py

Hinzufügen verschiedener Verzögerungen in einem Codeblock

Im vorherigen Beispiel haben wir eine feste Verzögerung von 5 Sekunden zwischen der Ausführung von zwei print()-Anweisungen verwendet. Nun wollen wir ein weiteres Beispiel programmieren, in dem verschiedene Verzögerungszeiten während der Iteration durch eine Schleife eingefügt werden.

In diesem Beispiel möchten wir folgendes erreichen:

• Einen Satz durchlaufen, jedes Wort ausgeben.
• Nach der Ausgabe jedes Wortes soll eine gewisse Zeit gewartet werden, bevor das nächste Wort ausgegeben wird.

Durchlaufen einer Reihe von Strings

Betrachten wir die Zeichenkette, den Satz. Es ist eine Zeichenkette, bei der jedes Wort eine Zeichenkette für sich ist.

Wenn wir die Zeichenkette durchlaufen, erhalten wir jedes Zeichen einzeln wie hier gezeigt:

>>> satz = "Wie lange wird das dauern?"
>>> for zeichen in satz:
...     print(zeichen)

# Ausgabe (gekürzt)
W
i
e
.
.
.
n
?

Das ist aber nicht, was wir wollen. Wir möchten den Satz durchlaufen und auf jedes einzelne Wort zugreifen. Dafür können wir die Methode split() auf der Zeichenkette aufrufen. Dies gibt eine Liste von Zeichenketten zurück, die durch Aufteilen des Satzes an allen Leerzeichen entstanden sind.

>>> satz.split()
['Wie', 'lange', 'wird', 'das', 'dauern?']
>>> for wort in satz.split():
...     print(wort)

# Ausgabe
Wie
lange
wird
das
dauern?

Iterables mit unterschiedlichen Verzögerungen durchlaufen

Sehen wir uns das Beispiel noch einmal genauer an:

• satz ist die Zeichenkette, die wir durchlaufen möchten, um jedes Wort zu erhalten.
• verzögerungszeiten ist die Liste der Verzögerungszeiten, die wir bei jeder Iteration der Schleife als Argument für die Funktion sleep() verwenden werden.

Hier möchten wir zwei Listen gleichzeitig durchlaufen: die Liste verzögerungszeiten und die Liste der Strings, die durch Aufteilen der Zeichenkette satz entstanden sind. Dazu verwenden wir die Funktion zip() für die parallele Iteration.

Die Python-Funktion zip(): zip(liste1, liste2) gibt einen Iterator von Tupeln zurück, wobei jedes Tupel das Element am Index i in liste1 und liste2 enthält.

# /python-sleep/delay_times.py
import time

verzögerungszeiten = [3,4,1.5,2,0.75]
satz = "Wie lange wird das dauern?"
for verzögerungszeit, wort in zip(verzögerungszeiten, satz.split()):
    print(wort)
    time.sleep(verzögerungszeit)

Ohne die Funktion sleep() würde die Steuerung sofort mit der nächsten Iteration fortfahren. Da wir aber eine Verzögerung eingebaut haben, wird die nächste Iteration erst nach Abschluss der sleep()-Operation ausgeführt.

Führen Sie nun delay_times.py aus und beobachten Sie die Ausgabe:

$ python3 delay_times.py

Die Wörter der Zeichenkette werden nacheinander mit den definierten Verzögerungen ausgegeben. Die Verzögerung nach dem Ausgeben des Wortes am Index i der Zeichenkette entspricht der Zahl am Index i in der Liste verzögerungszeiten.

Countdown-Timer in Python

Als nächstes Beispiel programmieren wir einen einfachen Countdown-Timer in Python.

Wir definieren die Funktion countdown() wie folgt:

# /python-sleep/countdown.py
import time

def countdown(n):
    for i in range(n, -1, -1):
        if i == 0:
            print("Fertig!")
        else:
            print(i)
            time.sleep(1)

Nun analysieren wir die Definition der Funktion countdown():

• Die Funktion nimmt eine Zahl n als Argument und zählt von dieser Zahl n rückwärts bis Null.
• Wir nutzen time.sleep(1), um zwischen den Zählschritte eine Pause von einer Sekunde einzufügen.
• Wenn der Zähler Null erreicht, gibt die Funktion „Fertig!“ aus.

🎯 Um den Countdown zu realisieren, haben wir die Funktion range() mit einem negativen Schrittwert von -1 genutzt. range(n, -1, -1) hilft uns, den Zahlenbereich n, n-1, n-2 usw. bis Null zu durchlaufen. Beachten Sie, dass der Endpunkt bei der Funktion range() standardmäßig ausgeschlossen ist.

Als nächstes fügen wir der Funktion countdown() einen Aufruf mit dem Argument 5 hinzu.

countdown(5)

Führen Sie nun das Skript countdown.py aus und sehen Sie die Funktion countdown in Aktion!

$ python3 countdown.py

Die sleep()-Funktion im Multithreading

Das Python-Modul threading bietet sofort einsatzbereite Multithreading-Funktionen. In Python stellt der Global Interpreter Lock (GIL) sicher, dass zu jedem Zeitpunkt immer nur ein Thread aktiv ist.

Während Ein- und Ausgabevorgängen (E/A) und Warteoperationen, wie beispielsweise die Ausführung von sleep(), kann der Prozessor jedoch die Ausführung des aktuellen Threads aussetzen und zu einem anderen wartenden Thread wechseln.

Zur Veranschaulichung betrachten wir ein Beispiel.

Erstellen und Ausführen von Threads in Python

Betrachten Sie die folgenden Funktionen func1(), func2() und func3(). Sie durchlaufen eine Reihe von Zahlen und geben diese aus. Danach wird bei jedem Schleifendurchlauf eine sleep()-Operation mit einer bestimmten Dauer durchgeführt. Wir haben für jede Funktion unterschiedliche Verzögerungszeiten verwendet, um besser zu verstehen, wie die Ausführung gleichzeitig zwischen den Threads wechselt.

import time
import threading

def func1():
    for i in range(5):
        print(f"Ausführung t1, Ausgabe {i}.")
        time.sleep(2)

def func2():
    for i  in range(5):
         print(f"Ausführung t2, Ausgabe {i}.")
         time.sleep(1)

def func3():
    for i in range(4):
         print(f"Ausführung t3, Ausgabe {i}.")
         time.sleep(0.5)

In Python können Sie mit dem Konstruktor Thread() ein Thread-Objekt instanziieren. Mit der Syntax threading.Thread(target = ..., args = ...) wird ein Thread erzeugt, der die Zielfunktion mit dem Argument im Tupel args ausführt.

In diesem Beispiel nehmen die Funktionen func1, func2 und func3 keine Argumente entgegen. Es reicht also, als Ziel nur den Namen der Funktion anzugeben. Dann definieren wir die Thread-Objekte t1, t2 und t3 mit func1, func2 bzw. func3 als Ziel.

t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)

t1.start()
t2.start()
t3.start()

Hier ist der vollständige Code für das Threading-Beispiel:

# /python-sleep/threads.py
import time
import threading

def func1():
    for i in range(5):
        print(f"Ausführung t1, Ausgabe {i}.")
        time.sleep(2)

def func2():
    for i  in range(5):
         print(f"Ausführung t2, Ausgabe {i}.")
         time.sleep(1)

def func3():
    for i in range(4):
         print(f"Ausführung t3, Ausgabe {i}.")
         time.sleep(0.5)

t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t3 = threading.Thread(target=func3)

t1.start()
t2.start()
t3.start()

Beobachten Sie die Ausgabe. Die Ausführung wechselt zwischen den drei Threads. Thread t3 hat die geringste Wartezeit und wird daher am wenigsten unterbrochen. Thread t1 hat die längste sleep()-Dauer von zwei Sekunden, also ist er der letzte Thread, der seine Ausführung beendet.

Für mehr Informationen können Sie sich das Tutorial zu den Grundlagen des Multithreadings in Python ansehen.

Fazit

In diesem Tutorial haben Sie gelernt, wie Sie mit der sleep()-Funktion in Python Ihrem Code zeitliche Verzögerungen hinzufügen.

Sie können über das eingebaute Zeitmodul time.sleep() auf die Funktion zugreifen. Um die Ausführung für n Sekunden zu verzögern, nutzen Sie time.sleep(n). Zudem haben Sie Beispiele gesehen, wie man nachfolgende Iterationen in einer Schleife um unterschiedliche Werte verzögert, einen Countdown erstellt und Multithreading nutzt.

Nun können Sie die erweiterten Funktionen des Zeitmoduls erkunden. Möchten Sie mit Datums- und Zeitangaben in Python arbeiten? Zusätzlich zum Zeitmodul können Sie die Funktionen des datetime– und calendar-Moduls verwenden.

Als nächstes lernen Sie, wie man Zeitdifferenzen in Python berechnet.⏰