പൈത്തണിലെ സമയ ഘടകം 3. പ്രധാന രീതികൾ, ടെംപ്ലേറ്റുകൾ, ഉദാഹരണങ്ങൾ

മിക്കവാറും എല്ലാ പ്രോഗ്രാമുകളും സമയം ഉപയോഗിക്കുന്നു. പൈത്തണിൽ, ഇതിനായി ഒരു പ്രത്യേക ലൈബ്രറി വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട് - കാലംഅത് ഉപയോഗിച്ച് പലതരം പ്രവർത്തനങ്ങൾ നടത്താൻ ഉപയോഗിച്ചു. ഇത് പ്രവർത്തിക്കുന്നതിന്, അത് ആദ്യം കോഡിന്റെ തുടക്കത്തിൽ പ്രഖ്യാപിക്കണം. ഇതിനായി ഈ വരി ഉപയോഗിക്കുന്നു:

ഇറക്കുമതി സമയം

പ്രായോഗികമായി ഈ മൊഡ്യൂൾ എങ്ങനെ ശരിയായി ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ചുള്ള വ്യത്യസ്ത ഓപ്ഷനുകൾ നമുക്ക് പരിഗണിക്കാം. 

യുഗം മുതൽ സെക്കൻഡുകളുടെ എണ്ണം നിർണ്ണയിക്കുന്നു

ഈ ചുമതല നിർവഹിക്കുന്നതിന്, ഒരു ഫംഗ്ഷൻ ഉണ്ട് കാലം() അത് പരാമീറ്ററുകളൊന്നും എടുക്കുന്നില്ല. 1 ജനുവരി 1970 മുതൽ എത്ര സെക്കന്റുകൾ കടന്നുപോയി എന്നതാണ് അതിന്റെ റിട്ടേൺ മൂല്യം. പൈത്തണിൽ ഈ സമയത്തെ ഒരു യുഗത്തിന്റെ ആരംഭം എന്ന് വിളിക്കുന്നു. യുണിക്സ് കുടുംബത്തിന്റെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലെങ്കിലും.

വിൻഡോസിനെ സംബന്ധിച്ചിടത്തോളം, തീയതി ഒന്നുതന്നെയാണ്, എന്നാൽ ഈ തീയതിക്ക് മുമ്പുള്ള നെഗറ്റീവ് മൂല്യങ്ങളിൽ പ്രശ്നങ്ങൾ ഉണ്ടാകാം. 

ഉപയോഗിച്ച സമയ മേഖല UTC ആണ്.

ഇറക്കുമതി സമയം

സെക്കന്റുകൾ = സമയം.സമയം()

പ്രിന്റ് (“യുഗം മുതൽ സെക്കൻഡുകൾ =”, സെക്കൻഡ്)

ഈ ഫംഗ്‌ഷന്റെ സങ്കീർണ്ണത, അത് കൃത്യമായി തീയതി പ്രദർശിപ്പിക്കുന്നില്ല, പക്ഷേ സെക്കൻഡുകളുടെ എണ്ണം മാത്രം കാണിക്കുന്നു എന്നതാണ്. എല്ലാവർക്കും പരിചിതമായ ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യാൻ, നിങ്ങൾ കൃത്യമായ വിവരങ്ങൾ ഉപയോഗിക്കേണ്ടതുണ്ട്. ഇതിനായി, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു time.ctime().

സാധാരണ ഫോർമാറ്റിൽ തീയതിയും സമയവും നൽകുന്നു

സാധാരണ ഫോർമാറ്റിൽ സമയം തിരികെ നൽകാൻ, ഒരു രീതിയുണ്ട് time.ctime(). യുഗത്തിന്റെ ആരംഭം മുതൽ കടന്നുപോയ സെക്കൻഡുകളുടെ എണ്ണത്തെ സൂചിപ്പിക്കുന്ന ഒരു വേരിയബിൾ അല്ലെങ്കിൽ ഒരു സംഖ്യയെ ബ്രാക്കറ്റുകൾ സൂചിപ്പിക്കുന്നു. തീയതി, വർഷം, മണിക്കൂറുകളുടെ എണ്ണം, മിനിറ്റ്, സെക്കൻഡ്, ആഴ്ചയിലെ ദിവസം എന്നിവ ഉൾപ്പെടെ എല്ലാ തീയതിയും സമയ സവിശേഷതകളും ഈ രീതി നൽകുന്നു.

