Ժամանակի մոդուլ Python 3-ում. Հիմնական մեթոդներ, կաղապարներ, օրինակներ

Գրեթե ցանկացած ծրագիր ժամանակ է օգտագործում: 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

Սա փաստարկների կատեգորիա է, որը կարող է ընդունվել մի շարք մեթոդներով: Այն ոչ մի տարբերակ չունի։ Անվանված ինտերֆեյսով բազմոց է։ Պարզ ասած, այս դասի տարրերին կարելի է մուտք գործել և՛ անունով, և՛ ինդեքսի համարով:

Այն բաղկացած է հետևյալ հատկանիշներից.Ժամանակի մոդուլ Python 3-ում. Հիմնական մեթոդներ, կաղապարներ, օրինակներ

Ուշադրություն. Ի տարբերություն ծրագրավորման մի շարք այլ լեզուների, այստեղ ամիսը կարող է տատանվել 1-ից մինչև 12, և ոչ թե զրոյից մինչև 11:

Հատուկ ձևաչափի վերադարձ

Օգտագործելով գործառույթը strftime () Դուք կարող եք անհատապես ստանալ տարին, ամիսը, օրը, ժամը, րոպեները, վայրկյանները և դրանք վերադարձնել տեքստային տողի: Այնուհետև այն կարող է տպվել օգտատիրոջը՝ օգտագործելով գործառույթը տպել () կամ այլ կերպ մշակված:

Որպես փաստարկ՝ ֆունկցիան կարող է վերցնել ցանկացած փոփոխական, որն ընդունում է այս մոդուլի այլ գործառույթների կողմից վերադարձված արժեք։ Օրինակ, դուք կարող եք տեղական ժամանակը փոխանցել դրան (այն կքննարկվի ավելի ուշ), որտեղից այն կհանի անհրաժեշտ տվյալները:

Ահա կոդի հատվածը, որտեղ մենք դա անում ենք:

ներմուծման ժամանակ

named_tuple = time.localtime() # get struct_time

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

տպել (ժամանակի_տող)

Եթե ​​գործարկեք այս կոդը, կցուցադրվեն ընթացիկ ամսաթիվը և ժամը: Տարրերի ձևաչափը և հաջորդականությունը կարող են փոխվել: Դրանք հետևյալն են.

  1. %Y-ը տարին է:
  2. %m ամիսն է:
  3. %d – օր.
  4. %H – ժամանակ.
  5. %M – րոպե:
  6. %S – վայրկյան:

Համապատասխանաբար, դուք կարող եք այնպես անել, որ ելքը լինի բացառապես ամսվա և օրվա համար: Դա անելու համար պարզապես պետք չէ տարին ցուցադրելու հրաման տալ: Այսինքն՝ վերը նշված բանաձեւում գրեք որպես %m/%d արգումենտ, ու վերջ։ Կամ հակառակը՝ %d/%m: 

Փաստորեն, լարային բառացիների թիվը շատ ավելի մեծ է: Ահա մի աղյուսակ, որտեղ դրանք մանրամասն նկարագրված են:Ժամանակի մոդուլ Python 3-ում. Հիմնական մեթոդներ, կաղապարներ, օրինակներ

Հետաձգեք թեման որոշակի վայրկյանով

Դրա համար օգտագործվում է գործառույթը քնել (). Ծրագրավորման առաջադրանքների բավականին մեծ բլոկը կապված է ժամանակի հետ: Երբեմն պետք է հետաձգել հաջորդ քայլը որոշակի ժամանակով։ Օրինակ, եթե Ձեզ անհրաժեշտ է շփվել տվյալների բազայի հետ, որի մշակման համար որոշակի ժամանակ է պահանջվում:

Որպես փաստարկ՝ մեթոդն օգտագործում է մի արժեք, որն արտահայտում է ալգորիթմից հաջորդ քայլը հետաձգելու վայրկյանների քանակը։

Օրինակ, այս հատվածում ուշացումը 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-ում ամսաթվերի ու ժամերի հետ աշխատելն ամենևին էլ դժվար չէ։ Բավական է հետևել այս հրահանգներին, և ամեն ինչ կստացվի։ Օգտագործելով գրադարանը ժամանակ Օգտագործողը ստանում է ժամանակի հետ աշխատելու հսկայական հնարավորություններ, ինչպիսիք են.

  1. Կասեցնել ծրագրի կատարումը որոշակի ժամանակով:
  2. Ցույց տվեք դարաշրջանից անցած ժամանակը վայրկյաններով: Այս տեղեկատվությունը կարող է օգտագործվել ժամանակն ամփոփելու կամ դրա վրա այլ մաթեմատիկական գործողություններ կատարելու համար:
  3. Փոխարկել հարմար ձևաչափի: Ավելին, ծրագրավորողն ինքը կարող է սահմանել, թե որ տարրերը կցուցադրվեն և ինչ հաջորդականությամբ։ 

Կան նաև մի շարք այլ հնարավորություններ, բայց այսօր մենք վերլուծել ենք ամենահիմնականները։ Նրանք հարմար կլինեն գրեթե ցանկացած ծրագրում, որն ինչ-որ կերպ աշխատում է ժամանակի հետ: Հաջողություն.

Թողնել գրառում