Ein Leitfaden für Anfänger zum Python-Zeitmodul

Ein Leitfaden für Anfänger zum Python-Zeitmodul

Das Pythontime-Modul bietet viele Möglichkeiten zur Darstellung der Zeit im Code, z. B. Objekte, Zahlen und Zeichenfolgen. Es bietet auch andere Funktionen als die Darstellung der Zeit, z. B. das Warten während der Codeausführung und das Messen der Effizienz Ihres Codes.

Dieser Artikel führt Sie durch die am häufigsten verwendeten Funktionen und Objekte intime.

Am Ende dieses Artikels können Sie:

  • UnderstandKernkonzepte der Arbeit mit Datums- und Uhrzeitangaben wie Epochen, Zeitzonen und Sommerzeit

  • Represent Zeit im Code mit Floats, Tupeln undstruct_time

  • Convert zwischen verschiedenen Zeitdarstellungen

  • Suspend Thread-Ausführung

  • Measure Codeleistung mitperf_counter()

Zunächst lernen Sie, wie Sie eine Gleitkommazahl zur Darstellung der Zeit verwenden können.

Free Bonus:Click here to get our free Python Cheat Sheet zeigt Ihnen die Grundlagen von Python 3, z. B. das Arbeiten mit Datentypen, Wörterbüchern, Listen und Python-Funktionen.

Umgang mit Python-Zeit in Sekunden

Eine Möglichkeit, das Konzept der Python-Zeit in Ihrer Anwendung zu verwalten, besteht darin, eine Gleitkommazahl zu verwenden, die die Anzahl der Sekunden darstellt, die seit Beginn einer Ära vergangen sind, dh seit einem bestimmten Startpunkt.

Lassen Sie uns genauer untersuchen, was dies bedeutet, warum es nützlich ist und wie Sie damit Logik basierend auf der Python-Zeit in Ihrer Anwendung implementieren können.

Die Epoche

Im vorherigen Abschnitt haben Sie gelernt, dass Sie die Python-Zeit mit einer Gleitkommazahl verwalten können, die die seit Beginn einer Ära verstrichene Zeit darstellt.

Merriam-Webster definiert eine Ära als:

  • Ein fester Zeitpunkt, ab dem eine Reihe von Jahren gerechnet wird

  • Ein System der chronologischen Notation, das ab einem bestimmten Datum als Grundlage berechnet wird

Das wichtige Konzept, das hier zu verstehen ist, ist, dass Sie beim Umgang mit Python-Zeit einen Zeitraum berücksichtigen, der durch einen Startpunkt identifiziert wird. Beim Rechnen nennen Sie diesen Startpunktepoch.

Die Epoche ist also der Ausgangspunkt, an dem Sie den Zeitablauf messen können.

Wenn Sie beispielsweise die Epoche als Mitternacht am 1. Januar 1970 UTC definieren - die Epoche, wie sie unter Windows und den meisten UNIX-Systemen definiert ist -, können Sie Mitternacht am 2. Januar 1970 UTC als86400ekunden seit der Epoche darstellen .

Dies liegt daran, dass eine Minute 60 Sekunden, eine Stunde 60 Minuten und ein Tag 24 Stunden umfasst. 2. Januar 1970 UTC ist nur einen Tag nach der Epoche, daher können Sie grundlegende Mathematik anwenden, um zu diesem Ergebnis zu gelangen:

>>>

>>> 60 * 60 * 24
86400

Es ist auch wichtig zu beachten, dass Sie die Zeit vor der Epoche noch darstellen können. Die Anzahl der Sekunden wäre nur negativ.

Zum Beispiel würden Sie Mitternacht am 31. Dezember 1969 UTC (unter Verwendung einer Epoche vom 1. Januar 1970) als-86400 Sekunden darstellen.

Während der 1. Januar 1970 UTC eine übliche Epoche ist, ist er nicht die einzige Epoche, die beim Rechnen verwendet wird. Tatsächlich verwenden unterschiedliche Betriebssysteme, Dateisysteme und APIs manchmal unterschiedliche Epochen.

Wie Sie zuvor gesehen haben, definieren UNIX-Systeme die Epoche als 1. Januar 1970. Die Win32-API definiert die Epoche dagegen alsJanuary 1, 1601.

Sie könnentime.gmtime() verwenden, um die Epoche Ihres Systems zu bestimmen:

>>>

>>> import time
>>> time.gmtime(0)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

Im Verlauf dieses Artikels erfahren Sie mehr übergmtime() undstruct_time. Im Moment wissen Sie nur, dass Sietime verwenden können, um die Epoche mit dieser Funktion zu entdecken.

Nachdem Sie nun mehr über das Messen der Zeit in Sekunden mithilfe einer Epoche erfahren haben, werfen wir einen Blick auf dastime-Modul von Python, um zu sehen, welche Funktionen Ihnen dabei helfen.

Python-Zeit in Sekunden als Gleitkommazahl

Erstens gibttime.time() die Anzahl der Sekunden zurück, die seit der Epoche vergangen sind. Der Rückgabewert ist eine Gleitkommazahl, um Sekundenbruchteile zu berücksichtigen:

>>>

>>> from time import time
>>> time()
1551143536.9323719

Die Nummer, die Sie auf Ihrem Computer erhalten, kann sehr unterschiedlich sein, da der Referenzpunkt, der als Epoche betrachtet wird, sehr unterschiedlich sein kann.