ഈ ഫംഗ്ഷൻ ആർഗ്യുമെന്റുകളില്ലാതെ ഉപയോഗിക്കാനും കഴിയും. ഈ സാഹചര്യത്തിൽ, അത് നിലവിലെ തീയതി, സമയം മുതലായവ നൽകുന്നു.

ഇത് തെളിയിക്കുന്ന ഒരു കോഡ് സ്നിപ്പറ്റ് ഇതാ.

ഇറക്കുമതി സമയം

പ്രിന്റ് (time.ctime())

ചൊവ്വ ഒക്ടോബർ 23 10:18:23 2018

പൈത്തൺ ഇന്റർപ്രെട്ടർ പ്രവർത്തിക്കുന്ന കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്തതാണ് അവസാന വരി. ലഭിച്ച സെക്കൻഡുകളുടെ എണ്ണം ഉപയോക്താക്കൾക്ക് പരിചിതമായ ഫോമിലേക്ക് ഈ രീതി യാന്ത്രികമായി ഫോർമാറ്റ് ചെയ്യുന്നു. ശരിയാണ്, മുകളിൽ വിവരിച്ച എല്ലാ ഘടകങ്ങളും വളരെ അപൂർവമായി മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ. ചട്ടം പോലെ, നിങ്ങൾക്ക് ഒന്നുകിൽ സമയം മാത്രമേ ലഭിക്കൂ, അല്ലെങ്കിൽ ഇന്നത്തെ തീയതി മാത്രം. ഇതിനായി, ഒരു പ്രത്യേക ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു - strftime(). എന്നാൽ ഞങ്ങൾ അത് പരിഗണിക്കുന്നതിന് മുമ്പ്, ഞങ്ങൾ ക്ലാസ് പാഴ്സ് ചെയ്യണം time.struct_time.

ക്ലാസ് സമയം.struct_time

വിവിധ രീതികളിലൂടെ അംഗീകരിക്കാൻ കഴിയുന്ന വാദങ്ങളുടെ ഒരു വിഭാഗമാണിത്. ഇതിന് ഓപ്ഷനുകളൊന്നുമില്ല. പേരിട്ട ഇന്റർഫേസുള്ള ഒരു ട്യൂപ്പിൾ ആണ് ഇത്. ലളിതമായി പറഞ്ഞാൽ, ഈ ക്ലാസിലെ ഘടകങ്ങൾ പേര് വഴിയും സൂചിക നമ്പർ വഴിയും ആക്സസ് ചെയ്യാൻ കഴിയും.

അതിൽ താഴെ പറയുന്ന ആട്രിബ്യൂട്ടുകൾ അടങ്ങിയിരിക്കുന്നു.

ശ്രദ്ധ! മറ്റ് നിരവധി പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി, ഇവിടെ മാസം 1 മുതൽ 12 വരെയാകാം, പൂജ്യം മുതൽ 11 വരെയല്ല.

ഒരു പ്രത്യേക ഫോർമാറ്റ് നൽകുന്നു

ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു strftime() നിങ്ങൾക്ക് വർഷം, മാസം, ദിവസം, മണിക്കൂർ, മിനിറ്റ്, സെക്കൻഡ് എന്നിവ വ്യക്തിഗതമായി നേടുകയും അവയെ ഒരു ടെക്സ്റ്റ് സ്‌ട്രിംഗിലേക്ക് തിരികെ നൽകുകയും ചെയ്യാം. തുടർന്ന് ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഉപയോക്താവിന് പ്രിന്റ് ചെയ്യാവുന്നതാണ് പ്രിന്റ് () അല്ലെങ്കിൽ പ്രോസസ്സ് ചെയ്തു.

ഒരു ആർഗ്യുമെന്റ് എന്ന നിലയിൽ, ഈ മൊഡ്യൂളിന്റെ മറ്റ് ഫംഗ്‌ഷനുകൾ നൽകുന്ന മൂല്യം എടുക്കുന്ന ഏത് വേരിയബിളും ഒരു ഫംഗ്‌ഷൻ എടുക്കാം. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് അതിലേക്ക് പ്രാദേശിക സമയം കൈമാറാൻ കഴിയും (അത് പിന്നീട് ചർച്ചചെയ്യും), അതിൽ നിന്ന് ആവശ്യമായ ഡാറ്റ പുറത്തെടുക്കും.

ഞങ്ങൾ ചെയ്യുന്ന കോഡ് സ്നിപ്പറ്റ് ഇതാ.

