Zäit Modul am Python 3. Main Methoden, Schablounen, Beispiller

Bal all Programm benotzt Zäit. Am Python ass eng separat Bibliothéik fir dëst entwéckelt ginn - Zäitbenotzt fir eng Vielfalt vun Aktiounen domat auszeféieren. Fir et ze schaffen, muss et als éischt am Ufank vum Code deklaréiert ginn. Dës Linn gëtt fir dëst benotzt:

Import Zäit

Loosst eis verschidden Optiounen betruechten wéi Dir dëse Modul richteg an der Praxis benotzt. 

Bestëmmung vun der Zuel vun de Sekonnen zënter der Epoch

Fir dës Aufgab ze erreechen, gëtt et eng Funktioun Zäit() déi keng Parameteren hëlt. Säi Retourwäert ass wéivill Sekonnen zënter dem 1. Januar 1970 vergaange sinn. Am Python gëtt dës Kéier den Ufank vun enger Epoch genannt. Op d'mannst an Betribssystemer vun der Unix Famill.

Wéi fir Windows ass den Datum d'selwecht, awer et kënne Probleemer mat negativen Wäerter sinn, déi virun dësem Datum waren. 

D'Zäitzone benotzt ass UTC.

Import Zäit

Sekonnen = Zäit.Zäit()

print("Seconds since Epoch =", Sekonnen)

D'Komplexitéit vun dëser Funktioun ass datt et net genau den Datum weist, awer nëmmen d'Zuel vu Sekonnen. Fir an de Format ze konvertéieren dat jidderee vertraut ass, musst Dir korrekt Informatioun benotzen. Fir dëst gëtt d'Funktioun benotzt time.ctime().

Den Datum an d'Zäit am gewéinleche Format zréckginn

Fir d'Zäit am gewéinleche Format zréckzekommen, gëtt et eng Method time.ctime(). D'Klammern weisen eng Variabel oder eng Zuel un, déi d'Zuel vun de Sekonnen uginn, déi zënter dem Ufank vun der Epoch vergaange sinn. Dës Method gëtt all Datum an Zäit Charakteristiken zréck, dorënner den Datum, Joer, Zuel vun Stonnen, Minutten, Sekonnen, an Dag vun der Woch.

Dës Funktioun kann och ouni Argumenter benotzt ginn. An dësem Fall gëtt den aktuellen Datum, Zäit, asw.

Hei ass e Code Snippet deen dëst weist.

Import Zäit

print(time.ctime())

Tue Okt 23 10:18:23 2018

Déi lescht Zeil ass wat op d'Konsol gedréckt gëtt wou de Python Dolmetscher leeft. D'Method formatéiert automatesch d'Zuel vu Sekonnen an eng Benotzer-bekannt Form. True, all déi uewe beschriwwen Elementer ginn selten benotzt. Als Regel, musst Dir entweder nëmmen d'Zäit kréien, oder nëmmen den Datum vun haut. Fir dëst gëtt eng separat Funktioun benotzt - strftime(). Awer ier mer et betruechten, musse mir d'Klass analyséieren time.struct_zeit.

Klass Zäit.struct_Zäit

Dëst ass eng Kategorie vun Argumenter déi duerch eng Rei vu Methoden ugeholl kënne ginn. Et huet keng Optiounen. Et ass en Tupel mat engem benannten Interface. Einfach gesot, d'Elementer vun dëser Klass kënne souwuel mam Numm wéi och duerch Indexnummer zougänglech sinn.

Et besteet aus de folgenden Attributer.

Opgepasst! Am Géigesaz zu enger Rei vun anere Programméierungssproochen, hei kann de Mount vun 1 bis 12 variéieren, an net vun Null bis 11.

E spezifescht Format zréckginn

Benotzt d'Funktioun strftime() Dir kënnt d'Joer, de Mount, den Dag, d'Stonn, d'Minuten, d'Sekonnen individuell kréien an se an eng Textstring zréckginn. Da kann et dem Benotzer mat der Funktioun gedréckt ginn drécken () oder anescht veraarbecht.

Als Argument kann eng Funktioun all Variabel huelen, déi e Wäert vun anere Funktiounen vun dësem Modul hëlt. Zum Beispill kënnt Dir d'lokal Zäit op et transferéieren (et gëtt méi spéit diskutéiert), aus deem se déi néideg Donnéeën erauszéien.