Further Reading: Python 3.7 führtetime_ns() ein, das einen ganzzahligen Wert zurückgibt, der dieselbe seit der Epoche verstrichene Zeit darstellt, jedoch nicht in Sekunden, sondern in Nanosekunden.

Das Messen der Zeit in Sekunden ist aus mehreren Gründen nützlich:

  • Sie können einen Float verwenden, um die Differenz zwischen zwei Zeitpunkten zu berechnen.

  • Ein Float ist leichtserializable, was bedeutet, dass er für die Datenübertragung gespeichert werden kann und auf der anderen Seite intakt herauskommt.

Manchmal möchten Sie jedoch möglicherweise die aktuelle Zeit als Zeichenfolge darstellen. Dazu können Sie die Anzahl der Sekunden, die Sie vontime() erhalten, intime.ctime() übergeben.

Python-Zeit in Sekunden als Zeichenfolge für die Ortszeit

Wie Sie zuvor gesehen haben, möchten Sie möglicherweise die Python-Zeit, dargestellt als Anzahl der seit der Epoche verstrichenen Sekunden, instring konvertieren. Sie können dies mitctime() tun:

>>>

>>> from time import time, ctime
>>> t = time()
>>> ctime(t)
'Mon Feb 25 19:11:59 2019'

Hier haben Sie die aktuelle Zeit in Sekunden in der Variablent aufgezeichnet und dannt als Argument anctime() übergeben, wodurch eine Zeichenfolgendarstellung derselben Zeit zurückgegeben wird.

Technical Detail: Das Argument, das Sekunden seit der Epoche darstellt, ist gemäß der Definition vonctime()optional. Wenn Sie kein Argument übergeben, verwendetctime() standardmäßig den Rückgabewert vontime(). Sie könnten also das obige Beispiel vereinfachen:

>>>

>>> from time import ctime
>>> ctime()
'Mon Feb 25 19:11:59 2019'

Die vonctime() zurückgegebene Zeichenfolgendarstellung der Zeit, auch alstimestamp bezeichnet, wird mit der folgenden Struktur formatiert:

  1. Day of the week:Mon (Monday)

  2. Month of the year:Feb (February)

  3. Tag des Monats: 25

  4. Stunden, Minuten und Sekunden in24-hour clock: 19:11:59

  5. Jahr: 2019

Das vorherige Beispiel zeigt den Zeitstempel eines bestimmten Moments, der von einem Computer in der Region South Central in den USA erfasst wurde. Angenommen, Sie leben in Sydney, Australien, und haben denselben Befehl im selben Moment ausgeführt.

Anstelle der obigen Ausgabe wird Folgendes angezeigt:

>>>

>>> from time import time, ctime
>>> t = time()
>>> ctime(t)
'Tue Feb 26 12:11:59 2019'

Beachten Sie, dass sich die Teileday of week,day of month undhour des Zeitstempels vom ersten Beispiel unterscheiden.

Diese Ausgaben sind unterschiedlich, da der vonctime() zurückgegebene Zeitstempel von Ihrem geografischen Standort abhängt.

Note: Während das Konzept der Zeitzonen relativ zu Ihrem physischen Standort ist, können Sie dies in den Einstellungen Ihres Computers ändern, ohne es tatsächlich zu verschieben.

Die Darstellung der Zeit in Abhängigkeit von Ihrem physischen Standort heißtlocal time und verwendet ein Konzept namenstime zones.

Note: Da die Ortszeit mit Ihrem Gebietsschema zusammenhängt, berücksichtigen Zeitstempel häufig länderspezifische Details wie die Reihenfolge der Elemente in der Zeichenfolge und die Übersetzungen der Tages- und Monatsabkürzungen. ctime() ignoriert diese Details.

Lassen Sie uns etwas tiefer in den Begriff der Zeitzonen eintauchen, damit Sie die Python-Zeitdarstellungen besser verstehen können.

Zeitzonen verstehen

Eine Zeitzone ist eine Region der Welt, die einer standardisierten Zeit entspricht. Zeitzonen werden durch ihren Versatz vonCoordinated Universal Time (UTC) und möglicherweise durch die Einbeziehung der Sommerzeit definiert (auf die wir später in diesem Artikel näher eingehen werden).

Fun Fact: Wenn Sie Englisch als Muttersprache sprechen, fragen Sie sich möglicherweise, warum die Abkürzung für "Coordinated Universal Time" eher UTC als die offensichtlichere CUT ist. Wenn Sie jedoch französischer Muttersprachler sind, würden Sie es "Temps Universel Coordonné" nennen, was eine andere Abkürzung vorschlägt: TUC.

Letztendlich istInternational Telecommunication Union and the International Astronomical Union compromised on UTC die offizielle Abkürzung, so dass die Abkürzung unabhängig von der Sprache dieselbe ist.

UTC und Zeitzonen

UTC ist der Zeitstandard, anhand dessen die gesamte Zeitmessung der Welt synchronisiert (oder koordiniert) wird. Es ist selbst keine Zeitzone, sondern ein transzendenter Standard, der definiert, was Zeitzonen sind.

Die UTC-Zeit wird mitastronomical time, bezogen auf die Erdrotation, undatomic clocks genau gemessen.

Zeitzonen werden dann durch ihren Versatz von UTC definiert. In Nord- und Südamerika liegt die Central Time Zone (CT) beispielsweise fünf oder sechs Stunden hinter UTC und verwendet daher die Notation UTC-5: 00 oder UTC-6: 00.

