பைத்தானில் நேர தொகுதி 3. முக்கிய முறைகள், வார்ப்புருக்கள், எடுத்துக்காட்டுகள்

ஏறக்குறைய எந்த நிரலும் நேரத்தைப் பயன்படுத்துகிறது. பைத்தானில், இதற்காக ஒரு தனி நூலகம் உருவாக்கப்பட்டுள்ளது - நேரம்அதைக் கொண்டு பல்வேறு செயல்களைச் செய்யப் பயன்படுகிறது. அதைச் செயல்படுத்த, குறியீட்டின் தொடக்கத்தில் முதலில் அதை அறிவிக்க வேண்டும். இந்த வரி இதற்குப் பயன்படுத்தப்படுகிறது:

இறக்குமதி நேரம்

நடைமுறையில் இந்த தொகுதியை எவ்வாறு சரியாகப் பயன்படுத்துவது என்பது குறித்த பல்வேறு விருப்பங்களைக் கருத்தில் கொள்வோம். 

சகாப்தத்திலிருந்து வினாடிகளின் எண்ணிக்கையைத் தீர்மானித்தல்

இந்த பணியை நிறைவேற்ற, ஒரு செயல்பாடு உள்ளது நேரம்() இது எந்த அளவுருக்களையும் எடுக்காது. ஜனவரி 1, 1970ல் இருந்து எத்தனை வினாடிகள் கடந்துவிட்டன என்பதுதான் அதன் திரும்பும் மதிப்பு. பைத்தானில், இந்த நேரம் ஒரு சகாப்தத்தின் தொடக்கம் என்று அழைக்கப்படுகிறது. குறைந்தபட்சம் யூனிக்ஸ் குடும்பத்தின் இயக்க முறைமைகளில்.

விண்டோஸைப் பொறுத்தவரை, தேதி ஒன்றுதான், ஆனால் இந்த தேதிக்கு முன் இருந்த எதிர்மறை மதிப்புகளில் சிக்கல்கள் இருக்கலாம். 

பயன்படுத்தப்படும் நேர மண்டலம் UTC ஆகும்.

இறக்குமதி நேரம்

நொடிகள் = நேரம்.நேரம்()

அச்சு ("சகாப்தத்திலிருந்து வினாடிகள் =", வினாடிகள்)

இந்த செயல்பாட்டின் சிக்கலானது என்னவென்றால், அது சரியாக தேதியைக் காட்டாது, ஆனால் வினாடிகளின் எண்ணிக்கை மட்டுமே. அனைவருக்கும் தெரிந்த வடிவத்திற்கு மாற்ற, நீங்கள் துல்லியமான தகவலைப் பயன்படுத்த வேண்டும். இதற்காக, செயல்பாடு பயன்படுத்தப்படுகிறது time.ctime().

வழக்கமான வடிவமைப்பில் தேதி, நேரம் திரும்பும்

வழக்கமான வடிவத்தில் நேரத்தை திரும்பப் பெற, ஒரு முறை உள்ளது time.ctime(). சகாப்தத்தின் தொடக்கத்திலிருந்து கடந்துவிட்ட வினாடிகளின் எண்ணிக்கையைக் குறிக்கும் ஒரு மாறி அல்லது எண்ணை அடைப்புக்குறிகள் குறிப்பிடுகின்றன. இந்த முறை தேதி, ஆண்டு, மணிநேர எண்ணிக்கை, நிமிடங்கள், வினாடிகள் மற்றும் வாரத்தின் நாள் உட்பட அனைத்து தேதி மற்றும் நேர பண்புகளையும் வழங்குகிறது.

இந்த செயல்பாட்டை வாதங்கள் இல்லாமல் பயன்படுத்தலாம். இந்த வழக்கில், இது தற்போதைய தேதி, நேரம் மற்றும் பலவற்றை வழங்குகிறது.

இதை நிரூபிக்கும் குறியீடு துணுக்கு இங்கே உள்ளது.

இறக்குமதி நேரம்

அச்சு(time.ctime())

செவ்வாய் அக்டோபர் 23 10:18:23 2018

பைதான் மொழிபெயர்ப்பான் இயங்கும் கன்சோலில் அச்சிடப்பட்டதே கடைசி வரி. பெறப்பட்ட வினாடிகளின் எண்ணிக்கையை பயனருக்குத் தெரிந்த படிவத்தில் இந்த முறை தானாகவே வடிவமைக்கிறது. உண்மை, மேலே விவரிக்கப்பட்ட அனைத்து கூறுகளும் அரிதாகவே பயன்படுத்தப்படுகின்றன. ஒரு விதியாக, நீங்கள் நேரத்தை மட்டுமே பெற வேண்டும், அல்லது இன்றைய தேதியை மட்டுமே பெற வேண்டும். இதற்காக, ஒரு தனி செயல்பாடு பயன்படுத்தப்படுகிறது - strftime(). ஆனால் அதைக் கருத்தில் கொள்வதற்கு முன், வகுப்பை அலச வேண்டும் நேரம்.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() மற்றும் localtime() செயல்பாடுகள் நெருக்கமாகப் பின்னிப் பிணைந்துள்ளன. இந்த குறியீடு துணுக்கு இதை தெளிவாக நிரூபிக்கிறது. இது எவ்வாறு செயல்படுகிறது என்பதை இன்னும் ஆழமாகப் புரிந்துகொள்ள அதைப் பார்ப்போம். 

இறக்குமதி நேரம்

வினாடிகள் = 1575721830

# struct_time திரும்புகிறது

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»)

அச்சு (முடிவு)

வெளியீடு என்னவாக இருக்கும் என்று யூகிக்கவா? அடிப்பகுதியைப் பார்க்காமல் யூகிக்க முயற்சிக்கவும். பின்னர் பதிலைச் சரிபார்க்கவும்.

நேரம்

ஒரு வார்த்தையில், பைத்தானில் தேதிகள் மற்றும் நேரங்களுடன் வேலை செய்வது கடினம் அல்ல. இந்த வழிமுறைகளைப் பின்பற்றினால் போதும், எல்லாம் சரியாகிவிடும். நூலகத்தைப் பயன்படுத்துதல் நேரம் பயனர் நேரத்துடன் பணிபுரிய ஏராளமான வாய்ப்புகளைப் பெறுகிறார்:

1. ஒரு குறிப்பிட்ட நேரத்திற்கு நிரல் செயலாக்கத்தை இடைநிறுத்தவும்.
2. சகாப்தத்திலிருந்து கடந்து வந்த நேரத்தை நொடிகளில் காட்டு. இந்தத் தகவல் நேரத்தைச் சுருக்கவும் அல்லது அதில் பிற கணிதச் செயல்பாடுகளைச் செய்யவும் பயன்படுத்தப்படலாம்.
3. வசதியான வடிவத்திற்கு மாற்றவும். மேலும், புரோகிராமர் தானே எந்த உறுப்புகள் காட்டப்படும் மற்றும் எந்த வரிசையில் அமைக்க முடியும். 

இன்னும் பல சாத்தியக்கூறுகள் உள்ளன, ஆனால் இன்று நாம் மிக அடிப்படையானவற்றை பகுப்பாய்வு செய்துள்ளோம். எப்படியாவது நேரத்துடன் செயல்படும் எந்தவொரு திட்டத்திலும் அவை கைக்குள் வரும். நல்ல அதிர்ஷ்டம்.