Python 3 හි කාල මොඩියුලය. ප්‍රධාන ක්‍රම, සැකිලි, උදාහරණ

ඕනෑම වැඩසටහනක් පාහේ කාලය භාවිතා කරයි. Python හි, මේ සඳහා වෙනම පුස්තකාලයක් සංවර්ධනය කර ඇත - කාලයඑය සමඟ විවිධ ක්රියාවන් සිදු කිරීමට භාවිතා කරයි. එය වැඩ කිරීමට නම්, එය මුලින්ම කේතයේ ආරම්භයේදී ප්රකාශ කළ යුතුය. මේ සඳහා මෙම රේඛාව භාවිතා වේ:

ආනයන කාලය

ප්රායෝගිකව මෙම මොඩියුලය නිවැරදිව භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ විවිධ විකල්ප සලකා බලමු. 

යුගයේ සිට තත්පර ගණන තීරණය කිරීම

මෙම කාර්යය ඉටු කිරීම සඳහා, කාර්යයක් ඇත කාලය() එය කිසිදු පරාමිතියක් නොගනී. එහි ප්‍රතිලාභ අගය 1 ජනවාරි 1970 සිට තත්පර කීයක් ගතවී ඇත්ද යන්නයි. පයිතන් හි මෙම කාලය යුගයක ආරම්භය ලෙස හැඳින්වේ. අවම වශයෙන් Unix පවුලේ මෙහෙයුම් පද්ධතිවල.

වින්ඩෝස් සම්බන්ධයෙන් ගත් කල, දිනය සමාන වේ, නමුත් මෙම දිනයට පෙර පැවති සෘණ අගයන් සමඟ ගැටළු ඇති විය හැකිය. 

භාවිතා කරන කාල කලාපය UTC වේ.

ආනයන කාලය

තත්පර = time.time()

මුද්‍රණය ("යුගයේ සිට තත්පර =", තත්පර)

මෙම කාර්යයේ සංකීර්ණත්වය වන්නේ එය හරියටම දිනය නොපෙන්වයි, නමුත් තත්පර ගණන පමණි. සෑම කෙනෙකුටම හුරුපුරුදු ආකෘතියට පරිවර්තනය කිරීම සඳහා, ඔබ නිවැරදි තොරතුරු භාවිතා කළ යුතුය. මේ සඳහා, කාර්යය භාවිතා වේ time.ctime().

සුපුරුදු ආකෘතියෙන් දිනය, වේලාව නැවත ලබා දීම

සුපුරුදු ආකෘතියෙන් කාලය ආපසු ලබා දීමට, ක්රමයක් තිබේ time.ctime(). වරහන් මඟින් යුගය ආරම්භයේ සිට ගත වූ තත්පර ගණන දැක්වෙන විචල්‍යයක් හෝ සංඛ්‍යාවක් දක්වයි. මෙම ක්‍රමය සතියේ දිනය, වර්ෂය, පැය ගණන, මිනිත්තු, තත්පර සහ දිනය ඇතුළුව සියලුම දින සහ වේලාව ලක්ෂණ ලබා දෙයි.

මෙම කාර්යය තර්ක නොමැතිව ද භාවිතා කළ හැකිය. මෙම අවස්ථාවේදී, එය වත්මන් දිනය, වේලාව සහ යනාදිය ලබා දෙයි.

මෙන්න මේ බව විදහා දක්වන කේත කොටසකි.

ආනයන කාලය

මුද්‍රණය (time.ctime())

23 ඔක්තෝබර් 10 18:23:2018 අඟහරුවාදා

අවසාන පේළිය වන්නේ පයිතන් පරිවර්තකය ක්‍රියාත්මක වන කොන්සෝලයට මුද්‍රණය කර ඇති දෙයයි. ක්‍රමය ස්වයංක්‍රීයව ලැබුණු තත්පර ගණන පරිශීලක-හඳුනන පෝරමයකට හැඩගස්වයි. ඇත්ත, ඉහත විස්තර කර ඇති සියලුම මූලද්රව්ය කලාතුරකින් භාවිතා වේ. රීතියක් ලෙස, ඔබට ලබා ගත යුත්තේ කාලය පමණක් හෝ අද දිනය පමණි. මේ සඳහා වෙනම කාර්යයක් භාවිතා කරයි - strftime (). නමුත් අපි එය සලකා බැලීමට පෙර, අපි පන්තිය විග්‍රහ කළ යුතුයි time.struct_time.