Sydney, Australien, gehört dagegen zur Australian Eastern Time Zone (AET), die zehn oder elf Stunden vor UTC liegt (UTC + 10: 00 oder UTC + 11: 00).

Dieser Unterschied (UTC-6: 00 bis UTC + 10: 00) ist der Grund für die Varianz, die Sie in den beiden Ausgängen vonctime() in den vorherigen Beispielen beobachtet haben:

  • Zentralzeit (CT): 'Mon Feb 25 19:11:59 2019'

  • Australian Eastern Time (AET): 'Tue Feb 26 12:11:59 2019'

Diese Zeiten liegen genau 16 Stunden auseinander, was mit den oben genannten Zeitzonenversätzen übereinstimmt.

Sie fragen sich vielleicht, warum CT entweder fünf oder sechs Stunden hinter UTC liegen kann oder warum AET zehn oder elf Stunden voraus sein kann. Der Grund dafür ist, dass einige Gebiete auf der ganzen Welt, einschließlich Teilen dieser Zeitzonen, die Sommerzeit einhalten.

Sommerzeit

In den Sommermonaten treten im Allgemeinen mehrdaylight hours auf als in den Wintermonaten. Aus diesem Grund beobachten einige Gebiete im Frühling und Sommer die Sommerzeit (DST), um diese Tageslichtstunden besser nutzen zu können.

Für Orte, die die Sommerzeit beobachten, springen ihre Uhren zu Beginn des Frühlings eine Stunde voraus (und verlieren effektiv eine Stunde). Im Herbst werden die Uhren dann auf die Standardzeit zurückgesetzt.

Die Buchstaben S und D stehen für Standardzeit und Sommerzeit in Zeitzonenschreibweise:

  • Zentrale Standardzeit (CST)

  • Australian Eastern Daylight Time (AEDT)

Wenn Sie Zeiten als Zeitstempel in der Ortszeit darstellen, ist es immer wichtig zu prüfen, ob die Sommerzeit anwendbar ist oder nicht.

ctime() berücksichtigt die Sommerzeit. Die zuvor aufgeführte Ausgangsdifferenz wäre also wie folgt genauer:

  • Zentrale Standardzeit (CST): 'Mon Feb 25 19:11:59 2019'

  • Australian Eastern Daylight Time (AEDT): 'Tue Feb 26 12:11:59 2019'

Umgang mit Python-Zeit mithilfe von Datenstrukturen

Nachdem Sie nun viele grundlegende Zeitkonzepte einschließlich Epochen, Zeitzonen und UTC genau verstanden haben, sehen wir uns weitere Möglichkeiten zur Darstellung der Zeit mit dem Pythontime-Modul an.

Python-Zeit als Tupel

Anstatt eine Zahl zur Darstellung der Python-Zeit zu verwenden, können Sie eine andere primitive Datenstruktur verwenden: atuple.

Mit dem Tupel können Sie die Zeit etwas einfacher verwalten, indem Sie einige Daten abstrahieren und lesbarer machen.

Wenn Sie die Zeit als Tupel darstellen, entspricht jedes Element in Ihrem Tupel einem bestimmten Zeitelement:

  1. Year

  2. Monat als Ganzzahl zwischen 1 (Januar) und 12 (Dezember)

  3. Tag des Monats

  4. Stunde als Ganzzahl zwischen 0 (12 Uhr) und 23 (23 Uhr)

  5. Minute

  6. Zweite

  7. Wochentag als Ganzzahl zwischen 0 (Montag) und 6 (Sonntag)

  8. Tag des Jahres

  9. Sommerzeit als Ganzzahl mit folgenden Werten:

    • 1 ist die Sommerzeit.

    • 0 ist die Standardzeit.

    • -1 ist unbekannt.

Mit den bereits erlernten Methoden können Sie dieselbe Python-Zeit auf zwei verschiedene Arten darstellen:

>>>

>>> from time import time, ctime
>>> t = time()
>>> t
1551186415.360564
>>> ctime(t)
'Tue Feb 26 07:06:55 2019'

>>> time_tuple = (2019, 2, 26, 7, 6, 55, 1, 57, 0)

In diesem Fall stellen sowohlt als auchtime_tuple dieselbe Zeit dar, aber das Tupel bietet eine besser lesbare Schnittstelle für die Arbeit mit Zeitkomponenten.

Technical Detail: Wenn Sie sich die Python-Zeit ansehen, die durchtime_tuple in Sekunden dargestellt wird (wie Sie später in diesem Artikel sehen werden), werden Sie feststellen, dass sie in1551186415.0aufgelöst wird. s statt1551186415.360564.

Dies liegt daran, dass das Tupel keine Möglichkeit hat, Sekundenbruchteile darzustellen.

Während das Tupel eine übersichtlichere Oberfläche für die Arbeit mit Python-Zeit bietet, gibt es ein noch besseres Objekt:struct_time.

Python-Zeit als Objekt

Das Problem mit dem Tupelkonstrukt ist, dass es immer noch wie eine Reihe von Zahlen aussieht, obwohl es besser organisiert ist als eine einzelne, auf Sekunden basierende Zahl.

struct_time bietet eine Lösung für dieses Problem, indemNamedTuple aus Pythonscollections-Modul verwendet wird, um die Zahlenfolge des Tupels mit nützlichen Bezeichnern zu verknüpfen:

>>>

