Denbora-modulua Python-en 3. Metodo nagusiak, txantiloiak, adibideak

Ia edozein programak denbora erabiltzen du. Python-en, aparteko liburutegi bat garatu da horretarako - denboraharekin hainbat ekintza egiteko erabiltzen da. Funtzionatzeko, lehenik eta behin kodearen hasieran deklaratu behar da. Lerro hau horretarako erabiltzen da:

inportatzeko denbora

Azter ditzagun modulu hau modu egokian erabiltzeko aukera desberdinak praktikan. 

Garaitik zenbat segundo izan diren zehaztea

Zeregin hori betetzeko, funtzio bat dago denbora() parametrorik hartzen ez duena. Haren itzulera-balioa 1eko urtarrilaren 1970etik zenbat segundo igaro diren da. Python-en, garai honi aro baten hasiera deitzen zaio. Unix familiako sistema eragileetan behintzat.

Windows-i dagokionez, data berdina da, baina baliteke data hori baino lehen zeuden balio negatiboekin arazoak egotea. 

Erabilitako ordu-eremua UTC da.

inportatzeko denbora

segundoak = denbora.denbora()

inprimatu ("Segunduak garaitik =", segundoak)

Funtzio honen konplexutasuna ez dela data zehatz bistaratzen da, segundo kopurua bakarrik baizik. Guztiontzat ezaguna den formatura bihurtzeko, informazio zehatza erabili behar duzu. Horretarako, funtzioa erabiltzen da denbora.ctime().

Data, ordua ohiko formatuan itzuliz

Ordua ohiko formatuan itzultzeko, metodo bat dago denbora.ctime(). Parentesiek aroa hasi zenetik zenbat segundo igaro diren adierazten duen aldagai bat edo zenbaki bat adierazten dute. Metodo honek data eta orduaren ezaugarri guztiak itzultzen ditu, data, urtea, ordu kopurua, minutuak, segundoak eta asteko eguna barne.

Funtzio hau argumenturik gabe ere erabil daiteke. Kasu honetan, uneko data, ordua eta abar itzultzen ditu.

Hona hemen hori frogatzen duen kode zati bat.

inportatzeko denbora

inprimatu(denbora.ctime())

23ko urriaren 10a 18:23:2018

Azken lerroa Python interpretea exekutatzen ari den kontsolan inprimatutakoa da. Metodoak automatikoki formateatzen ditu jasotako segundo kopurua erabiltzaileak ezagutzen duen forma batean. Egia da, goian deskribatutako elementu guztiak oso gutxitan erabiltzen dira. Oro har, ordua bakarrik lortu behar duzu edo gaurko data bakarrik. Horretarako, aparteko funtzio bat erabiltzen da - strftime(). Baina kontuan hartu baino lehen, klasea aztertu behar dugu denbora.egitura_denbora.

klase ordua.struct_time

Metodo ezberdinen bidez onar daitezkeen argumentuen kategoria bat da. Ez dauka aukerarik. Izeneko interfazea duen tupla bat da. Besterik gabe, klase honetako elementuak izenez nahiz indize-zenbakiz atzi daitezke.

Ondorengo atributuek osatzen dute.

Kontuz! Beste programazio hizkuntza batzuetan ez bezala, hemen hilabetea 1etik 12ra bitartekoa izan daiteke, eta ez zerotik 11ra.

Formatu zehatz bat itzultzea

Funtzioa erabiliz strftime() urtea, hilabetea, eguna, ordua, minutuak, segundoak banan-banan lor ditzakezu eta testu-kate batera itzul ditzakezu. Ondoren, erabiltzaileari inprima diezaioke funtzioa erabiliz inprimatu () edo bestela prozesatu.

Argumentu gisa, funtzio batek modulu honetako beste funtzioek itzultzen duten balio bat hartzen duen edozein aldagai har dezake. Adibidez, tokiko ordua transferi dezakezu (geroago eztabaidatuko da), eta hortik aterako ditu beharrezko datuak.