පන්ති කාලය.struct_time

මෙය විවිධ ක්‍රම මගින් පිළිගත හැකි තර්ක කාණ්ඩයකි. එයට විකල්ප නොමැත. එය නම් කරන ලද අතුරු මුහුණතක් සහිත ටුපල් එකකි. සරලව කිවහොත්, මෙම පන්තියේ මූලද්‍රව්‍ය නාමයෙන් සහ දර්ශක අංකයෙන් ප්‍රවේශ විය හැක.

එය පහත ගුණාංග වලින් සමන්විත වේ.Python 3 හි කාල මොඩියුලය. ප්‍රධාන ක්‍රම, සැකිලි, උදාහරණ

අවධානය! වෙනත් ක්‍රමලේඛන භාෂා ගණනාවක් මෙන් නොව, මෙහි මාසය 1 සිට 12 දක්වා වෙනස් විය හැකි අතර, බිංදුවේ සිට 11 දක්වා නොවේ.

විශේෂිත ආකෘතියක් ආපසු ලබා දීම

කාර්යය භාවිතා කිරීම strftime () ඔබට වසර, මාසය, දිනය, පැය, මිනිත්තු, තත්පර තනි තනිව ලබාගෙන ඒවා පෙළ පෙළකට ආපසු ලබා දිය හැක. එවිට එය ශ්‍රිතය භාවිතයෙන් පරිශීලකයාට මුද්‍රණය කළ හැක මුද්‍රණය () නැතහොත් වෙනත් ආකාරයකින් සකස් කර ඇත.

තර්කයක් ලෙස, ශ්‍රිතයකට මෙම මොඩියුලයේ අනෙකුත් ශ්‍රිතයන් මඟින් අගයක් ලබා දෙන ඕනෑම විචල්‍යයක් ගත හැක. උදාහරණයක් ලෙස, ඔබට දේශීය වේලාව එයට මාරු කළ හැකිය (එය පසුව සාකච්ඡා කරනු ඇත), එයින් එය අවශ්‍ය දත්ත ලබා ගනී.

මෙන්න අපි ඒක කරන කෝඩ් ස්නිපට් එක.

ආනයන කාලය

name_tuple = time.localtime() # get struct_time

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

මුද්‍රණය (කාල_තන්තුව)

ඔබ මෙම කේතය ධාවනය කරන්නේ නම්, වත්මන් දිනය සහ වේලාව පෙන්වනු ඇත. මූලද්රව්යවල ආකෘතිය සහ අනුපිළිවෙල වෙනස් කළ හැකිය. ඒවා පහත පරිදි වේ.

  1. %Y යනු වසරයි.
  2. %m යනු මාසයයි.
  3. %d - දවස.
  4. %H - කාලය.
  5. %M - මිනිත්තු.
  6. %S - දෙවන.

ඒ අනුව, ප්‍රතිදානය මාසය සහ දිනය පමණක් වන පරිදි ඔබට එය සෑදිය හැකිය. මෙය සිදු කිරීම සඳහා, ඔබට වසර පෙන්වීමට විධානයක් ලබා දීමට අවශ්ය නොවේ. එනම් ඉහත සූත්‍රයේ %m/%d තර්කයක් ලෙස ලියන්න, එපමණයි. හෝ අනෙක් අතට, %d/%m. 

ඇත්ත වශයෙන්ම, තන්තු අක්ෂර ගණන වඩා විශාල වේ. මෙන්න ඒවා විස්තරාත්මකව විස්තර කර ඇති වගුවකි.Python 3 හි කාල මොඩියුලය. ප්‍රධාන ක්‍රම, සැකිලි, උදාහරණ

නිශ්චිත තත්පර ගණනකට නූල් කල් දමන්න

මේ සඳහා, කාර්යය භාවිතා වේ නිදාගන්න (). ක්‍රමලේඛන කාර්යයන් තරමක් විශාල කොටසක් කාලයාගේ ඇවෑමෙන් සම්බන්ධ වේ. සමහර විට ඔබට ඊළඟ පියවර යම් කාලයක් සඳහා කල් දැමීමට සිදු වේ. උදාහරණයක් ලෙස, ඔබට සැකසීමට යම් කාලයක් ගතවන දත්ත සමුදායක් සමඟ අන්තර් ක්‍රියා කිරීමට අවශ්‍ය නම්.