>>> from time import struct_time
>>> time_tuple = (2019, 2, 26, 7, 6, 55, 1, 57, 0)
>>> time_obj = struct_time(time_tuple)
>>> time_obj
time.struct_time(tm_year=2019, tm_mon=2, tm_mday=26, tm_hour=7, tm_min=6, tm_sec=55, tm_wday=1, tm_yday=57, tm_isdst=0)

Technical Detail: Wenn Sie aus einer anderen Sprache stammen, stehen die Begriffestruct undobject möglicherweise im Gegensatz zueinander.

In Python gibt es keinen Datentyp namensstruct. Stattdessen ist alles ein Objekt.

Der Namestruct_time leitet sich jedoch vonC-based time library ab, wobei der Datentyp tatsächlichstruct ist.

Tatsächlich verwendet dastime-Modul von Python,implemented in C, diesesstruct direkt, indem es die Header-Dateitimes.h einschließt.

Jetzt können Sie auf bestimmte Elemente vontime_objzugreifen, indem Sie den Namen des Attributs anstelle eines Index verwenden:

>>>

>>> day_of_year = time_obj.tm_yday
>>> day_of_year
57
>>> day_of_month = time_obj.tm_mday
>>> day_of_month
26

Neben der Lesbarkeit und Verwendbarkeit vonstruct_time ist es auch wichtig zu wissen, dass dies der Rückgabetyp vieler Funktionen im Pythontime-Modul ist.

Konvertieren der Python-Zeit in Sekunden in ein Objekt

Nachdem Sie die drei wichtigsten Methoden zum Arbeiten mit Python-Zeit kennengelernt haben, lernen Sie, wie Sie zwischen den verschiedenen Zeitdatentypen konvertieren.

Die Konvertierung zwischen Zeitdatentypen hängt davon ab, ob die Zeit in UTC oder Ortszeit angegeben ist.

Koordinierte Weltzeit (UTC)

Die Epoche verwendet UTC als Definition und nicht als Zeitzone. Daher sind die seit der Epoche verstrichenen Sekunden nicht abhängig von Ihrem geografischen Standort.

Dies gilt jedoch nicht fürstruct_time. Die Objektdarstellung der Python-Zeit kann Ihre Zeitzone berücksichtigen oder nicht.

Es gibt zwei Möglichkeiten, einen Float, der Sekunden darstellt, instruct_time umzuwandeln:

  1. UTC

  2. Ortszeit

Um einen Python-Zeit-Float in ein UTC-basiertesstruct_time zu konvertieren, bietet das Pythontime-Modul eine Funktion namensgmtime().

Sie habengmtime() schon einmal in diesem Artikel gesehen:

>>>

>>> import time
>>> time.gmtime(0)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

Sie haben diesen Aufruf verwendet, um die Epoche Ihres Systems zu ermitteln. Jetzt haben Sie eine bessere Grundlage, um zu verstehen, was hier tatsächlich passiert.

gmtime() konvertiert die Anzahl der seit der Epoche verstrichenen Sekunden instruct_time in UTC. In diesem Fall haben Sie0 als Anzahl der Sekunden übergeben, was bedeutet, dass Sie versuchen, die Epoche selbst in UTC zu finden.

Note: Beachten Sie, dass das Attributtm_isdst auf0 gesetzt ist. Dieses Attribut gibt an, ob die Zeitzone Sommerzeit verwendet. UTC abonniert niemals die Sommerzeit, sodass das Flag bei Verwendung vongmtime() immer0 ist.

Wie Sie zuvor gesehen haben, könnenstruct_time keine Bruchsekunden darstellen, daher ignoriertgmtime() die Bruchsekunden im Argument:

>>>

>>> import time
>>> time.gmtime(1.99)
time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=1, tm_wday=3, tm_yday=1, tm_isdst=0)

Beachten Sie, dass, obwohl die Anzahl der Sekunden, die Sie verstrichen sind, sehr nahe an2 lag, die Sekundenbruchteile von.99einfach ignoriert wurden, wie durchtm_sec=1 gezeigt.

Der Parametersecs fürgmtime() ist optional, dh Sie könnengmtime() ohne Argumente aufrufen. Dadurch wird die aktuelle Uhrzeit in UTC angezeigt:

>>>

>>> import time
>>> time.gmtime()
time.struct_time(tm_year=2019, tm_mon=2, tm_mday=28, tm_hour=12, tm_min=57, tm_sec=24, tm_wday=3, tm_yday=59, tm_isdst=0)

Interessanterweise gibt es für diese Funktion innerhalb vontime keine Umkehrung. Stattdessen müssen Sie im Python-Modulcalendarnach einer Funktion mit dem Namentimegm()uchen:

>>>

>>> import calendar
>>> import time
>>> time.gmtime()
time.struct_time(tm_year=2019, tm_mon=2, tm_mday=28, tm_hour=13, tm_min=23, tm_sec=12, tm_wday=3, tm_yday=59, tm_isdst=0)
>>> calendar.timegm(time.gmtime())
1551360204

timegm() nimmt ein Tupel (oderstruct_time, da es sich um eine Unterklasse von Tupeln handelt) und gibt die entsprechende Anzahl von Sekunden seit der Epoche zurück.

Historical Context: Wenn Sie interessiert sind, warumtimegm() nicht intime enthalten ist, können Sie die Diskussion inPython Issue 6280 anzeigen.

