Python Time: Alles über die Nutzung und die Funk­tio­nen des Moduls

Python time ist ein Modul, mit dem in der Pro­gram­mier­spra­che Da­tums­an­ga­ben aus­ge­ge­ben werden können. Das Modul bietet zahl­rei­che Funk­tio­nen und bedient sich der Unix­zeit­an­ga­be und struct_time-Objekten.

Was ist Python time und wie wird das Modul genutzt?

Für die Im­ple­men­tie­rung und Be­rück­sich­ti­gung von Zeit­an­ga­ben in der Pro­gram­mier­spra­che ist das Python-Modul time von ent­schei­den­der Bedeutung. Zu den Aufgaben, die durch dieses Modul erledigt werden können, gehören die Wie­der­ga­be der aktuellen Zeit, die For­ma­tie­rung von Zeit­an­ga­ben und die Angabe einer be­stimm­ten Dauer bei der Aus­füh­rung einer Funktion. Um das Modul nutzen zu können, muss Python time zunächst mit dem folgenden Schlüs­sel­wort im­por­tiert werden:

import time

Im Anschluss können Sie ver­schie­de­ne Funk­tio­nen mit dem Modul anwenden. Die wich­tigs­ten zeigen wir Ihnen in den folgenden Ab­schnit­ten. Falls Sie nach einer Al­ter­na­ti­ve zu Python time suchen, ist Python datetime eine gute Wahl.

time.time() und die Bedeutung des Unix­zeit­s­tem­pels

Die Basis für die Funktion time.time() ist der Unix­zeit­s­tem­pel. Dieser be­schreibt einen exakten Punkt in der Ver­gan­gen­heit, von dem an Zeit in einem System gemessen wird. Für Windows und zahl­rei­che Unix-Systeme ist dieser Zeitpunkt der 1. Januar 1970, um 00:00:00 Uhr (ko­or­di­nier­te Weltzeit). Auch Python legt diesen Moment zugrunde. Al­ter­na­tiv wird die Be­rech­nung von dieser Sekunde aus als „Zeit seit Epoch“ be­zeich­net. Die Funktion time.time() gibt Ihnen die Anzahl der Sekunden an, die seit diesem Moment zu Beginn der 1970er Jahre vergangen sind. Dafür nutzen Sie den folgenden Code:

import time
vergangene_zeit = time.time()
print("Verstrichene Sekunden seit Epoch: ", vergangene_zeit)

Im Moment unserer Tex­terstel­lung erhielten wir dafür diese Ausgabe:

1716816325

time.ctime(): Daten leserlich angeben

Da Sie mit dieser Angabe al­ler­dings im Nor­mal­fall nur wenig anfangen können, bietet Ihnen Python time die Mög­lich­keit, den Unix­zeit­s­tem­pel als Basis für eine Da­tums­an­ga­be zu nehmen. Sie pro­fi­tie­ren dabei also von der Ge­nau­ig­keit dieser Zeit­mes­sung, erhalten den Stempel aber in einem sinn­vol­len Format. Die passende Funktion lautet time.ctime(). Sie rechnet den Unix­zeit­s­tem­pel direkt in ein Datum um. Der ent­spre­chen­de Code ist dieser:

import time
vergangene_zeit = 1716816325
aktuelle_zeit = time.ctime(vergangene_zeit)
print("Dies ist die aktuelle Zeit: ", aktuelle_zeit)

Unsere Ausgabe sieht dann so aus. Be­rück­sich­tigt wird die lokale Zeit:

Dies ist die aktuelle Zeit: Mon May 27 2024 15:25:25

time.sleep(): Aus­füh­rung eines Programms planen

Python time kann al­ler­dings deutlich mehr als nur die aktuelle Zeit wie­der­ge­ben. Das Modul wird auch verwendet, um die Aus­füh­rung eines Programms zu steuern be­zie­hungs­wei­se diese zu verzögern. Die passende Funktion nennt sich time.sleep() und wird so ge­schrie­ben:

import time
print("Dies wird sofort angezeigt… ")
time.sleep(5)
print("…und dies nach 5 Sekunden.")

Unsere Ausgabe sieht dann fol­gen­der­ma­ßen aus:

Dies wird sofort angezeigt…
…und dies nach 5 Sekunden.

Der zweite Teil wird al­ler­dings erst nach einer Ver­zö­ge­rung von fünf Sekunden aus­ge­ge­ben. Wofür Sie Python time.sleep() im Detail verwenden können, erfahren Sie in unserem aus­führ­li­chen Ratgeber im Digital Guide.

struct_time-Objekte für Python time

Für viele Funk­tio­nen von Python time ist das Objekt struct_time die Grundlage. Es wird meistens als Parameter oder Rück­ga­be­wert genutzt und gibt ein Tuple aus, dessen Wert über den Index oder das Attribut an­ge­wie­sen werden kann. Die folgenden Attribute kommen dafür in Frage:

time.localtime(): Ver­bin­dung von struct_time und der Zeit seit Epoch

Die Funktion time.localtime() nutzt ein solches struct_time-Objekt auf Basis des Unix­zeit­s­tem­pels. Das sieht im Code so aus:

import time
zeitangabe = time.time()
aktuelle_zeit = time.localtime(zeitangabe)
print(aktuelle_zeit)

So erhalten wir die folgende Ausgabe:

time.struct_time(tm_year=2024, tm_mon=5, tm_mday=27, tm_hour=15, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=148, tm_isdst=1)

Al­ter­na­tiv ist es auch möglich, einen be­lie­bi­gen Wert für den Parameter localtime() zu wählen. Dann sieht der Code aus wie folgt:

import time
zeitangabe = time.time()
aktuelle_zeit = time.localtime(1716816325)
print(aktuelle_zeit)

Die Ausgabe ent­spricht dann wieder dem Beispiel von oben:

time.struct_time(tm_year=2024, tm_mon=5, tm_mday=27, tm_hour=15, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=148, tm_isdst=1)

time.mktime(): Das Ge­gen­stück zu localtime()

time.mktime() ist in Python time die ent­ge­gen­ge­setz­te Funktion von localtime(). Dabei nutzen Sie ein struct_time-Objekt als Parameter und das System gibt Ihnen den passenden Stempel für die Zeit seit Epoch aus. So sieht der Code aus:

import time
zeitangabe = time.mktime(local_time)
print(zeitangabe)

Als Ausgabe erhalten Sie einen Se­kun­den­wert in diesem Format:

1716816325

time.gmtime(): Ko­or­di­nier­te Weltzeit für die Anzeige

time.gmtime() ent­spricht in großen Teilen time.localtime(). Das ent­spre­chen­de struct_time-Objekt wird hier al­ler­dings in der ko­or­di­nier­ten Weltzeit zu­rück­ge­ge­ben. Das ist der Code:

import time
time_stamp = time.time()
weltzeit = time.gmtime(time_stamp)
print(weltzeit)

Ihre Ausgabe un­ter­schei­det sich bei dieser Funktion von Python time somit in einigen Details von dem Beispiel oben:

time.struct_time(tm_year=2024, tm_mon=5, tm_mday=27, tm_hour=13, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=148, tm_isdst=0)

time.asctime(): struct_time-Objekte in Strings

Sie können time.asctime() nutzen, um ein struct_time-Objekt in einen Python-String um­zu­wan­deln. Dies könnte bei­spiel­haft so aussehen:

import time
zeitpunkt = time.localtime()
leserliche_angabe = time.asctime(zeitpunkt)
print(leserliche_angabe)

So erhalten Sie direkt eine bessere Ausgabe:

Mon May 27 15:25:25 2024

time.strftime(): Eine Zei­chen­ket­te erstellen mit Python time

Ver­schie­de­ne Va­ria­tio­nen sind mit time.strftime() möglich. Hierbei nutzen Sie un­ter­schied­li­che For­mat­codes, um die aktuelle Zeit im ge­wünsch­ten Format dar­zu­stel­len. Um Ihnen einen Einblick in die un­ter­schied­li­chen For­mat­codes zu geben, listen wir hier ein paar der wich­tigs­ten auf:

• %Y: Steht für die Jah­res­zahl im Format 0001, …, 2024, …, 9999
• %m: Steht für den Monat und nutzt dafür die Zahlen von 01 (Januar) bis 12 (Dezember)
• %d: Steht für den Tag vom 01. des Monats bis zum 31.
• %H: Steht für die Stunde im Spektrum von 00 bis 23
• %M: Steht für die Minute und wird von 00 bis 59 ab­ge­bil­det
• %S: Steht für die Sekunde von 00 bis 61

Im Code könnte das zum Beispiel so aussehen:

import time
zeitpunkt = time.localtime()
leserliche_angabe = time.strftime("%d-%m-%Y, %H:%M:%S", zeitpunkt)
print(leserliche_angabe)

In diesem Fall wäre das die Ausgabe:

27-05-2024, 15:25:25

time.strptime(): Strings in struct_time-Objekte umwandeln

Auch dafür gibt es in Python time ein Ge­gen­stück: time.strptime() nutzt einen String, um ein struct_time-Objekt aus­zu­ge­ben. Dies ist der passende Code:

import time
zeitpunkt = time.strptime(leserliche_angabe, "%d-%m-%Y, %H: %M:%S")
print(zeitpunkt)

So erhalten wir wieder diese Ausgabe:

time.struct_time(tm_year=2024, tm_mon=5, tm_mday=27, tm_hour=15, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=148, tm_isdst=1)