# Python Time: Alles über die Nutzung und die Funktionen des Moduls Python `time` ist ein Modul, mit dem in der Programmiersprache Datumsangaben ausgegeben werden können. Das Modul bietet zahlreiche Funktionen und bedient sich der Unixzeitangabe und `struct_time`-Objekten. ## Was ist Python `time` und wie wird das Modul genutzt? Für die Implementierung und Berücksichtigung von Zeitangaben in der Programmiersprache ist das Python-Modul `time` von entscheidender Bedeutung. Zu den Aufgaben, die durch dieses Modul erledigt werden können, gehören die **Wiedergabe der aktuellen Zeit, die Formatierung von Zeitangaben und die Angabe einer bestimmten Dauer** bei der Ausführung einer Funktion. Um das Modul nutzen zu können, muss Python `time` zunächst mit dem folgenden Schlüsselwort importiert werden: ```python import time ``` Im Anschluss können Sie verschiedene Funktionen mit dem Modul anwenden. Die wichtigsten zeigen wir Ihnen in den folgenden Abschnitten. Falls Sie nach einer Alternative zu Python `time` suchen, ist [Python datetime](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-datetime/) eine gute Wahl. ## `time.time()` und die Bedeutung des Unixzeitstempels Die Basis für die Funktion `time.time()` ist der Unixzeitstempel. Dieser beschreibt einen exakten Punkt in der Vergangenheit, von dem an Zeit in einem System gemessen wird. Für Windows und zahlreiche Unix-Systeme ist dieser Zeitpunkt der **1. Januar 1970, um 00:00:00 Uhr** (koordinierte Weltzeit). Auch Python legt diesen Moment zugrunde. Alternativ wird die Berechnung von dieser Sekunde aus als „Zeit seit Epoch“ bezeichnet. 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: ```python import time vergangene_zeit = time.time() print("Verstrichene Sekunden seit Epoch: ", vergangene_zeit) ``` Im Moment unserer Texterstellung erhielten wir dafür diese Ausgabe: ```python 1716816325 ``` ## `time.ctime()`: Daten leserlich angeben Da Sie mit dieser Angabe allerdings im Normalfall nur wenig anfangen können, bietet Ihnen Python `time` die Möglichkeit, den Unixzeitstempel als **Basis für eine Datumsangabe** zu nehmen. Sie profitieren dabei also von der Genauigkeit dieser Zeitmessung, erhalten den Stempel aber in einem sinnvollen Format. Die passende Funktion lautet `time.ctime()`. Sie rechnet den Unixzeitstempel direkt in ein Datum um. Der entsprechende Code ist dieser: ```python 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. Berücksichtigt wird die lokale Zeit: ```python Dies ist die aktuelle Zeit: Mon May 27 2024 15:25:25 ``` Tipp Die ideale Lösung für die Arbeit mit Ihrem Webprojekt: Mit [Deploy Now](https://www.ionos.at/hosting/deploy-now "Deploy Now von IONOS") von IONOS deployen Sie Änderungen am Code direkt mit GitHub und profitieren von der Echtzeitanpassung. Finden Sie jetzt den passenden Tarif! ## `time.sleep()`: Ausführung eines Programms planen Python `time` kann allerdings deutlich mehr als nur die aktuelle Zeit wiedergeben. Das Modul wird auch verwendet, um die Ausführung eines Programms zu steuern beziehungsweise diese zu verzögern. Die passende Funktion nennt sich `time.sleep()` und wird so geschrieben: ```python import time print("Dies wird sofort angezeigt… ") time.sleep(5) print("…und dies nach 5 Sekunden.") ``` Unsere Ausgabe sieht dann folgendermaßen aus: ```python Dies wird sofort angezeigt… …und dies nach 5 Sekunden. ``` Der zweite Teil wird allerdings erst nach einer Verzögerung von fünf Sekunden ausgegeben. Wofür Sie [Python time.sleep()](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-sleep/) im Detail verwenden können, erfahren Sie in unserem ausführlichen Ratgeber im Digital Guide. ## `struct_time`-Objekte für Python `time` Für viele Funktionen von Python `time` ist das **Objekt `struct_time`** die Grundlage. Es wird meistens als Parameter oder Rückgabewert genutzt und gibt ein Tuple aus, dessen Wert über den Index oder das Attribut angewiesen werden kann. Die folgenden Attribute kommen dafür in Frage:
Index Attribut Beschreibung Mögliche Werte
0 tm\_year Jahreszahl 0000, …, 2024, …, 9999
1 tm\_mon Angabe des Monats 1, 2, 3, …, 12
2 tm\_mday Bestimmter Tag im Monat 1, 2, 3, 31
3 tm\_hour Uhrzeit in Stunden 0, 1, 2, …, 23
4 tm\_min Uhrzeit in Minuten 0, 1, 2, …, 59
5 tm\_sec Uhrzeit in Sekunden 0, 1, 2, …, 60, 61
6 tm\_wday Wochentag 0 (für Montag), …, 6 (für Sonntag)
7 tm\_yday Tag in einem Jahr 1, 2, 3, …, 366
8 tm\_isdst Sommer- oder Winterzeit 0 (Winter), 1 (Sommer) oder -1 (keine Angabe)
## `time.localtime()`: Verbindung von `struct_time` und der Zeit seit Epoch Die Funktion **`time.localtime()`** nutzt ein solches `struct_time`-Objekt auf Basis des Unixzeitstempels. Das sieht im Code so aus: ```python import time zeitangabe = time.time() aktuelle_zeit = time.localtime(zeitangabe) print(aktuelle_zeit) ``` So erhalten wir die folgende Ausgabe: ```python 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) ``` Alternativ ist es auch möglich, einen beliebigen Wert für den Parameter `localtime()` zu wählen. Dann sieht der Code aus wie folgt: ```python import time zeitangabe = time.time() aktuelle_zeit = time.localtime(1716816325) print(aktuelle_zeit) ``` Die Ausgabe entspricht dann wieder dem Beispiel von oben: ```python 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 Gegenstück zu `localtime()` `time.mktime()` ist in Python `time` die entgegengesetzte 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: ```python import time zeitangabe = time.mktime(local_time) print(zeitangabe) ``` Als Ausgabe erhalten Sie einen Sekundenwert in diesem Format: ```python 1716816325 ``` ## `time.gmtime()`: Koordinierte Weltzeit für die Anzeige `time.gmtime()` entspricht in großen Teilen `time.localtime()`. Das entsprechende `struct_time`-Objekt wird hier allerdings in der koordinierten Weltzeit zurückgegeben. Das ist der Code: ```python import time time_stamp = time.time() weltzeit = time.gmtime(time_stamp) print(weltzeit) ``` Ihre Ausgabe unterscheidet sich bei dieser Funktion von Python `time` somit in einigen Details von dem Beispiel oben: ```python 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](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-string/) umzuwandeln. Dies könnte beispielhaft so aussehen: ```python import time zeitpunkt = time.localtime() leserliche_angabe = time.asctime(zeitpunkt) print(leserliche_angabe) ``` So erhalten Sie direkt eine bessere Ausgabe: ```python Mon May 27 15:25:25 2024 ``` ## `time.strftime()`: Eine Zeichenkette erstellen mit Python `time` Verschiedene Variationen sind mit `time.strftime()` möglich. Hierbei nutzen Sie unterschiedliche Formatcodes, um die aktuelle Zeit im gewünschten Format darzustellen. Um Ihnen einen Einblick in die unterschiedlichen Formatcodes zu geben, listen wir hier ein paar der wichtigsten auf: - **%Y**: Steht für die Jahreszahl 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 abgebildet - **%S**: Steht für die Sekunde von 00 bis 61 Im Code könnte das zum Beispiel so aussehen: ```python 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: ```python 27-05-2024, 15:25:25 ``` ## `time.strptime()`: Strings in `struct_time`-Objekte umwandeln Auch dafür gibt es in Python `time` ein Gegenstück: `time.strptime()` nutzt einen String, um ein `struct_time`-Objekt auszugeben. Dies ist der passende Code: ```python import time zeitpunkt = time.strptime(leserliche_angabe, "%d-%m-%Y, %H: %M:%S") print(zeitpunkt) ``` So erhalten wir wieder diese Ausgabe: ```python 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) ``` Tipp In unserem Digital Guide finden Sie viele weitere Artikel rund um die beliebte Programmiersprache. Unter anderem gibt es ein [Python-Tutorial](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-tutorial/), eine Anleitung für die [Installation von Python](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-installieren/) und einen Ratgeber über [Python-Operatoren](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-operatoren/). This is a markdown version of: [https://www.ionos.at/digitalguide/websites/web-entwicklung/python-time-modul/](https://www.ionos.at/digitalguide/websites/web-entwicklung/python-time-modul/) for AI/LLM consumption.