Kurz gesagt, es wurde ursprünglich zucalendar hinzugefügt, datime der Zeitbibliothek von C (definiert intime.h), die keine Übereinstimmungsfunktion enthält, genau folgt. Das oben erwähnte Problem schlug die Idee vor,timegm() intime zu verschieben oder zu kopieren.

Mit Fortschritten in derdatetime-Bibliothek, Inkonsistenzen bei der gepatchten Implementierung vontime.timegm() und der Frage, wie dann mitcalendar.timegm() umgegangen werden soll, lehnten die Betreuer den Patch ab und ermutigten die Verwendung vondatetime stattdessen.

Die Arbeit mit UTC ist für die Programmierung wertvoll, da es sich um einen Standard handelt. Sie müssen sich keine Gedanken über Sommerzeit, Zeitzone oder Gebietsschema machen.

Es gibt jedoch viele Fälle, in denen Sie die Ortszeit verwenden möchten. Als Nächstes erfahren Sie, wie Sie von Sekunden in Ortszeit konvertieren, damit Sie genau das tun können.

Ortszeit

In Ihrer Anwendung müssen Sie möglicherweise eher mit der Ortszeit als mit UTC arbeiten. Dastime-Modul von Python bietet eine Funktion zum Abrufen der Ortszeit aus der Anzahl der Sekunden, die seit der Epochelocaltime() vergangen sind.

Die Signatur vonlocaltime() ähneltgmtime(), da ein optionalessecs-Argument verwendet wird, mit dem einstruct_time unter Verwendung Ihrer lokalen Zeitzone erstellt wird:

>>>

>>> import time
>>> time.time()
1551448206.86196
>>> time.localtime(1551448206.86196)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=1, tm_hour=7, tm_min=50, tm_sec=6, tm_wday=4, tm_yday=60, tm_isdst=0)

Beachten Sie, dasstm_isdst=0. Da die Sommerzeit für die Ortszeit von Bedeutung ist, ändert sichtm_isdst zwischen0 und1, je nachdem, ob die Sommerzeit für die angegebene Zeit anwendbar ist oder nicht. Datm_isdst=0 gilt die Sommerzeit nicht für den 1. März 2019.

In den USA beginnt die Sommerzeit 2019 am 10. März. Um zu testen, ob sich das DST-Flag korrekt ändert, müssen Sie dem Argumentsecsekunden im Wert von 9 Tagen hinzufügen.

Um dies zu berechnen, nehmen Sie die Anzahl der Sekunden pro Tag (86.400) und multiplizieren diese mit 9 Tagen:

>>>

>>> new_secs = 1551448206.86196 + (86400 * 9)
>>> time.localtime(new_secs)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=10, tm_hour=8, tm_min=50, tm_sec=6, tm_wday=6, tm_yday=69, tm_isdst=1)

Jetzt sehen Sie, dassstruct_time das Datum des 10. März 2019 mittm_isdst=1 anzeigt. Beachten Sie auch, dasstm_hour aufgrund der Sommerzeit ebenfalls auf8 anstelle von7 im vorherigen Beispiel gesprungen ist.

Seit Python 3.3 enthältstruct_time auch zwei Attribute, die zur Bestimmung der Zeitzone vonstruct_time nützlich sind:

  1. tm_zone

  2. tm_gmtoff

Anfangs waren diese Attribute plattformabhängig, aber seit Python 3.6 sind sie auf allen Plattformen verfügbar.

Zunächst speicherttm_zone die lokale Zeitzone:

>>>

>>> import time
>>> current_local = time.localtime()
>>> current_local.tm_zone
'CST'

Hier sehen Sie, dasslocaltime() einstruct_time zurückgibt, wobei die Zeitzone aufCST (Central Standard Time) eingestellt ist.

Wie Sie zuvor gesehen haben, können Sie die Zeitzone auch anhand von zwei Informationen ermitteln, dem UTC-Offset und der Sommerzeit (falls zutreffend):

>>>

>>> import time
>>> current_local = time.localtime()
>>> current_local.tm_gmtoff
-21600
>>> current_local.tm_isdst
0

In diesem Fall können Sie sehen, dasscurrent_local21600 Sekunden hinter GMT ist, was für Greenwich Mean Time steht. GMT ist die Zeitzone ohne UTC-Offset: UTC ± 00: 00.

21600 Sekunden geteilt durch Sekunden pro Stunde (3.600) bedeutet, dasscurrent_local ZeitGMT-06:00 (oderUTC-06:00) ist.

Sie können den GMT-Offset plus den DST-Status verwenden, um abzuleiten, dasscurrent_local zur StandardzeitUTC-06:00 ist, was der zentralen Standardzeitzone entspricht.

Wie beigmtime() können Sie das Argumentsecs beim Aufrufen vonlocaltime() ignorieren und die aktuelle Ortszeit instruct_time zurückgeben:

>>>

>>> import time
>>> time.localtime()
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=1, tm_hour=8, tm_min=34, tm_sec=28, tm_wday=4, tm_yday=60, tm_isdst=0)

Im Gegensatz zugmtime() existiert die Umkehrfunktion vonlocaltime() im Pythontime-Modul. Schauen wir uns an, wie das funktioniert.

Konvertieren eines lokalen Zeitobjekts in Sekunden

Sie haben bereits gesehen, wie Sie ein UTC-Zeitobjekt mitcalendar.timegm() in Sekunden konvertieren. Um die Ortszeit in Sekunden umzuwandeln, verwenden Siemktime().