Hei ass de Code Snippet wou mir et maachen.

Import Zäit

named_tuple = time.localtime() # get struct_time

time_string = time.strftime(«%m/%d/%Y, %H:%M:%S», genannt_tuple)

print(Time_string)

Wann Dir dëse Code leeft, gëtt den aktuellen Datum an Zäit ugewisen. D'Format an d'Sequenz vun Elementer kënnen geännert ginn. Si sinn wéi follegt:

1. %Y ass d'Joer.
2. %m ass de Mount.
3. %d - Tag.
4. %H – Zeit.
5. %M - Minutten.
6. %S - zweet.

Deementspriechend kënnt Dir et esou maachen datt d'Ausgab exklusiv vum Mount an Dag ass. Fir dëst ze maachen, musst Dir einfach kee Kommando ginn fir d'Joer ze weisen. Dat ass, schreift an der uewe genannter Formel als Argument %m/%d, an dat ass et. Oder vice versa, %d/%m. 

Tatsächlech ass d'Zuel vun de Stringliteralen vill méi grouss. Hei ass eng Tabell wou se am Detail beschriwwe ginn.

Post e Fuedem fir eng gewëssen Zuel vu Sekonnen

Fir dëst gëtt d'Funktioun benotzt schlofen (). E zimlech grousse Block vu Programméierungsaufgaben ass mam Passage vun der Zäit verbonnen. Heiansdo musst Dir de nächste Schrëtt fir eng gewëssen Zäit ausstellen. Zum Beispill, wann Dir mat enger Datebank interagéiere musst, déi eng gewëssen Zäit brauch fir ze veraarbecht.

Als Argument benotzt d'Method e Wäert deen d'Zuel vu Sekonnen ausdréckt fir den nächste Schrëtt vum Algorithmus ze verzögeren.

Zum Beispill, an dësem Snippet ass d'Verzögerung 10 Sekonnen.

Import Zäit

Paus = 10

print(«Programm gestart...»)

time.sleep (pause)

print(str(pause) +» Sekonnen passéiert.»)

Als Resultat wäerte mir dëst kréien:

Programm gestart...

10 Sekonnen passéiert.

Wéi mir aus der Ausgab gesinn, bericht de Programm als éischt datt et ugefaang huet. An no zéng Sekonnen huet si geschriwwen datt dës Zäit vergaangen ass.

D'Funktioun erlaabt Iech d'Dauer vun der Paus a Millisekonnen ze spezifizéieren. Fir dëst ze maachen, benotze mir Fraktiounswäerter vum Funktiounsargument schlofen. Zum Beispill, 0,1. Dëst bedeit datt d'Verspéidung 100 Millisekonnen wäert sinn.

Kréien lokal Zäit

Mat der Funktioun Localtime () kritt de Programm d'Zuel vu Sekonnen zënter dem Ufank vun der Epoch an enger spezifescher Zäitzone. 

Loosst eis e Beispill Code fir Kloerheet ginn.

Import Zäit

Resultat = time.localtime(1575721830)

print ("Resultat:", Resultat)

print(«nгод:», result.tm_year)

print(«tm_hour:», result.tm_hour)

Zréck struct_time an UTC baséiert op Zuel vu Sekonnen zënter Epoch

Dës Aufgab gëtt mat der time.gmtime () erreecht. Method. Et gëtt méi kloer wa mir e Beispill ginn.

Import Zäit

Resultat = time.gmtime(1575721830)

print ("Resultat:", Resultat)

print(«nгод:», result.tm_year)

print(«tm_hour:», result.tm_hour)

Wann Dir dës Sequenz vun Aktiounen aktivéiert, da gëtt eng Rei vun Elementer am Zesummenhang mat Zäit, Joer an Zäitzon ugewisen.

Zréck d'Zuel vu Sekonnen zënter dem Ufank vun der Epoch mat automatescher Konversioun op d'Lokalzäit zréck

Wann Dir mat esou enger Aufgab konfrontéiert sidd, gëtt se mat der Method ëmgesat mktime(), wat hëlt struct_zeit. Duerno mécht et déi ëmgedréint Handlung vun der Funktioun localtime(). Dat ass, et konvertéiert d'Zäit no der lokaler Zäitzone an d'Zuel vun de Sekonnen déi zënter dem Ufank vun der Epoch vergaange sinn, ugepasst fir d'Zäitzone.

