Բովանդակություն
- Դարաշրջանից ի վեր վայրկյանների քանակի որոշում
- Վերադարձնել ամսաթիվը, ժամը սովորական ձևաչափով
- դասաժամ.struct_time
- Հատուկ ձևաչափի վերադարձ
- Հետաձգեք թեման որոշակի վայրկյանով
- Ստացեք տեղական ժամանակ
- Վերադարձեք struct_time-ը UTC-ում՝ հիմնվելով դարաշրջանից սկսած վայրկյանների քանակի վրա
- Վերադարձեք դարաշրջանի սկզբից ի վեր վայրկյանների քանակը՝ տեղական ժամանակի ավտոմատ փոխարկումով
- Ելքի ամսաթիվը 9 թվերից, որոնք վերաբերում են struct_time-ին
- Ժամանակի և ամսաթվի ստացում Python տողի հիման վրա
Գրեթե ցանկացած ծրագիր ժամանակ է օգտագործում: Python-ում դրա համար մշակվել է առանձին գրադարան. ժամանակօգտագործվում է դրա հետ տարբեր գործողություններ կատարելու համար: Որպեսզի այն աշխատի, նախ այն պետք է հայտարարվի կոդի սկզբում: Այս տողը օգտագործվում է դրա համար.
ներմուծման ժամանակ
Եկեք քննարկենք տարբեր տարբերակներ, թե ինչպես ճիշտ օգտագործել այս մոդուլը գործնականում:
Դարաշրջանից ի վեր վայրկյանների քանակի որոշում
Այս խնդիրն իրականացնելու համար կա գործառույթ ժամանակ() որը ոչ մի պարամետր չի ընդունում: Դրա վերադարձի արժեքը այն է, թե քանի վայրկյան է անցել 1 թվականի հունվարի 1970-ից: Python-ում այս ժամանակը կոչվում է դարաշրջանի սկիզբ: Առնվազն Unix ընտանիքի օպերացիոն համակարգերում։
Ինչ վերաբերում է Windows-ին, ամսաթիվը նույնն է, բայց կարող են խնդիրներ լինել բացասական արժեքների հետ, որոնք եղել են մինչ այս ամսաթիվը:
Օգտագործված ժամային գոտին UTC է:
ներմուծման ժամանակ
վայրկյան = time.time()
տպել («Վայրկյաններ դարաշրջանից ի վեր =», վայրկյան)
Այս ֆունկցիայի բարդությունն այն է, որ այն չի ցուցադրում ճշգրիտ ամսաթիվը, այլ միայն վայրկյանների քանակը: Բոլորին ծանոթ ձևաչափին փոխարկելու համար անհրաժեշտ է ճշգրիտ տեղեկատվություն օգտագործել: Դրա համար օգտագործվում է գործառույթը time.ctime().
Վերադարձնել ամսաթիվը, ժամը սովորական ձևաչափով
Ժամանակը սովորական ձևաչափով վերադարձնելու համար կա մի մեթոդ time.ctime(). Փակագծերը նշում են փոփոխական կամ թիվ, որը ցույց է տալիս դարաշրջանի սկզբից անցած վայրկյանների քանակը: Այս մեթոդը վերադարձնում է ամսաթվի և ժամի բոլոր բնութագրերը, ներառյալ ամսաթիվը, տարին, ժամերի քանակը, րոպեները, վայրկյանները և շաբաթվա օրը:
Այս ֆունկցիան կարող է օգտագործվել նաև առանց փաստարկների։ Այս դեպքում այն վերադարձնում է ընթացիկ ամսաթիվը, ժամը և այլն:
Ահա մի կոդի հատված, որը ցույց է տալիս դա:
ներմուծման ժամանակ
տպել (time.ctime())
Երեք հոկտեմբերի 23 10:18:23 2018 թ
Վերջին տողը այն է, ինչ տպվում է այն վահանակում, որտեղ աշխատում է Python թարգմանիչը: Մեթոդը ստացված վայրկյանների քանակը ավտոմատ կերպով ձևակերպում է օգտագործողի համար ծանոթ ձևի: Ճիշտ է, վերը նկարագրված բոլոր տարրերը հազվադեպ են օգտագործվում: Որպես կանոն, դուք պետք է ստանաք կամ միայն ժամը, կամ միայն այսօրվա ամսաթիվը: Դրա համար օգտագործվում է առանձին գործառույթ՝ strftime (). Բայց նախքան այն քննարկելը, մենք պետք է վերլուծենք դասը ժամանակ.struct_time.
դասաժամ.struct_time
Սա փաստարկների կատեգորիա է, որը կարող է ընդունվել մի շարք մեթոդներով: Այն ոչ մի տարբերակ չունի։ Անվանված ինտերֆեյսով բազմոց է։ Պարզ ասած, այս դասի տարրերին կարելի է մուտք գործել և՛ անունով, և՛ ինդեքսի համարով:
Այն բաղկացած է հետևյալ հատկանիշներից.
Ուշադրություն. Ի տարբերություն ծրագրավորման մի շարք այլ լեզուների, այստեղ ամիսը կարող է տատանվել 1-ից մինչև 12, և ոչ թե զրոյից մինչև 11:
Հատուկ ձևաչափի վերադարձ
Օգտագործելով գործառույթը strftime () Դուք կարող եք անհատապես ստանալ տարին, ամիսը, օրը, ժամը, րոպեները, վայրկյանները և դրանք վերադարձնել տեքստային տողի: Այնուհետև այն կարող է տպվել օգտատիրոջը՝ օգտագործելով գործառույթը տպել () կամ այլ կերպ մշակված:
Որպես փաստարկ՝ ֆունկցիան կարող է վերցնել ցանկացած փոփոխական, որն ընդունում է այս մոդուլի այլ գործառույթների կողմից վերադարձված արժեք։ Օրինակ, դուք կարող եք տեղական ժամանակը փոխանցել դրան (այն կքննարկվի ավելի ուշ), որտեղից այն կհանի անհրաժեշտ տվյալները:
Ահա կոդի հատվածը, որտեղ մենք դա անում ենք:
ներմուծման ժամանակ
named_tuple = time.localtime() # get struct_time
time_string = time.strftime («%m/%d/%Y, %H:%M:%S», named_tuple)
տպել (ժամանակի_տող)
Եթե գործարկեք այս կոդը, կցուցադրվեն ընթացիկ ամսաթիվը և ժամը: Տարրերի ձևաչափը և հաջորդականությունը կարող են փոխվել: Դրանք հետևյալն են.
- %Y-ը տարին է:
- %m ամիսն է:
- %d – օր.
- %H – ժամանակ.
- %M – րոպե:
- %S – վայրկյան:
Համապատասխանաբար, դուք կարող եք այնպես անել, որ ելքը լինի բացառապես ամսվա և օրվա համար: Դա անելու համար պարզապես պետք չէ տարին ցուցադրելու հրաման տալ: Այսինքն՝ վերը նշված բանաձեւում գրեք որպես %m/%d արգումենտ, ու վերջ։ Կամ հակառակը՝ %d/%m:
Փաստորեն, լարային բառացիների թիվը շատ ավելի մեծ է: Ահա մի աղյուսակ, որտեղ դրանք մանրամասն նկարագրված են:
Հետաձգեք թեման որոշակի վայրկյանով
Դրա համար օգտագործվում է գործառույթը քնել (). Ծրագրավորման առաջադրանքների բավականին մեծ բլոկը կապված է ժամանակի հետ: Երբեմն պետք է հետաձգել հաջորդ քայլը որոշակի ժամանակով։ Օրինակ, եթե Ձեզ անհրաժեշտ է շփվել տվյալների բազայի հետ, որի մշակման համար որոշակի ժամանակ է պահանջվում:
Որպես փաստարկ՝ մեթոդն օգտագործում է մի արժեք, որն արտահայտում է ալգորիթմից հաջորդ քայլը հետաձգելու վայրկյանների քանակը։
Օրինակ, այս հատվածում ուշացումը 10 վայրկյան է:
ներմուծման ժամանակ
դադար = 10
տպել («Ծրագիրը սկսվել է…»)
time.sleep (դադար)
print(str(դադար) + »անցել է վայրկյան։»)
Արդյունքում մենք կստանանք հետևյալը.
Ծրագիրը մեկնարկել է…
Անցավ 10 վայրկյան։
Ինչպես տեսնում ենք արդյունքից, ծրագիրը նախ հայտնում է, որ այն սկսվել է: Իսկ տասը վայրկյան հետո նա գրել է, որ այս ժամանակն անցել է։
Ֆունկցիան թույլ է տալիս միլիվայրկյաններով նշել դադարի տևողությունը: Դա անելու համար մենք օգտագործում ենք ֆունկցիայի փաստարկի կոտորակային արժեքները քնում. Օրինակ՝ 0,1։ Սա նշանակում է, որ ուշացումը կկազմի 100 միլիվայրկյան։
Ստացեք տեղական ժամանակ
Օգտագործելով localtime() ֆունկցիան՝ ծրագիրը ստանում է որոշակի ժամային գոտում դարաշրջանի սկզբից ի վեր վայրկյանների քանակը:
Պարզության համար բերենք օրինակ կոդ:
ներմուծման ժամանակ
արդյունք = time.localtime (1575721830)
տպել («արդյունք:», արդյունք)
տպել («nгод:», result.tm_year)
տպել («tm_hour:», result.tm_hour)
Վերադարձեք struct_time-ը UTC-ում՝ հիմնվելով դարաշրջանից սկսած վայրկյանների քանակի վրա
Այս առաջադրանքը կատարվում է օգտագործելով time.gmtime(): մեթոդ. Ավելի պարզ կլինի, եթե օրինակ բերենք.
ներմուծման ժամանակ
արդյունք = time.gmtime (1575721830)
տպել («արդյունք:», արդյունք)
տպել («nгод:», result.tm_year)
տպել («tm_hour:», result.tm_hour)
Եթե դուք միացնեք գործողությունների այս հաջորդականությունը, ապա կցուցադրվի ժամանակի, տարվա և ժամային գոտու հետ կապված տարրերի մի շարք:
Վերադարձեք դարաշրջանի սկզբից ի վեր վայրկյանների քանակը՝ տեղական ժամանակի ավտոմատ փոխարկումով
Եթե դուք կանգնած եք նման խնդրի առաջ, ապա այն իրականացվում է մեթոդի կիրառմամբ mktime (), որը տանում է struct_time. Դրանից հետո այն կատարում է ֆունկցիայի հակառակ գործողությունը տեղական ժամանակ(). Այսինքն՝ այն փոխակերպում է ժամը՝ ըստ տեղական ժամային գոտու, դարաշրջանի սկզբից անցած վայրկյանների քանակի՝ հարմարեցված ժամային գոտու համար։
mktime() և localtime() ֆունկցիաները սերտորեն փոխկապակցված են: Կոդի այս հատվածը հստակ ցույց է տալիս դա: Եկեք նայենք դրան՝ ավելի խորը հասկանալու համար, թե ինչպես է այն աշխատում:
ներմուծման ժամանակ
վայրկյան = 1575721830
# վերադարձնում է struct_time
t = time.localtime (վայրկյան)
տպել («t1: «, t)
# վայրկյան է վերադարձնում struct_time-ից
s = time.mktime(t)
տպել («ns:», վայրկյան)
Մենք տեսնում ենք, որ փոփոխականը վայրկյան դարաշրջանից ի վեր նշանակվել է 1575721830 վայրկյան։ Նախ, ծրագիրը ստանում է ճշգրիտ ամսաթիվը, ժամանակը և այլ պարամետրերը, այս արժեքի հիման վրա դրեք այն փոփոխականի մեջ t, և այնուհետև դրա բովանդակությունը փոխակերպում է փոփոխականի s.
Դրանից հետո հարվածում է նոր գիծ և ցուցադրում է վահանի վայրկյանների քանակը: Դուք կարող եք ստուգել, որ դա կլինի նույն թիվը, որը նշանակվել է վայրկյանների փոփոխականին:
Ելքի ամսաթիվը 9 թվերից, որոնք վերաբերում են struct_time-ին
Ենթադրենք, մենք ունենք 9 թվեր, որոնք ներկայացնում են տարին, ամիսը, ամսաթիվը, շաբաթվա օրը և մի շարք այլ արժեքներ, և մենք պետք է դրանք միավորենք մեկ տողի մեջ: Դրա համար օգտագործվում է գործառույթը asctime (). Նա ընդունում է կամ պատրաստ է struct_time, կամ 9 արժեքների ցանկացած այլ կրկնակի, որը նույնն է: Դրանից հետո վերադարձվում է տող, որն իրենից ներկայացնում է ամսաթիվ, ժամը և մի շարք այլ պարամետրեր։
Շատ հարմար է օգտագործել այս մեթոդը, որպեսզի օգտագործողի կողմից նշված տարբեր տվյալները մեկ փոփոխականի մեջ բերվեն:.
Օրինակ, դա կարող է լինել ծրագիր, որտեղ օգտատերը առանձին նշում է օրը, ամիսը, տարին, շաբաթվա օրը և այլ տվյալներ՝ կապված իրադարձության գրանցման հետ: Դրանից հետո ստացված տեղեկատվությունը մուտքագրվում է տվյալների բազա, այնուհետև տրամադրվում է այն պահանջող մեկ այլ անձի:
Ժամանակի և ամսաթվի ստացում Python տողի հիման վրա
Ենթադրենք, որ օգտվողը նշել է տարբեր տվյալներ, և մենք պետք է դրանք միավորենք մեկ տողի մեջ այն ձևաչափով, որը մուտքագրել է անձը, այնուհետև պատճենել մեկ այլ փոփոխական և վերակառուցել այն ստանդարտ ձևաչափով: Դրա համար օգտագործվում է գործառույթը time.strptime().
Այն վերցնում է փոփոխական, որում նշված է այս արժեքը և վերադարձնում է մեզ արդեն ծանոթը struct_time.
Պարզության համար մենք կգրենք նման ծրագիր.
ներմուծման ժամանակ
time_string = «15 հունիսի, 2019»
արդյունք = time.strptime (time_string, «%d %B, %Y»)
տպել (արդյունք)
Գուշակեք, թե ինչ արդյունք կլինի: Փորձեք գուշակել՝ չնայելով հիմնականին: Եվ հետո ստուգեք պատասխանը.
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)
Մի խոսքով, Python-ում ամսաթվերի ու ժամերի հետ աշխատելն ամենևին էլ դժվար չէ։ Բավական է հետևել այս հրահանգներին, և ամեն ինչ կստացվի։ Օգտագործելով գրադարանը ժամանակ Օգտագործողը ստանում է ժամանակի հետ աշխատելու հսկայական հնարավորություններ, ինչպիսիք են.
- Կասեցնել ծրագրի կատարումը որոշակի ժամանակով:
- Ցույց տվեք դարաշրջանից անցած ժամանակը վայրկյաններով: Այս տեղեկատվությունը կարող է օգտագործվել ժամանակն ամփոփելու կամ դրա վրա այլ մաթեմատիկական գործողություններ կատարելու համար:
- Փոխարկել հարմար ձևաչափի: Ավելին, ծրագրավորողն ինքը կարող է սահմանել, թե որ տարրերը կցուցադրվեն և ինչ հաջորդականությամբ։
Կան նաև մի շարք այլ հնարավորություններ, բայց այսօր մենք վերլուծել ենք ամենահիմնականները։ Նրանք հարմար կլինեն գրեթե ցանկացած ծրագրում, որն ինչ-որ կերպ աշխատում է ժամանակի հետ: Հաջողություն.