Fürmktime() müssen Sie einen Parameter namenst übergeben, der entweder die Form eines normalen 9-Tupels oder einesstruct_time-Objekts hat, das die Ortszeit darstellt:

>>>

>>> import time

>>> time_tuple = (2019, 3, 10, 8, 50, 6, 6, 69, 1)
>>> time.mktime(time_tuple)
1552225806.0

>>> time_struct = time.struct_time(time_tuple)
>>> time.mktime(time_struct)
1552225806.0

Es ist wichtig zu beachten, dasst ein Tupel sein muss, das die Ortszeit darstellt, nicht UTC:

>>>

>>> from time import gmtime, mktime

>>> # 1
>>> current_utc = time.gmtime()
>>> current_utc
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=1, tm_hour=14, tm_min=51, tm_sec=19, tm_wday=4, tm_yday=60, tm_isdst=0)

>>> # 2
>>> current_utc_secs = mktime(current_utc)
>>> current_utc_secs
1551473479.0

>>> # 3
>>> time.gmtime(current_utc_secs)
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=1, tm_hour=20, tm_min=51, tm_sec=19, tm_wday=4, tm_yday=60, tm_isdst=0)

Note: In diesem Beispiel wird angenommen, dass die OrtszeitMarch 1, 2019 08:51:19 CST ist.

Dieses Beispiel zeigt, warum es wichtig ist,mktime() mit Ortszeit anstelle von UTC zu verwenden:

  1. gmtime() ohne Argument gibt mit UTCstruct_time zurück. current_utc zeigtMarch 1, 2019 14:51:19 UTC. Dies ist genau, daCST is UTC-06:00, sodass UTC 6 Stunden vor der Ortszeit liegen sollte.

  2. mktime() versucht, die Anzahl der Sekunden zurückzugeben, wobei die Ortszeit erwartet wird, aber Sie haben stattdessencurrent_utc übergeben. Anstatt zu verstehen, dasscurrent_utc UTC-Zeit ist, wird davon ausgegangen, dass SieMarch 1, 2019 14:51:19 CST gemeint haben.

  3. gmtime() wird dann verwendet, um diese Sekunden wieder in UTC umzuwandeln, was zu einer Inkonsistenz führt. Die Zeit ist jetztMarch 1, 2019 20:51:19 UTC. Der Grund für diese Diskrepanz ist die Tatsache, dassmktime()die erwartete Ortszeit ist. Die Umstellung auf UTC erhöht also die Ortszeit umanother 6 Stunden.

Das Arbeiten mit Zeitzonen ist bekanntermaßen schwierig. Daher ist es wichtig, sich auf den Erfolg vorzubereiten, indem Sie die Unterschiede zwischen UTC und Ortszeit sowie die Python-Zeitfunktionen verstehen, die sich mit den einzelnen Zeitzonen befassen.

Konvertieren eines Python-Zeitobjekts in einen String

Während das Arbeiten mit Tupeln Spaß macht, ist es manchmal am besten, mit Strings zu arbeiten.

Zeichenfolgendarstellungen der Zeit, auch als Zeitstempel bezeichnet, verbessern die Lesbarkeit der Zeiten und können besonders nützlich sein, um intuitive Benutzeroberflächen zu erstellen.

Es gibt zwei Pythontime-Funktionen, mit denen Sie dastime.struct_time-Objekt in eine Zeichenfolge konvertieren können:

  1. asctime()

  2. strftime()

Zunächst lernen Sie "asctime ()" kennen.

asctime()

Sie verwendenasctime() zum Konvertieren eines Zeittupels oderstruct_time in einen Zeitstempel:

>>>

>>> import time
>>> time.asctime(time.gmtime())
'Fri Mar  1 18:42:08 2019'
>>> time.asctime(time.localtime())
'Fri Mar  1 12:42:15 2019'

Sowohlgmtime() als auchlocaltime() gebenstruct_time Instanzen für UTC bzw. Ortszeit zurück.

Mitasctime() können Sie entwederstruct_time in einen Zeitstempel konvertieren. asctime() funktioniert ähnlich wiectime(), von dem Sie weiter oben in diesem Artikel erfahren haben, außer dass Sie anstelle einer Gleitkommazahl ein Tupel übergeben. Auch das Zeitstempelformat ist zwischen den beiden Funktionen gleich.

Wie beictime() ist der Parameter fürasctime() optional. Wenn Sie ein Zeitobjekt nicht anasctime() übergeben, wird die aktuelle Ortszeit verwendet:

>>>

>>> import time
>>> time.asctime()
'Fri Mar  1 12:56:07 2019'

Wie beictime() werden auch die Gebietsschemainformationen ignoriert.

Einer der größten Nachteile vonasctime() ist die Formatflexibilität. strftime() löst dieses Problem, indem Sie Ihre Zeitstempel formatieren können.

strftime()

Möglicherweise befinden Sie sich in einer Position, in der das Zeichenfolgenformat vonctime() undasctime() für Ihre Anwendung nicht zufriedenstellend ist. Stattdessen möchten Sie möglicherweise Ihre Zeichenfolgen so formatieren, dass sie für Ihre Benutzer aussagekräftiger sind.

Ein Beispiel hierfür ist, wenn Sie Ihre Zeit in einer Zeichenfolge anzeigen möchten, die Gebietsschemainformationen berücksichtigt.

