Time module sa Python 3. Pangunahing pamamaraan, template, halimbawa

Halos anumang programa ay gumagamit ng oras. Sa Python, isang hiwalay na aklatan ang binuo para dito - orasginamit upang magsagawa ng iba't ibang mga aksyon kasama nito. Upang magawa ito, dapat muna itong ideklara sa simula ng code. Ang linyang ito ay ginagamit para dito:

oras ng pag-import

Isaalang-alang natin ang iba't ibang opsyon kung paano gamitin nang tama ang modyul na ito sa pagsasanay. 

Pagtukoy sa bilang ng mga segundo mula noong panahon

Upang magawa ang gawaing ito, mayroong isang function oras() na walang mga parameter. Ang return value nito ay kung ilang segundo na ang lumipas mula noong Enero 1, 1970. Sa Python, ang oras na ito ay tinatawag na simula ng isang panahon. Hindi bababa sa mga operating system ng pamilyang Unix.

Tulad ng para sa Windows, ang petsa ay pareho, ngunit maaaring may mga problema sa mga negatibong halaga na bago ang petsang ito. 

Ang time zone na ginamit ay UTC.

oras ng pag-import

segundo = time.time()

print(“Secons since epoch =”, segundo)

Ang pagiging kumplikado ng function na ito ay hindi ito nagpapakita ng eksaktong petsa, ngunit ang bilang lamang ng mga segundo. Upang mag-convert sa format na pamilyar sa lahat, kailangan mong gumamit ng tumpak na impormasyon. Para dito, ginagamit ang function oras.ctime().

Ibinabalik ang petsa, oras sa karaniwang format

Upang ibalik ang oras sa karaniwang format, mayroong isang paraan oras.ctime(). Ang mga bracket ay nagpapahiwatig ng isang variable o isang numero na nagsasaad ng bilang ng mga segundo na lumipas mula noong simula ng panahon. Ibinabalik ng paraang ito ang lahat ng katangian ng petsa at oras, kabilang ang petsa, taon, bilang ng oras, minuto, segundo, at araw ng linggo.

Ang function na ito ay maaari ding gamitin nang walang mga argumento. Sa kasong ito, ibinabalik nito ang kasalukuyang petsa, oras, at iba pa.

Narito ang isang snippet ng code na nagpapakita nito.

oras ng pag-import

print(time.ctime())

Martes Okt 23 10:18:23 2018

Ang huling linya ay kung ano ang naka-print sa console kung saan tumatakbo ang Python interpreter. Awtomatikong pino-format ng pamamaraan ang natanggap na bilang ng mga segundo sa isang form na pamilyar sa gumagamit. Totoo, ang lahat ng mga elemento na inilarawan sa itaas ay bihirang ginagamit. Bilang isang tuntunin, kailangan mong makuha ang alinman sa oras lamang, o petsa lamang ngayon. Para dito, ginagamit ang isang hiwalay na function - strftime(). Ngunit bago natin ito isaalang-alang, kailangan nating i-parse ang klase oras.struct_time.

oras ng klase.struct_time

Ito ay isang kategorya ng mga argumento na maaaring tanggapin ng isang hanay ng mga pamamaraan. Wala itong anumang mga pagpipilian. Ito ay isang tuple na may pinangalanang interface. Sa madaling salita, ang mga elemento ng klase na ito ay maaaring ma-access sa parehong pangalan at sa pamamagitan ng index number.

Binubuo ito ng mga sumusunod na katangian.Time module sa Python 3. Pangunahing pamamaraan, template, halimbawa

Pansin! Hindi tulad ng iba pang mga programming language, dito ang buwan ay maaaring mula 1 hanggang 12, at hindi mula sa zero hanggang 11.

Pagbabalik ng Partikular na Format

Gamit ang function strftime() maaari mong makuha ang taon, buwan, araw, oras, minuto, segundo nang paisa-isa at ibalik ang mga ito sa isang text string. Pagkatapos ay maaari itong i-print sa gumagamit gamit ang function print () o kung hindi man ay naproseso.

Bilang argumento, maaaring kunin ng isang function ang anumang variable na kumukuha ng value na ibinalik ng iba pang function ng module na ito. Halimbawa, maaari mong ilipat ang lokal na oras dito (tatalakayin ito sa ibang pagkakataon), kung saan ilalabas nito ang kinakailangang data.