Hona hemen egiten dugun kode zatia.

inportatzeko denbora

named_tuple = time.localtime() # lortu struct_time

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

inprimatu(denbora_katea)

Kode hau exekutatzen baduzu, uneko data eta ordua bistaratuko dira. Elementuen formatua eta sekuentzia alda daitezke. Honako hauek dira:

1. %Y urtea da.
2. %m hilabetea da.
3. %d – eguna.
4. %H – denbora.
5. %M – minutu.
6. %S – segundo.

Horren arabera, irteera hilabetekoa eta egunekoa soilik izan dadin egin dezakezu. Horretarako, besterik gabe, ez duzu agindurik eman behar urtea bistaratzeko. Hau da, idatzi goiko formulan %m/%d argumentu gisa, eta kitto. Edo alderantziz, %d/%m. 

Izan ere, kate literalen kopurua askoz handiagoa da. Hona hemen xehetasunez deskribatzen diren taula bat.

Atzeratu hari bat segundo kopuru jakin batean

Horretarako, funtzioa erabiltzen da lo (). Programazio-zereginen bloke nahiko handi bat denboraren joan-etorriarekin lotuta dago. Batzuetan hurrengo urratsa denbora jakin baterako atzeratu behar duzu. Adibidez, prozesatzeko denbora jakin bat behar duen datu-base batekin elkarreragin behar baduzu.

Argumentu gisa, metodoak segundo kopurua adierazten duen balio bat erabiltzen du algoritmoaren hurrengo urratsa atzeratzeko.

Adibidez, zati honetan, atzerapena 10 segundokoa da.

inportatzeko denbora

pausa = 10

inprimatu(«Programa hasi zen...»)

denbora.loa(pausoa)

inprimatu(str(pausa) + » segundoak pasatu dira.»)

Ondorioz, hau lortuko dugu:

Programa hasi zen...

10 segundo pasatu ziren.

Irteeran ikus dezakegunez, programak hasi dela jakinarazi du lehenik. Eta hamar segundoren buruan, denbora hau pasatu zela idatzi zuen.

Funtzioak etenaldiaren iraupena milisegundotan zehazteko aukera ematen du. Horretarako, funtzioaren argumentuaren balio zatikiak erabiltzen ditugu lo. Adibidez, 0,1. Horrek esan nahi du atzerapena 100 milisegundokoa izango dela.

Lortu tokiko ordua

Localtime() funtzioa erabiliz, programak garaia hasi zenetik ordu-eremu zehatz batean zenbat segundotan egon den lortzen du. 

Eman dezagun kode adibide bat argitzeko.

inportatzeko denbora

emaitza = time.localtime (1575721830)

inprimatu("emaitza:", emaitza)

inprimatu(«nгод:», emaitza.tm_urtea)

inprimatu(«tm_hour:», emaitza.tm_hour)

Itzuli struct_time UTC-n, garaitik izandako segundo kopuruan oinarrituta

Ataza hau time.gmtime() erabiliz lortzen da. metodoa. Adibide bat jartzen badugu argiagoa izango da.

inportatzeko denbora

emaitza = denbora.gmtime (1575721830)

inprimatu("emaitza:", emaitza)

inprimatu(«nгод:», emaitza.tm_urtea)

inprimatu(«tm_hour:», emaitza.tm_hour)

Ekintza-sekuentzia hau aktibatzen baduzu, orduarekin, urtearekin eta ordu-eremuarekin lotutako elementu multzo bat bistaratuko da.

Itzuli aroa hasi zenetik igarotako segundo kopurua tokiko ordura automatikoki bihurtzeko

Zeregin baten aurrean bazaude, metodoa erabiliz inplementatzen da mktime(), horrek hartzen du egitura_denbora. Horren ondoren, funtzioaren alderantzizko ekintza egiten du tokiko ordua(). Hau da, tokiko ordu-eremuaren araberako ordua garaia hasi zenetik igaro diren segundo kopurua bihurtzen du, ordu-eremuari egokituta.