තර්කයක් ලෙස, ක්‍රමය ඇල්ගොරිතමයෙන් ඊළඟ පියවර ප්‍රමාද කිරීමට තත්පර ගණන ප්‍රකාශ කරන අගයක් භාවිතා කරයි.

උදාහරණයක් ලෙස, මෙම කොටසෙහි, ප්රමාදය තත්පර 10 කි.

ආනයන කාලය

විරාමය = 10

මුද්‍රණය ("වැඩසටහන ආරම්භ කර ඇත...")

කාලය. නින්ද (විරාමය)

මුද්‍රණය (str(විරාමය) + »තත්පර ගත විය.»)

ප්රතිඵලයක් වශයෙන්, අපට මෙය ලැබෙනු ඇත:

වැඩසටහන ආරම්භ...

තත්පර 10 ක් ගත විය.

නිමැවුමෙන් අපට පෙනෙන පරිදි, වැඩසටහන මුලින්ම එය ආරම්භ වී ඇති බව වාර්තා කරයි. තත්පර දහයකට පසු, මෙම කාලය ගෙවී ගිය බව ඇය ලිවීය.

විරාමයේ කාලසීමාව මිලි තත්පර වලින් නියම කිරීමට ශ්‍රිතය ඔබට ඉඩ සලසයි. මෙය සිදු කිරීම සඳහා, අපි ශ්‍රිත තර්කයේ භාගික අගයන් භාවිතා කරමු නින්ද. උදාහරණයක් ලෙස, 0,1. මෙයින් අදහස් වන්නේ ප්රමාදය මිලි තත්පර 100 ක් වනු ඇති බවයි.

දේශීය වේලාව ලබා ගන්න

Localtime() ශ්‍රිතය භාවිතයෙන්, වැඩසටහනට නිශ්චිත කාල කලාපයක යුගය ආරම්භයේ සිට තත්පර ගණන ලැබේ. 

පැහැදිලිකම සඳහා උදාහරණ කේතයක් දෙමු.

ආනයන කාලය

ප්‍රතිඵලය = time.localtime(1575721830)

මුද්රණය ("ප්රතිඵල:", ප්රතිඵලය)

මුද්‍රණය ("nгод:", result.tm_year)

මුද්‍රණය («tm_hour:», result.tm_hour)

යුගයේ සිට තත්පර ගණන මත පදනම්ව UTC හි struct_time ආපසු ලබා දෙන්න

මෙම කාර්යය සාක්ෂාත් කරගනු ලබන්නේ time.gmtime() භාවිතා කරමිනි. ක්රමය. අපි උදාහරණයක් දුන්නොත් එය වඩාත් පැහැදිලි වනු ඇත.

ආනයන කාලය

ප්‍රතිඵලය = time.gmtime(1575721830)

මුද්රණය ("ප්රතිඵල:", ප්රතිඵලය)

මුද්‍රණය ("nгод:", result.tm_year)

මුද්‍රණය («tm_hour:», result.tm_hour)

ඔබ මෙම ක්‍රියා අනුපිළිවෙල ක්‍රියාත්මක කළහොත්, කාලය, වර්ෂය සහ කාල කලාපයට අදාළ මූලද්‍රව්‍ය සමූහයක් දර්ශනය වේ.

දේශීය වේලාවට ස්වයංක්‍රීය පරිවර්තනයක් සමඟ යුගයේ ආරම්භයේ සිට තත්පර ගණන ආපසු දෙන්න

ඔබ එවැනි කාර්යයකට මුහුණ දෙන්නේ නම්, එය ක්රමවේදය භාවිතයෙන් ක්රියාත්මක වේ mktime()ගතවන කාලයයි struct_time. ඊට පසු, එය ශ්රිතයේ ප්රතිලෝම ක්රියාව සිදු කරයි දේශීය වේලාව(). එනම්, එය දේශීය කාල කලාපයට අනුව කාලය, කාල කලාපය සඳහා සකස් කරන ලද යුගය ආරම්භයේ සිට ගත වූ තත්පර ගණනට පරිවර්තනය කරයි.

mktime() සහ localtime() ශ්‍රිතයන් එකිනෙකට සමීපව බැඳී ඇත. මෙම කේත කොටස පැහැදිලිව පෙන්නුම් කරයි. එය ක්‍රියාත්මක වන ආකාරය වඩාත් ගැඹුරින් අවබෝධ කර ගැනීමට අපි එය දෙස බලමු. 