ഇറക്കുമതി സമയം

name_tuple = time.localtime() # get struct_time

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

പ്രിന്റ് (time_string)

നിങ്ങൾ ഈ കോഡ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, നിലവിലെ തീയതിയും സമയവും പ്രദർശിപ്പിക്കും. മൂലകങ്ങളുടെ ഫോർമാറ്റും ക്രമവും മാറ്റാവുന്നതാണ്. അവ ഇപ്രകാരമാണ്:

1. %Y എന്നത് വർഷമാണ്.
2. %m എന്നത് മാസമാണ്.
3. %d - ദിവസം.
4. %H - സമയം.
5. %M – മിനിറ്റ്.
6. %S – സെക്കന്റ്.

അതനുസരിച്ച്, നിങ്ങൾക്ക് ഇത് നിർമ്മിക്കാൻ കഴിയും, അതിലൂടെ ഔട്ട്പുട്ട് മാസത്തിലും ദിവസത്തിലും മാത്രമായിരിക്കും. ഇത് ചെയ്യുന്നതിന്, വർഷം പ്രദർശിപ്പിക്കുന്നതിന് നിങ്ങൾ ഒരു കമാൻഡ് നൽകേണ്ടതില്ല. അതായത്, മുകളിൽ പറഞ്ഞ ഫോർമുലയിൽ %m/%d എന്ന ആർഗ്യുമെന്റായി എഴുതുക, അത്രമാത്രം. അല്ലെങ്കിൽ തിരിച്ചും, %d/%m. 

വാസ്തവത്തിൽ, സ്ട്രിംഗ് ലിറ്ററലുകളുടെ എണ്ണം വളരെ വലുതാണ്. അവ വിശദമായി വിവരിക്കുന്ന ഒരു പട്ടിക ഇതാ.

ഒരു ത്രെഡ് ഒരു നിശ്ചിത എണ്ണം സെക്കൻഡ് മാറ്റിവയ്ക്കുക

ഇതിനായി, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു ഉറക്കം (). പ്രോഗ്രാമിംഗ് ടാസ്ക്കുകളുടെ ഒരു വലിയ ബ്ലോക്ക് സമയം കടന്നുപോകുന്നതുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. ചിലപ്പോൾ അടുത്ത ഘട്ടം ഒരു നിശ്ചിത സമയത്തേക്ക് മാറ്റിവെക്കേണ്ടി വരും. ഉദാഹരണത്തിന്, പ്രോസസ്സ് ചെയ്യുന്നതിന് ഒരു നിശ്ചിത സമയമെടുക്കുന്ന ഒരു ഡാറ്റാബേസുമായി നിങ്ങൾക്ക് സംവദിക്കണമെങ്കിൽ.

ഒരു വാദം എന്ന നിലയിൽ, അൽഗോരിതത്തിൽ നിന്നുള്ള അടുത്ത ഘട്ടം വൈകിപ്പിക്കുന്നതിന് സെക്കൻഡുകളുടെ എണ്ണം പ്രകടിപ്പിക്കുന്ന ഒരു മൂല്യം രീതി ഉപയോഗിക്കുന്നു.

ഉദാഹരണത്തിന്, ഈ സ്നിപ്പറ്റിൽ, കാലതാമസം 10 സെക്കൻഡാണ്.

ഇറക്കുമതി സമയം

താൽക്കാലികമായി നിർത്തുക = 10

പ്രിന്റ് ("പ്രോഗ്രാം ആരംഭിച്ചു...")

സമയം. ഉറക്കം (താൽക്കാലികമായി നിർത്തുക)

പ്രിന്റ് (str(താൽക്കാലികമായി നിർത്തുക) + » സെക്കന്റുകൾ കടന്നുപോയി.»)

തൽഫലമായി, ഞങ്ങൾക്ക് ഇത് ലഭിക്കും:

പ്രോഗ്രാം തുടങ്ങി...

10 സെക്കൻഡ് കഴിഞ്ഞു.

ഔട്ട്പുട്ടിൽ നിന്ന് നമുക്ക് കാണാനാകുന്നതുപോലെ, പ്രോഗ്രാം അത് ആരംഭിച്ചതായി ആദ്യം റിപ്പോർട്ട് ചെയ്യുന്നു. പത്തു സെക്കൻഡിനുശേഷം, ഈ സമയം കഴിഞ്ഞുവെന്ന് അവൾ എഴുതി.