D'mktime () an localtime () Funktiounen sinn enk matenee verbonnen. Dëse Code Snippet weist dëst kloer. Loosst eis et kucken fir méi déif ze verstoen wéi et funktionnéiert. 

Import Zäit

Sekonnen = 1575721830

# gëtt struct_time zréck

t = time.localtime(seconds)

print(«t1: «, t)

# gëtt Sekonnen vun struct_time zréck

s = Zäit.mktime(t)

print("ns:", Sekonnen)

Mir gesinn, datt d'Variabel Sekonnen gouf 1575721830 Sekonnen zënter der Epoch zougewisen. Als éischt kritt de Programm den exakten Datum, Zäit an aner Parameteren, baséiert op dësem Wäert, setzt se an eng Variabel t, a konvertéiert dann säin Inhalt an eng Variabel s.

Duerno schléit eng nei Linn of a weist d'Zuel vun de Sekonnen an der Konsole. Dir kënnt iwwerpréiwen datt et déiselwecht Zuel ass, déi der Sekonne Variabel zougewisen gouf.

Ausgangsdatum vun 9 Zuelen déi op struct_time bezéien

Ugeholl datt mir 9 Zuelen hunn, déi d'Joer, de Mount, den Datum, den Dag vun der Woch an eng Rei vun anere Wäerter representéieren, a mir mussen se an eng String kombinéieren. Fir dëst gëtt d'Funktioun benotzt asctime(). Si acceptéiert oder prett struct_zeit, oder all aner Tupel vun 9 Wäerter déi fir d'selwecht steet. Duerno gëtt e String zréck, dat ass en Datum, Zäit an eng Rei vun anere Parameteren. 

Et ass ganz bequem dës Method ze benotzen fir ënnerschiddlech Benotzerspezifizéiert Daten an eng eenzeg Variabel ze bréngen..

Zum Beispill kann et e Programm sinn, wou de Benotzer den Dag, Mount, Joer, Dag vun der Woch an aner Donnéeën iwwer d'Aschreiwung fir en Event separat spezifizéiert. Duerno gëtt d'Informatioun kritt an d'Datebank agefouert an dann un eng aner Persoun erausginn, déi se freet.

Kritt Zäit an Datum baséiert op Python String

Ugeholl datt de Benotzer disparate Donnéeën uginn huet, a mir mussen se an eng Zeil am Format kombinéieren, deen d'Persoun aginn huet, an dann eng Kopie op eng aner Variabel maachen an et an e Standardformat do opbauen. Fir dëst gëtt d'Funktioun benotzt time.strptime().

Et hëlt eng Variabel an där dëse Wäert spezifizéiert ass, a bréngt eis dat scho vertraut zréck struct_zeit.

Fir Kloerheet wäerte mir esou e Programm schreiwen.

Import Zäit

time_string = «15 Juni, 2019»

result = time.strptime(time_string, «%d %B, %Y»)

Drécken (Resultat)

Guess wat d'Ausgab wäert sinn? Probéiert ze roden ouni op déi ënnescht Linn ze kucken. An dann d'Äntwert kontrolléieren.

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=166, tm_isdst=-1)

An engem Wuert, mat Datumen an Zäiten am Python ze schaffen ass guer net schwéier. Et ass genuch dës Instruktiounen ze verfollegen, an alles funktionnéiert. Benotzt d'Bibliothéik Zäit de Benotzer kritt eng grouss Zuel vu Méiglechkeete fir mat der Zäit ze schaffen, sou wéi:

1. Suspendéiert d'Ausféierung vum Programm fir eng spezifizéiert Zäit.
2. Weist d'Zäit déi zënter der Epoch vergaang ass, a Sekonnen. Dës Informatioun kann benotzt ginn fir Zäit ze summéieren oder aner mathematesch Operatiounen drop auszeféieren.
3. Konvertéiert an e praktescht Format. Ausserdeem kann de Programméierer selwer astellen wéi eng Elementer ugewise ginn a wéi eng Reihenfolge. 

Et ginn och eng Rei aner Méiglechkeeten, mä haut hu mir déi elementarsten analyséiert. Si kommen an praktesch all Programm, datt iergendwéi mat Zäit Wierker. Vill Gléck.