Eine vollständige Zusammenfassung der Zeitverarbeitung in Python

1.Übersicht

Das Datum/Uhrzeit-Modul wird hauptsächlich zur Darstellung von Daten verwendet, die wir oft als Jahr, Monat, Tag, Stunde, Minute und Sekunde bezeichnen. Das Kalendermodul wird hauptsächlich zur Darstellung von Jahr, Monat, Tag, Wochentag und anderen Informationen verwendet Das Zeitmodul konzentriert sich hauptsächlich auf Stunden, Minuten und Sekunden. Aus funktionaler Sicht können wir davon ausgehen, dass die drei in einer komplementären Beziehung stehen und sich jeweils auf einen Bereich konzentrieren. Für Benutzer ist es praktisch, geeignete Module für unterschiedliche Zwecke auszuwählen.

2. Beginnen wir mit dem Zeitmodul

Um das Zeitmodul zu erlernen, müssen wir zunächst mehrere zeitbezogene Konzepte kennen:

(1)Epoche

Angenommen, wir möchten die Zeit in Millisekunden ausdrücken, beispielsweise 1.000.000 Millisekunden. Dann gibt es ein Problem, das gelöst werden muss. Was ist der Ausgangspunkt von 1.000.000 Millisekunden? Wenn ich beispielsweise sage, dass Sie 1,8 Meter groß sind, bezieht sich diese Höhe auf den Boden, auf dem Sie stehen. Dieser Zeitbezugspunkt ist die Epoche. Im Unix-System ist dieser Bezugspunkt der Zeitpunkt um 0:00 Uhr am 1. Januar 1970.

(2)GMT, UTC

Wir haben oben gesagt, dass diese Epoche den Ausgangspunkt von 1970 darstellt. Auf welche Basiszeit bezieht sich dieses Jahr 1970 also? Im Allgemeinen ist sie relativ zur Greenwich-Zeit, auch GMT-Zeit (Greenwich Mean Time) und auch UTC-Zeit (Coordinated Universal Time) genannt. Warum hat eine Zeitbasis zwei Namen? Historisch gesehen kam GMT zuerst, dann UTC.

UTC ist der Zeitstandard, den wir jetzt verwenden, und GMT ist der alte Zeitmessstandard. UTC berechnet die Zeit basierend auf Atomuhren, während GMT die Zeit basierend auf der Rotation und Umdrehung der Erde berechnet.

UTC kann also als tatsächliche Referenzzeit betrachtet werden und die Abweichung von GMT von UTC beträgt 0.

In Wirklichkeit verfügt unser Computer über ein Hardwaremodul RCT, das die UTC-Zeit in Echtzeit aufzeichnet. Dieses Modul wird von einer separaten Batterie gespeist und ist auch dann nicht betroffen, wenn es ausgeschaltet ist.

Mit der Zeitbasis Epoche und der Basis UTC können wir eine Zeit genau darstellen.

(3)DST, Tzone

Obwohl wir eine Zeit bereits genau darstellen können, müssen wir die Zeit in vielen Fällen immer noch an die tatsächliche Situation in der Region anpassen. Die gebräuchlichste ist die Zeitzone, tzone, die meiner Meinung nach jeder kennt.

Wenn wir zu diesem Zeitpunkt die Zeit 5:05 nennen, müssen wir 5:05 hinzufügen, in welcher Zeitzone, um eine Zeit genau zu beschreiben.

Eine weitere Zeitanpassung ist die Sommerzeit.

DST steht für Daylight Saving Time, was bedeutet, dass die Zeit künstlich angepasst wird, um das Sonnenlicht voll auszunutzen und den Stromverbrauch zu senken, was von den Richtlinien und Vorschriften verschiedener Länder und Regionen abhängt. Wenn Sie beispielsweise im Winter um 7 Uhr aufwachen, im Sommer jedoch um 6 Uhr, wird die Zeit im Sommer künstlich um 1 Stunde verlängert. Dadurch glauben Sie immer noch, dass Sie aufwachen um 7 Uhr, tatsächlich ist es aber eine Stunde früher.

Also, für diejenigen unter uns, die neugierig sind, müssen wir fragen: Woher kennt Python die Werte von Tzone und DST? Die Antwort liegt in Umgebungsvariablen.

Hier verwenden wir zur Erläuterung nur Linux als Beispiel.

Unter Linux gibt es eine TZ-Umgebungsvariable, deren Wert etwa so aussieht:

CST+08EDT, M4.1.0, M10.5.0, diese Zeichenfolge kann wie folgt interpretiert werden: Trennen Sie sie durch Leerzeichen und teilen Sie sie in drei Teile

CST+08 EDT, M4.1.0, M10.5.0

Die CST im ersten Teil stellt den Namen der Zeitzone dar, die China Standard Time ist, was wir Peking-Zeit nennen. +8 bedeutet Peking-Zeit plus 8 Stunden ist UTC-Zeit