വിരാമത്തിന്റെ ദൈർഘ്യം മില്ലിസെക്കൻഡിൽ വ്യക്തമാക്കാൻ ഫംഗ്ഷൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ ഫംഗ്ഷൻ ആർഗ്യുമെന്റിന്റെ ഫ്രാക്ഷണൽ മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നു ഉറക്കം. ഉദാഹരണത്തിന്, 0,1. ഇതിനർത്ഥം കാലതാമസം 100 മില്ലിസെക്കൻഡ് ആയിരിക്കും എന്നാണ്.

പ്രാദേശിക സമയം നേടുക

ലോക്കൽടൈം() ഫംഗ്ഷൻ ഉപയോഗിച്ച്, പ്രോഗ്രാമിന് ഒരു നിശ്ചിത സമയ മേഖലയിൽ യുഗം ആരംഭിച്ചതിന് ശേഷമുള്ള സെക്കൻഡുകളുടെ എണ്ണം ലഭിക്കുന്നു. 

വ്യക്തതയ്ക്കായി ഒരു ഉദാഹരണ കോഡ് നൽകാം.

ഇറക്കുമതി സമയം

ഫലം = 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() ഉം ലോക്കൽടൈം () ഫംഗ്ഷനുകളും പരസ്പരം ബന്ധപ്പെട്ടിരിക്കുന്നു. ഈ കോഡ് സ്നിപ്പെറ്റ് ഇത് വ്യക്തമായി കാണിക്കുന്നു. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കൂടുതൽ ആഴത്തിൽ മനസ്സിലാക്കാൻ നമുക്ക് അത് നോക്കാം. 

ഇറക്കുമതി സമയം

സെക്കന്റുകൾ = 1575721830

# റിട്ടേൺസ് സ്ട്രക്റ്റ്_ടൈം

t = സമയം. പ്രാദേശിക സമയം(സെക്കൻഡ്)

പ്രിന്റ് (“t1: «, t)

# struct_time-ൽ നിന്ന് സെക്കൻഡുകൾ തിരികെ നൽകുന്നു

s = time.mktime(t)

പ്രിന്റ് ("ns:", സെക്കൻഡ്)

വേരിയബിൾ എന്ന് നമ്മൾ കാണുന്നു നിമിഷങ്ങൾ യുഗം മുതൽ 1575721830 സെക്കൻഡ് അസൈൻ ചെയ്തിട്ടുണ്ട്. ആദ്യം, പ്രോഗ്രാമിന് കൃത്യമായ തീയതിയും സമയവും മറ്റ് പാരാമീറ്ററുകളും ലഭിക്കുന്നു, ഈ മൂല്യത്തെ അടിസ്ഥാനമാക്കി, അത് ഒരു വേരിയബിളിൽ ഇടുക t, തുടർന്ന് അതിലെ ഉള്ളടക്കങ്ങളെ ഒരു വേരിയബിളാക്കി മാറ്റുന്നു s.

അതിനുശേഷം ഒരു പുതിയ ലൈൻ അടിക്കുകയും കൺസോളിലെ സെക്കൻഡുകളുടെ എണ്ണം പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു. സെക്കൻഡ് വേരിയബിളിന് നൽകിയ അതേ നമ്പർ തന്നെയായിരിക്കുമെന്ന് നിങ്ങൾക്ക് പരിശോധിക്കാം.

struct_time സൂചിപ്പിക്കുന്ന 9 നമ്പറുകളിൽ നിന്നുള്ള ഔട്ട്‌പുട്ട് തീയതി

വർഷം, മാസം, തീയതി, ആഴ്ചയിലെ ദിവസം, മറ്റ് നിരവധി മൂല്യങ്ങൾ എന്നിവയെ പ്രതിനിധീകരിക്കുന്ന 9 സംഖ്യകൾ ഉണ്ടെന്ന് കരുതുക, അവ ഒരു സ്ട്രിംഗായി സംയോജിപ്പിക്കേണ്ടതുണ്ട്. ഇതിനായി, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു asctime(). അവൾ സ്വീകരിക്കുന്നു അല്ലെങ്കിൽ തയ്യാറാണ് ഘടന_സമയം, അല്ലെങ്കിൽ അതിനെ സൂചിപ്പിക്കുന്ന 9 മൂല്യങ്ങളുടെ മറ്റേതെങ്കിലും ട്യൂപ്പിൾ. അതിനുശേഷം, ഒരു സ്ട്രിംഗ് തിരികെ നൽകുന്നു, അത് തീയതിയും സമയവും മറ്റ് നിരവധി പാരാമീറ്ററുകളും ആണ്. 