ආනයන කාලය

තත්පර = 1575721830

# ව්‍යුහ_කාලය ආපසු ලබා දෙයි

t = වෙලාව.දේශීය වේලාව(තත්පර)

මුද්‍රණය (“t1: «, t)

# struct_time සිට තත්පර # ආපසු ලබා දෙයි

s = time.mktime(t)

මුද්‍රණය ("ns:", තත්පර)

විචල්‍යය බව අපට පෙනේ තත්පර යුගයේ සිට තත්පර 1575721830ක් පවරා ඇත. පළමුව, වැඩසටහනට නිශ්චිත දිනය, වේලාව සහ අනෙකුත් පරාමිතීන් ලැබේ, මෙම අගය මත පදනම්ව, එය විචල්‍යයකට දමන්න. t, ඉන්පසු එහි අන්තර්ගතය විචල්‍යයක් බවට පරිවර්තනය කරයි s.

ඊට පසු, නව රේඛාවක් ඉවත් කර කොන්සෝලයේ තත්පර ගණන පෙන්වයි. එය තත්පර විචල්‍යයට පවරා ඇති අංකයම දැයි ඔබට පරීක්ෂා කළ හැකිය.

ප්‍රතිදාන දිනය struct_time වෙත යොමු වන අංක 9 කින්

අපට වසර, මාසය, දිනය, සතියේ දිනය සහ වෙනත් අගයන් ගණනාවක් නියෝජනය කරන සංඛ්‍යා 9ක් ඇතැයි සිතමු, අපි ඒවා එක පෙළකට ඒකාබද්ධ කළ යුතුයි. මේ සඳහා, කාර්යය භාවිතා වේ asctime(). ඇය පිළිගන්නවා හෝ සූදානම් struct_time, හෝ එයම නියෝජනය කරන අගයන් 9 කින් යුත් වෙනත් ටියුපල්. ඊට පසු, තන්තුවක් ආපසු එවනු ලැබේ, එය දිනය, වේලාව සහ වෙනත් පරාමිති ගණනාවක් වේ. 

අසමාන පරිශීලක-නිශ්චිත දත්ත තනි විචල්‍යයකට ගෙන ඒම සඳහා මෙම ක්‍රමය භාවිතා කිරීම ඉතා පහසු වේ..

උදාහරණයක් ලෙස, එය පරිශීලකයා විසින් දිනය, මාසය, වර්ෂය, සතියේ දිනය සහ සිදුවීමක් සඳහා ලියාපදිංචි වීම සම්බන්ධ වෙනත් දත්ත වෙන වෙනම සඳහන් කරන වැඩසටහනක් විය හැක. ඊට පසු, ලැබුණු තොරතුරු දත්ත ගබඩාවට ඇතුළත් කර එය ඉල්ලා සිටින වෙනත් පුද්ගලයෙකුට නිකුත් කරනු ලැබේ.

Python string මත පදනම්ව වේලාව සහ දිනය ලබා ගැනීම

පරිශීලකයා අසමාන දත්ත සඳහන් කර ඇතැයි සිතමු, අපි ඒවා පුද්ගලයා ඇතුළත් කළ ආකෘතියේ එක් පේළියකට ඒකාබද්ධ කළ යුතු අතර, පසුව වෙනත් විචල්‍යයකට පිටපතක් සාදා එහි සම්මත ආකෘතියකට නැවත ගොඩනඟන්න. මේ සඳහා, කාර්යය භාවිතා වේ 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. පහසු ආකෘතියකට පරිවර්තනය කරන්න. එපමණක් නොව, කුමන මූලද්‍රව්‍ය පෙන්විය යුතුද සහ කුමන අනුපිළිවෙලකින්ද යන්න ක්‍රමලේඛකයා විසින්ම සැකසිය හැකිය. 

තවත් අවස්ථා ගණනාවක් ද ඇත, නමුත් අද අපි වඩාත් මූලික ඒවා විශ්ලේෂණය කර ඇත. කාලයත් සමඟ කෙසේ හෝ ක්‍රියා කරන ඕනෑම වැඩසටහනක පාහේ ඒවා ප්‍රයෝජනවත් වනු ඇත. වාසනාව.

ඔබමයි