Narito ang snippet ng code kung saan namin ito ginagawa.

oras ng pag-import

named_tuple = time.localtime() # makakuha ng struct_time

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

print(time_string)

Kung patakbuhin mo ang code na ito, ang kasalukuyang petsa at oras ay ipapakita. Maaaring baguhin ang format at pagkakasunud-sunod ng mga elemento. Ang mga ito ay ang mga sumusunod:

  1. %Y ang taon.
  2. %m ang buwan.
  3. %d – araw.
  4. %H – oras.
  5. %M – minuto.
  6. %S – pangalawa.

Alinsunod dito, maaari mong gawin ito upang ang output ay eksklusibo sa buwan at araw. Upang gawin ito, hindi mo na kailangang magbigay ng isang utos upang ipakita ang taon. Iyon ay, isulat sa formula sa itaas bilang isang argumento %m/%d, at iyon na. O vice versa, %d/%m. 

Sa katunayan, ang bilang ng mga literal na string ay mas malaki. Narito ang isang talahanayan kung saan inilarawan ang mga ito nang detalyado.Time module sa Python 3. Pangunahing pamamaraan, template, halimbawa

Ipagpaliban ang isang thread para sa isang tiyak na bilang ng mga segundo

Para dito, ginagamit ang function matulog (). Ang isang medyo malaking bloke ng mga gawain sa programming ay nauugnay sa paglipas ng oras. Minsan kailangan mong ipagpaliban ang susunod na hakbang para sa isang tiyak na oras. Halimbawa, kung kailangan mong makipag-ugnayan sa isang database na tumatagal ng ilang oras upang maproseso.

Bilang isang argumento, ang pamamaraan ay gumagamit ng isang halaga na nagpapahayag ng bilang ng mga segundo upang maantala ang susunod na hakbang mula sa algorithm.

Halimbawa, sa snippet na ito, ang pagkaantala ay 10 segundo.

oras ng pag-import

pause = 10