mktime() eta localtime() funtzioak oso lotuta daude. Kode zati honek argi erakusten du hori. Ikus dezagun nola funtzionatzen duen sakonago ulertzeko. 

inportatzeko denbora

segundo = 1575721830

# struct_time itzultzen du

t = denbora.localtime(segundoak)

inprimatu(«t1: «, t)

# struct_time-tik segundoak itzultzen ditu

s = denbora.mktime(t)

inprimatu(«ns:», segundo)

Aldagaia dela ikusten dugu segundotan garaitik 1575721830 segundo esleitu zaizkio. Lehenik eta behin, programak data zehatza, ordua eta beste parametro batzuk lortzen ditu, balio horretan oinarrituta, aldagai batean jarri t, eta gero bere edukia aldagai bihurtzen du s.

Horren ondoren, lerro berri bat jotzen du eta kontsolan segundo kopurua bistaratzen du. Egiaztatu dezakezu segundo aldagaiari esleitu zitzaion zenbaki bera izango dela.

struct_time aipatzen duten 9 zenbakien irteera data

Demagun urtea, hilabetea, data, asteko eguna eta beste hainbat balio adierazten dituzten 9 zenbaki ditugula eta kate batean konbinatu behar ditugula. Horretarako, funtzioa erabiltzen da asctime(). Onartzen du edo prest egitura_denbora, edo berdina adierazten duen 9 balioko beste edozein tupla. Horren ostean, kate bat itzultzen da, hau da, data, ordua eta beste hainbat parametro. 

Metodo hau erabiltzea oso erosoa da erabiltzaileak zehaztutako hainbat datu aldagai bakarrean sartzeko..

Esaterako, programa bat izan daiteke, non erabiltzaileak bereizita zehazten dituen eguna, hilabetea, urtea, asteko eguna eta ekitaldi batean erregistratzeari buruzko beste datu batzuk. Horren ostean, jasotako informazioa datu-basean sartzen da eta, ondoren, eskatzen duen beste pertsona bati ematen zaio.

Ordua eta data lortzea Python katean oinarrituta

Demagun erabiltzaileak hainbat datu zehaztu dituela eta lerro batean konbinatu behar ditugula pertsonak sartu duen formatuan, eta, ondoren, beste aldagai batean kopia bat egin eta formatu estandarrean berreraiki behar ditugu bertan. Horretarako, funtzioa erabiltzen da denbora.strptime().

Balio hori zehazten den aldagai bat hartzen du, eta dagoeneko ezaguna dena itzultzen digu egitura_denbora.

Argitasunerako, halako programa bat idatziko dugu.

inportatzeko denbora

time_string = «15ko ekainaren 2019a»

emaitza = denbora.strptime (denbora_katea, «%d %B, %Y»)

inprimatu (emaitza)

Asmatu zein izango den irteera? Saiatu beheko lerroari begiratu gabe asmatzen. Eta gero egiaztatu erantzuna.

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)

Hitz batean, Python-en datak eta orduak lantzea ez da batere zaila. Argibide hauek jarraitzea nahikoa da eta dena ondo aterako da. Liburutegia erabiliz denbora erabiltzaileak denborarekin lan egiteko aukera ugari ditu, hala nola:

1. Eten programaren exekuzioa denbora jakin batean.
2. Erakutsi garaitik igaro den denbora, segundotan. Informazio hori denbora laburtzeko edo beste eragiketa matematiko batzuk egiteko erabil daiteke.
3. Bihurtu formatu eroso batera. Gainera, programatzaileak berak ezarri dezake zein elementu bistaratuko diren eta zein sekuentzian. 

Beste aukera batzuk ere badaude, baina gaur oinarrizkoenak aztertu ditugu. Denborarekin nolabait funtzionatzen duen ia edozein programatan ondo etorriko dira. Zorte on.