Der zweite Teil EDT stellt den Namen DST dar. Wir sagen, dass die Sommerzeit aufgrund unterschiedlicher Richtlinien und Vorschriften in verschiedenen Ländern und Regionen unterschiedlich ist. Sie können nach EDT auch einen Zeitanpassungswert hinzufügen, wie nach CST, aber in unserem Land ist dies nur der Fall zwischen 1986 und 1992. Die Sommerzeit wurde 2015 für einen bestimmten Zeitraum eingeführt, wurde jedoch inzwischen abgeschafft, sodass keine Notwendigkeit besteht, später eine Anpassungszeit hinzuzufügen.

Der dritte Teil stellt die Start- und Endzeit der DST-Implementierung dar, wir werden ihn nicht im Detail erklären.

(4) Zeitdarstellung, Erfassung, Umrechnung

Die grundlegende Methode, um Zeit im Zeitmodul zu erhalten, ist

t = time.time()

Es gibt die Anzahl der Sekunden von der Epoche bis heute (ausgedrückt als Gleitkommazahl) unter Verwendung der UTC-Zeit zurück.

Wir möchten diese Anzahl von Sekunden natürlich in die Form von Jahr, Monat, Tag, Stunde, Minute und Sekunde umwandeln. Diese Konvertierung ist in zwei Typen unterteilt: Einer verwendet weiterhin UTC-Zeit und der andere verwendet die angepasste Zeit in unserer Zeitzone.

Das Zeitmodul bietet uns zwei Methoden,

time. gmtime(t)
time.localtime(t)

Beide geben eine Instanz der Klasse struct_time mit den folgenden Eigenschaften zurück:

Im Vergleich zur in Sekunden ausgedrückten Zeit ist dieser Ausdruck für uns besser verständlich.

Wenn diese beiden Funktionen ohne Übergabe von Parametern aufgerufen werden, rufen sie intern time.time() auf und verwenden die zurückgegebenen Sekunden zur Konvertierung.

Im Gegenteil, Python bietet auch Methoden zum Konvertieren dieser beiden struct_times in Sekunden.

Die Methode

calendar.timegm() wird verwendet, um UTCs struct_time (das Rückgabeobjekt von gmtime) in die Anzahl der Sekunden ab Epoche umzuwandeln

time.mktime() wird verwendet, um das an die Zeitzone angepasste Objekt struct_time (d. h. das Rückgabeobjekt von localtime) in die Anzahl der Sekunden ab der Epoche umzuwandeln

Das heißt, die mktime-Methode findet zuerst die Zeitzonen- und Sommerzeitinformationen im System und verwendet diese Informationen, um struct_time anzupassen und sie dann in Sekunden umzuwandeln.

Ein weiterer häufiger Bedarf besteht darin, zwischen einer Zeit und einer Zeichenfolge zu konvertieren, die die Zeit darstellt.

Strftime und strptime im Zeitmodul werden hierfür verwendet.

Jeder sollte ihre Bedeutung erkennen, indem er sich ihre Namen ansieht,

strftime ist eine String-Formatzeit, die zum Formatieren der Zeit in einen String verwendet wird

strptime ist die String-Analysezeit, die zum Parsen von Strings in Zeit verwendet wird.

Es ist zu beachten, dass die Zeiten hier alle struct_time-Objekte sind.

Über das Formatieren der Zeit ist es ein sehr einfaches Wissen. Hier leihe ich mir den Inhalt aus dem offiziellen Website-Dokument.

Zusätzlich zu diesen beiden Funktionen bietet das Zeitmodul auch zwei praktische Methoden, um die Zeit in einen String umzuwandeln

asctime wird verwendet, um ein struct_time-Objekt in eine Standardzeichenfolge mit 24 Zeichen zu konvertieren, wie unten gezeigt:

Sonntag, 20. Juni 1993, 23:21:05 Uhr

Die ctime-Methode hat die gleiche Funktion wie asctime, außer dass sie intern Sekunden empfängt und diese zunächst über localtime in struct_time umwandelt und dann mit asctime identisch ist.

Das Obige ist der Kerninhalt des Zeitmoduls. Ich versuche, eine Formel zu verwenden, um mir diese APIs zu merken

time点time得秒数

传入gm, local time得struct_time

要想变回原秒数

你得传回calendar.timegm和time. mktime

string f和string p

格式化时间靠哥俩

你要还是嫌费事

asctime ,ctime来助力

专门帮你转字符串

前者接收struct_time

后者专门处理秒数

分工合作不费力

学好time模块基本功

做个时间的明白人！

Als nächstes beginnen wir mit dem Erlernen des Datetime-Moduls.