print("Nagsimula ang programa...»)

oras.sleep(pause)

print(str(pause) + » lumipas ang mga segundo.»)

Bilang resulta, makukuha natin ito:

Nagsimula ang programa…

Lumipas ang 10 segundo.

Tulad ng nakikita natin mula sa output, ang programa ay unang nag-uulat na ito ay nagsimula. At pagkatapos ng sampung segundo, isinulat niya na lumipas na ang oras na ito.

Binibigyang-daan ka ng function na tukuyin ang tagal ng pag-pause sa mga millisecond. Upang gawin ito, gumagamit kami ng mga fractional na halaga ng argumento ng function matulog. Halimbawa, 0,1. Nangangahulugan ito na ang pagkaantala ay magiging 100 millisecond.

Kumuha ng lokal na oras

Gamit ang localtime() function, nakukuha ng program ang bilang ng mga segundo mula noong simula ng epoch sa isang partikular na time zone. 

Magbigay tayo ng isang halimbawang code para sa kalinawan.

oras ng pag-import

resulta = time.localtime(1575721830)

print("resulta:", resulta)

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

print(«tm_hour:», result.tm_hour)

Ibalik ang struct_time sa UTC batay sa bilang ng mga segundo mula noong panahon

Nakamit ang gawaing ito gamit ang time.gmtime(). paraan. Mas magiging malinaw kung magbibigay tayo ng halimbawa.

oras ng pag-import

resulta = time.gmtime(1575721830)

print("resulta:", resulta)

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

print(«tm_hour:», result.tm_hour)

Kung i-on mo ang pagkakasunud-sunod ng mga pagkilos na ito, ang isang hanay ng mga elementong nauugnay sa oras, taon at time zone ay ipapakita.

Ibalik ang bilang ng mga segundo mula noong simula ng panahon na may awtomatikong conversion sa lokal na oras

Kung nahaharap ka sa ganoong gawain, ito ay ipinatupad gamit ang pamamaraan mktime(), na tumatagal struct_time. Pagkatapos nito, ginagawa nito ang reverse action ng function lokal na Oras(). Ibig sabihin, kino-convert nito ang oras ayon sa lokal na time zone sa bilang ng mga segundo na lumipas mula noong simula ng epoch, na naayos para sa time zone.

Ang mktime() at localtime() function ay malapit na magkakaugnay. Malinaw itong ipinapakita ng snippet ng code na ito. Tingnan natin ito upang maunawaan nang mas malalim kung paano ito gumagana. 

oras ng pag-import

segundo = 1575721830

# nagbabalik ng struct_time

t = time.localtime(segundo)

print(«t1: «, t)

# nagbabalik ng mga segundo mula sa struct_time

s = oras.mktime(t)

print(«ns:», segundo)

Nakikita natin na ang variable segundo ay itinalaga 1575721830 segundo mula noong panahon. Una, nakukuha ng programa ang eksaktong petsa, oras at iba pang mga parameter, batay sa halagang ito, ilagay ito sa isang variable t, at pagkatapos ay iko-convert ang mga nilalaman nito sa isang variable s.

Pagkatapos nito, matalo ang isang bagong linya at ipinapakita ang bilang ng mga segundo sa console. Maaari mong suriin na ito ay ang parehong numero na itinalaga sa variable ng mga segundo.

Petsa ng output mula sa 9 na numero na tumutukoy sa struct_time

Ipagpalagay na mayroon tayong 9 na numero na kumakatawan sa taon, buwan, petsa, araw ng linggo at ilang iba pang mga halaga, at kailangan nating pagsamahin ang mga ito sa isang string. Para dito, ginagamit ang function asctime(). Tanggap niya o handa struct_time, o anumang iba pang tuple ng 9 na halaga na kumakatawan sa pareho. Pagkatapos nito, ibabalik ang isang string, na isang petsa, oras, at ilang iba pang mga parameter. 

Lubhang maginhawang gamitin ang paraang ito upang dalhin ang magkakaibang data na tinukoy ng user sa iisang variable..

Halimbawa, maaaring isa itong programa kung saan hiwalay na tinutukoy ng user ang araw, buwan, taon, araw ng linggo, at iba pang data tungkol sa pagpaparehistro para sa isang kaganapan. Pagkatapos nito, ang impormasyong natanggap ay ipinasok sa database at pagkatapos ay ibibigay sa ibang tao na humiling nito.

Pagkuha ng oras at petsa batay sa string ng Python

Ipagpalagay na ang user ay may tinukoy na magkakaibang data, at kailangan nating pagsamahin ang mga ito sa isang linya sa format na ipinasok ng tao, at pagkatapos ay gumawa ng isang kopya sa isa pang variable, at muling itayo ito sa isang karaniwang format doon. Para dito, ginagamit ang function time.strptime().

Kinakailangan ang isang variable kung saan tinukoy ang halagang ito, at ibinabalik ang pamilyar na sa amin struct_time.

Para sa kalinawan, magsusulat kami ng naturang programa.

oras ng pag-import

time_string = «Hunyo 15, 2019»

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

print(resulta)

Hulaan kung ano ang magiging output? Subukang hulaan nang hindi tumitingin sa ilalim na linya. At pagkatapos ay suriin ang sagot.

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)

Sa madaling salita, ang pagtatrabaho sa mga petsa at oras sa Python ay hindi mahirap sa lahat. Ito ay sapat na upang sundin ang mga tagubiling ito, at lahat ay gagana. Gamit ang Library oras ang gumagamit ay nakakakuha ng isang malaking bilang ng mga pagkakataon para sa pagtatrabaho sa oras, tulad ng:

  1. Suspindihin ang pagpapatupad ng programa para sa isang tiyak na tagal ng oras.
  2. Ipakita ang oras na lumipas mula noong panahon, sa mga segundo. Maaaring gamitin ang impormasyong ito upang buod ng oras o magsagawa ng iba pang mga operasyong matematika dito.
  3. I-convert sa isang maginhawang format. Bukod dito, ang programmer mismo ay maaaring magtakda kung aling mga elemento ang ipapakita at sa anong pagkakasunud-sunod. 

Mayroon ding ilang iba pang mga posibilidad, ngunit ngayon ay sinuri namin ang mga pinakapangunahing mga posibilidad. Magagamit ang mga ito sa halos anumang programa na kahit papaano ay gumagana sa oras. Good luck.

Mag-iwan ng Sagot