Zum Formatieren von Zeichenfolgen mit einemstruct_time oder Python-Zeittupel verwenden Siestrftime(), was für "Zeichenfolgeformat Zeit" steht.

strftime() akzeptiert zwei Argumente:

  1. format gibt die Reihenfolge und Form der Zeitelemente in Ihrer Zeichenfolge an.

  2. t ist ein optionales Zeittupel.

Zum Formatieren einer Zeichenfolge verwenden Siedirectives. Direktiven sind Zeichenfolgen, die mit% beginnen und ein bestimmtes Zeitelement angeben, z.

  • %d: Tag des Monats

  • %m: Monat des Jahres

  • %Y: Jahr

Beispielsweise können Sie das Datum in Ihrer Ortszeit mit dem StandardISO 8601wie folgt ausgeben:

>>>

>>> import time
>>> time.strftime('%Y-%m-%d', time.localtime())
'2019-03-01'

Further Reading: Während die Darstellung von Datumsangaben mit Python-Zeit vollständig gültig und akzeptabel ist, sollten Sie auch das Python-Moduldatetimein Betracht ziehen, das Verknüpfungen und ein robusteres Framework für die Zusammenarbeit mit Datums- und Uhrzeitangaben bietet.

Sie können beispielsweise die Ausgabe eines Datums im ISO 8601-Format mitdatetime vereinfachen:

>>>

>>> from datetime import date
>>> date(year=2019, month=3, day=1).isoformat()
'2019-03-01'

Wie Sie bereits gesehen haben, besteht ein großer Vorteil der Verwendung vonstrftime() gegenüberasctime() in der Fähigkeit, Zeitstempel zu rendern, die länderspezifische Informationen verwenden.

Wenn Sie beispielsweise Datum und Uhrzeit auf eine länderspezifische Weise darstellen möchten, können Sieasctime() nicht verwenden:

>>>

>>> from time import asctime
>>> asctime()
'Sat Mar  2 15:21:14 2019'

>>> import locale
>>> locale.setlocale(locale.LC_TIME, 'zh_HK')  # Chinese - Hong Kong
'zh_HK'
>>> asctime()
'Sat Mar  2 15:58:49 2019'

Beachten Sie, dassasctime() auch nach dem programmgesteuerten Ändern Ihres Gebietsschemas Datum und Uhrzeit im gleichen Format wie zuvor zurückgibt.

Technical Detail:LC_TIME ist die Gebietsschemakategorie für die Formatierung von Datum und Uhrzeit. Das Argumentlocale'zh_HK' kann je nach System unterschiedlich sein.

Wenn Sie jedochstrftime() verwenden, werden Sie feststellen, dass das Gebietsschema berücksichtigt wird:

>>>

>>> from time import strftime, localtime
>>> strftime('%c', localtime())
'Sat Mar  2 15:23:20 2019'

>>> import locale
>>> locale.setlocale(locale.LC_TIME, 'zh_HK')  # Chinese - Hong Kong
'zh_HK'
>>> strftime('%c', localtime())
'六  3/ 2 15:58:12 2019' 2019'

Hier haben Sie die Gebietsschemainformationen erfolgreich verwendet, da Siestrftime() verwendet haben.

Note:%c ist die Direktive für das Gebietsschema und die Uhrzeit.

Wenn das Zeittupel nicht an den Parametert übergeben wird, verwendetstrftime() standardmäßig das Ergebnis vonlocaltime(). Sie können die obigen Beispiele also vereinfachen, indem Sie das optionale zweite Argument entfernen:

>>>

>>> from time import strftime
>>> strftime('The current local datetime is: %c')
'The current local datetime is: Fri Mar  1 23:18:32 2019'

Hier haben Sie die Standardzeit verwendet, anstatt Ihre eigene als Argument zu übergeben. Beachten Sie außerdem, dass das Argumentformataus anderem Text als Formatierungsanweisungen bestehen kann.

Further Reading: Schauen Sie sich diese gründlichenlist of directives an, diestrftime() zur Verfügung stehen.

Das Pythontime-Modul enthält auch die inverse Operation zum Zurückkonvertieren eines Zeitstempels in einstruct_time-Objekt.

Konvertieren einer Python-Zeitzeichenfolge in ein Objekt

Wenn Sie mit datums- und zeitbezogenen Zeichenfolgen arbeiten, kann es sehr hilfreich sein, den Zeitstempel in ein Zeitobjekt zu konvertieren.

Um eine Zeitzeichenfolge instruct_time umzuwandeln, verwenden Siestrptime(), was für "Zeichenfolgeparse Zeit" steht:

>>>

>>> from time import strptime
>>> strptime('2019-03-01', '%Y-%m-%d')
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=60, tm_isdst=-1)

Das erste Argument fürstrptime() muss der Zeitstempel sein, den Sie konvertieren möchten. Das zweite Argument istformat, in dem sich der Zeitstempel befindet.

Der Parameterformat ist optional und standardmäßig'%a %b %d %H:%M:%S %Y'. Wenn Sie einen Zeitstempel in diesem Format haben, müssen Sie ihn daher nicht als Argument übergeben:

>>>

>>> strptime('Fri Mar 01 23:38:40 2019')
time.struct_time(tm_year=2019, tm_mon=3, tm_mday=1, tm_hour=23, tm_min=38, tm_sec=40, tm_wday=4, tm_yday=60, tm_isdst=-1)