3.datetime-Modul (1) Übersicht Das Zeitmodul löst das Problem des Erhaltens und Darstellens der Zeit, und das Datum/Uhrzeit-Modul löst außerdem das Problem des schnellen Erhaltens und Bearbeitens der Jahres-, Monats-, Tages-, Stunden-, Minuten- und Sekundeninformationen in der Zeit.

Um es einfach auszudrücken: Es gibt drei Kernklassen in diesem Modul. Die Datumsklasse repräsentiert das Jahr, den Monat und den Tag, und die Zeitklasse repräsentiert die Stunden, Minuten, Sekunden und Millisekunden. Verwechseln Sie sie hier nicht mit dem Zeitmodul . Ein Jingle kann helfen, sich an diese Situation zu erinnern:

Es gibt keine Zeit in der Zeit

Versteckt in Datetime

Ist die Bearbeitung schlecht? Na ja, das denke ich auch.

Die Datetime-Klasse ist eine Kombination aus Datum und Uhrzeit.

Eine Sache muss im Voraus erklärt werden. Sowohl die Zeitklasse als auch die Datums-/Uhrzeitklasse haben ein tzinfo-Objekt, das die Zeitzoneninformationen des Zeit- oder Datums-/Uhrzeitobjekts enthält bewusst, und es kann genau in Sekunden seit der Epoche umgerechnet werden.

Wenn diese Eigenschaft auf „None“ gesetzt ist, verfügt das Zeitobjekt oder das Datum/Uhrzeit-Objekt über keine Zeitzoneninformationen. Ob es sich insbesondere um die Ortszeit oder die UTC-Zeit handelt, müssen wir im Programm selbst entscheiden.

Die Ortszeit, über die wir hier sprechen, bezieht sich auf die Zeit in unserer Zeitzone, und UTC-Zeit bezieht sich auf die internationale Standardzeit, die Greenwich-Zeit. Das Gleiche unten.

Bitte denken Sie daran, dass das Datum keine Zeitzoneninformationen enthält.

（2）从创建datetime开始

创建datetime对象，我最常用的办法如下

dt=datetime.datetime.fromtimestamp(time.time())

以上，time.time()获得自epoch开始的秒数，fromtimestamp方法会将这个秒数转变成一个datetime对象。

这里有一个问题，这个datetime对象究竟是utc的还是local的？

答案是local的，这是该方法的默认行为。如果你在fromtimestamp方法中传入一个表示时区的参数，即tzinfo对象，就会按传入的时区信息进行转换。

获得表示当前local时间的datetime对象，还有两个简便方法

datetime. datetime. now()
datetime. datetime. today()

以上我们得到的都是local的datetime对象，如何获得utc的datetime对象呢？有两个办法

datetime. datetime. utcfromtimestamp()
datetime. datetime. utcnow()

我们还可以从字符串中创建datetime对象，

其内部还是先调用的time模块中的striptime方法，获取struct_time对象，再利用struct_time对象中的年月日时分秒信息构建datetime对象。

同样的，datetime类也提供了strftime()，asctime()，ctime()方法，相信不说你也知道是做什么的了。

datetime类还提供了一个combine方法，用来将一个date对象和一个time对象组合成一个datetime对象。

需要注意的是，datetime模块中出现timestamp时，一般可将其理解成time.time()返回的秒数

（3）date和time的创建

date对象的创建和datetime非常相似，

datetime. date. today()

datetime.date.fromtimestamp()都可以创建一个date对象。

当然，你也可以通过构造方法传入年月日来创建date对象。

相比之下，time对象的创建就很有限，只能通过

datetime.time([hour[, minute[, second[, microsecond[, tzinfo]]]]])

这个方法创建。

（4）以上三个对象的操作和timedelta类

在实际使用中，我们有一大块需求就是对日期进行比较和加减运算。得益于python的操作符重载能力，python中可以方便地对

date对象之间，或者datetime对象之间进行小于(

注意，这里仅限于同类对象之间，而且，不包括time对象之间。

两个date对象作减，或者两个datetime对象之间作减，差值用一个timedelta对象表示。

同理，一个date 对象或者datetime对象也可以加或者减一个timedelta对象。

一个timedelta对象含有三个属性:days,seconds, microseconds,days属性可以取负值，另外两个属性都只能是正值。

你可以用total_seconds()方法获得一个timedelta对象的秒数表示。

两个timedelta对象之间可加，可减，但不能做大小比较，因为这样没什么意义。

一个timedelta对象还可以与整数相乘，或通过//操作与一个整数相除。

还可以取反，或者用abs函数获得绝对值

4.无总结，不进步

本文的目的不在于详细说明python处理时间日期的api如何使用，而是想通过一个概览的形式，让大家抓住time和datetime模块的设计结构，从而能够清楚这些模块提供了哪些能力，在需要的时候能够想起来去用，至于查详细的api，应该是可以轻松解决的。

Das obige ist der detaillierte Inhalt vonEine vollständige Zusammenfassung der Zeitverarbeitung in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!