വ്യത്യസ്ത ഉപയോക്തൃ-നിർദ്ദിഷ്ട ഡാറ്റ ഒരൊറ്റ വേരിയബിളിലേക്ക് കൊണ്ടുവരുന്നതിന് ഈ രീതി ഉപയോഗിക്കുന്നത് വളരെ സൗകര്യപ്രദമാണ്..

ഉദാഹരണത്തിന്, ഉപയോക്താവ് ദിവസം, മാസം, വർഷം, ആഴ്ചയിലെ ദിവസം എന്നിവയും ഒരു ഇവന്റിനായുള്ള രജിസ്ട്രേഷനുമായി ബന്ധപ്പെട്ട മറ്റ് ഡാറ്റയും പ്രത്യേകം വ്യക്തമാക്കുന്ന ഒരു പ്രോഗ്രാമായിരിക്കാം ഇത്. അതിനുശേഷം, ലഭിച്ച വിവരങ്ങൾ ഡാറ്റാബേസിൽ രേഖപ്പെടുത്തുകയും അത് ആവശ്യപ്പെടുന്ന മറ്റൊരു വ്യക്തിക്ക് നൽകുകയും ചെയ്യുന്നു.

പൈത്തൺ സ്ട്രിംഗിനെ അടിസ്ഥാനമാക്കി സമയവും തീയതിയും ലഭിക്കുന്നു

ഉപയോക്താവ് വ്യത്യസ്‌തമായ ഡാറ്റ വ്യക്തമാക്കിയിട്ടുണ്ടെന്ന് കരുതുക, ആ വ്യക്തി നൽകിയ ഫോർമാറ്റിൽ ഞങ്ങൾ അവയെ ഒരു വരിയിലേക്ക് സംയോജിപ്പിക്കേണ്ടതുണ്ട്, തുടർന്ന് മറ്റൊരു വേരിയബിളിലേക്ക് ഒരു പകർപ്പ് ഉണ്ടാക്കുകയും അവിടെ ഒരു സാധാരണ ഫോർമാറ്റിലേക്ക് പുനർനിർമ്മിക്കുകയും വേണം. ഇതിനായി, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു 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)

ഒറ്റവാക്കിൽ പറഞ്ഞാൽ, പൈത്തണിൽ തീയതികളും സമയവും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് ഒട്ടും ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല. ഈ നിർദ്ദേശങ്ങൾ പാലിച്ചാൽ മതി, എല്ലാം പ്രവർത്തിക്കും. ലൈബ്രറി ഉപയോഗിക്കുന്നത് കാലം സമയത്തിനനുസരിച്ച് പ്രവർത്തിക്കുന്നതിന് ഉപയോക്താവിന് ധാരാളം അവസരങ്ങൾ ലഭിക്കുന്നു, ഉദാഹരണത്തിന്:

1. ഒരു നിശ്ചിത സമയത്തേക്ക് പ്രോഗ്രാം എക്സിക്യൂഷൻ താൽക്കാലികമായി നിർത്തുക.
2. യുഗം മുതൽ കടന്നുപോയ സമയം സെക്കൻഡിൽ കാണിക്കുക. സമയം സംഗ്രഹിക്കാനോ അതിൽ മറ്റ് ഗണിത പ്രവർത്തനങ്ങൾ നടത്താനോ ഈ വിവരങ്ങൾ ഉപയോഗിക്കാം.
3. സൗകര്യപ്രദമായ ഒരു ഫോർമാറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുക. കൂടാതെ, പ്രോഗ്രാമർക്ക് തന്നെ ഏത് ഘടകങ്ങൾ പ്രദർശിപ്പിക്കണമെന്നും ഏത് ക്രമത്തിൽ ക്രമീകരിക്കാനും കഴിയും. 

മറ്റ് നിരവധി സാധ്യതകളും ഉണ്ട്, എന്നാൽ ഇന്ന് ഞങ്ങൾ ഏറ്റവും അടിസ്ഥാനപരമായവ വിശകലനം ചെയ്തു. കാലത്തിനനുസരിച്ച് പ്രവർത്തിക്കുന്ന ഏതൊരു പ്രോഗ്രാമിലും അവ ഉപയോഗപ്രദമാകും. നല്ലതുവരട്ടെ.