Da einstruct_time 9 wichtige Datums- und Zeitkomponenten enthält, mussstrptime() angemessene Standardwerte für Werte für die Komponenten bereitstellen, die nicht vonstring analysiert werden können.

In den vorherigen Beispielen wurdetm_isdst=-1. Das bedeutet, dassstrptime() anhand des Zeitstempels nicht bestimmen kann, ob es sich um die Sommerzeit handelt oder nicht.

Jetzt wissen Sie, wie Sie mit Python-Zeiten und -Daten auf verschiedene Weise mit dem Modultimearbeiten können. Es gibt jedoch andere Verwendungsmöglichkeiten fürtime, außer einfach Zeitobjekte zu erstellen, Python-Zeitzeichenfolgen abzurufen und Sekunden zu verwenden, die seit der Epoche vergangen sind.

Ausführung anhalten

Eine wirklich nützliche Python-Zeitfunktion istsleep(), mit der die Ausführung des Threads für eine bestimmte Zeit unterbrochen wird.

Sie können beispielsweise die Ausführung Ihres Programms für 10 Sekunden wie folgt anhalten:

>>>

>>> from time import sleep, strftime
>>> strftime('%c')
'Fri Mar  1 23:49:26 2019'
>>> sleep(10)
>>> strftime('%c')
'Fri Mar  1 23:49:36 2019'

Ihr Programm druckt die erste formatiertedatetime-String, hält dann 10 Sekunden an und druckt schließlich die zweite formatiertedatetime-String.

Sie können auch Sekundenbruchteile ansleep() übergeben:

>>>

>>> from time import sleep
>>> sleep(0.5)

sleep() ist nützlich, um Ihr Programm aus irgendeinem Grund zu testen oder warten zu lassen. Sie müssen jedoch darauf achten, Ihren Produktionscode nicht anzuhalten, es sei denn, Sie haben gute Gründe dafür.

Vor Python 3.5 konnte ein an Ihren Prozess gesendetes Signalsleep() unterbrechen. In Version 3.5 und höher setztsleep() die Ausführung jedoch immer für mindestens die angegebene Zeitspanne aus, selbst wenn der Prozess ein Signal empfängt.

sleep() ist nur eine Python-Zeitfunktion, mit der Sie Ihre Programme testen und robuster machen können.

Leistungsmessung

Sie könnentime verwenden, um die Leistung Ihres Programms zu messen.

Sie verwenden dazuperf_counter(), die, wie der Name schon sagt, einen Leistungsindikator mit hoher Auflösung zum Messen kurzer Zeitabstände bieten.

Umperf_counter() zu verwenden, setzen Sie einen Zähler, bevor Ihr Code mit der Ausführung beginnt und nachdem die Ausführung Ihres Codes abgeschlossen ist:

>>>

>>> from time import perf_counter
>>> def longrunning_function():
...     for i in range(1, 11):
...         time.sleep(i / i ** 2)
...
>>> start = perf_counter()
>>> longrunning_function()
>>> end = perf_counter()
>>> execution_time = (end - start)
>>> execution_time
8.201258441999926

Zunächst erfasststart den Moment, bevor Sie die Funktion aufrufen. end erfasst den Moment nach der Rückkehr der Funktion. Die Gesamtausführungszeit der Funktion dauerte(end - start)ekunden.

Technical Detail: Python 3.7 führteperf_counter_ns() ein, das genauso funktioniert wieperf_counter(), jedoch Nanosekunden anstelle von Sekunden verwendet.

perf_counter() (oderperf_counter_ns()) ist die genaueste Methode, um die Leistung Ihres Codes mit einer Ausführung zu messen. Wenn Sie jedoch versuchen, die Leistung eines Code-Snippets genau zu messen, empfehle ich die Verwendung desPython timeit-Moduls.

timeit ist darauf spezialisiert, Code viele Male auszuführen, um eine genauere Leistungsanalyse zu erhalten, und hilft Ihnen, eine zu starke Vereinfachung Ihrer Zeitmessung sowie andere häufige Fallstricke zu vermeiden.

Fazit

Herzliche Glückwünsche! Sie haben jetzt eine gute Grundlage für die Arbeit mit Datums- und Uhrzeitangaben in Python.

Jetzt können Sie:

  • Verwenden Sie eine Gleitkommazahl, die die seit der Epoche verstrichenen Sekunden darstellt, um mit der Zeit umzugehen

  • Verwalten Sie die Zeit mit Tupeln undstruct_time Objekten

  • Konvertieren Sie zwischen Sekunden, Tupeln und Zeitstempelzeichenfolgen

  • Unterbrechen Sie die Ausführung eines Python-Threads

  • Messen Sie die Leistung mitperf_counter()

Darüber hinaus haben Sie einige grundlegende Konzepte zu Datum und Uhrzeit kennengelernt, z.

  • Epochen

  • UTC

  • Zeitzonen

  • Sommerzeit

Jetzt ist es Zeit für Sie, Ihr neu gewonnenes Wissen über die Python-Zeit in Ihren realen Anwendungen anzuwenden!

Weitere Lektüre

Wenn Sie mehr über die Verwendung von Datum und Uhrzeit in Python erfahren möchten, sehen Sie sich die folgenden Module an:

  • datetime: Ein robusteres Datums- und Zeitmodul in der Python-Standardbibliothek

  • timeit: Ein Modul zum Messen der Leistung von Codefragmenten

  • astropy: In der Astronomie verwendete Datenzeiten mit höherer Genauigkeit