பைதான் ஓஎஸ் வெளியேறு

பைத்தானின் இயக்க முறைமைகள் தொகுதி இயக்க முறைமையுடன் பரிமாற்றம் செய்வதற்கான பல்வேறு கருவிகளை வழங்குகிறது. இந்த தொகுதி இயக்க முறைமை சார்ந்த அம்சத்தைப் பயன்படுத்துவதற்கான மட்டு முறையை வழங்குகிறது. பைதான் நிரலாக்க மொழியில் பல்வேறு முறைகள் பயன்படுத்தப்படுகின்றன, மேலும் 'Python os exit' அவற்றில் ஒன்றாகும். இந்தச் செயல்பாட்டைப் பயன்படுத்தி, ஒரு பைதான் செயல்முறையை க்ளீனிங் ஹேண்ட்லர்கள் அல்லது ஃப்ளஷிங் பஃபர்களை இயக்காமல் ஒரு குறிப்பிட்ட நிலையுடன் முடிக்க முடியும், விளக்கமாக, “os fork()” சிஸ்டம் கால் மூலம், இந்தச் செயல்பாடு பொதுவாக குழந்தைச் செயல்பாட்டில் பயன்படுத்தப்படுகிறது.

ஒரு கணினி செயல்பாடு பல கணினிகளின் இயக்க முறைமைகளில் வெளியேறும் முறைமை அழைப்பைத் தொடங்குவதன் மூலம் அதன் செயல்பாட்டை முடிக்க முடியும். ஒரு மல்டித்ரெடிங் அமைப்பில், வெளியேறுதல் என்பது ஒரு செயல்பாட்டு நூலை நிறுத்துவதைக் குறிக்கிறது. ஆப்பரேட்டிங் சிஸ்டம், ஆதார மேலாண்மைக்காக கோப்புகள் மற்றும் நினைவகத்தை உள்ளடக்கிய ஆதாரங்களை மீட்டெடுக்கிறது. ஆனால், வெளியேறுவதற்கான நிலையான ஒன்றைப் பற்றி நாம் பேசினால், அது 'sys.exit(n)' முறையாக இருக்கலாம்.

தொடரியல்

பைதான் ஓஎஸ் வெளியேறும் முறையின் தொடரியல் கீழே கொடுக்கப்பட்டுள்ளது:

Python os exit முறையின் தொடரியல் இரண்டு விஷயங்களைத் தீர்மானிக்கிறது: முதல் பகுதி செயல்முறையின் வெளியேறும் நிலையைக் குறிக்கிறது, மேலும் இந்த தொகுதி எந்த மதிப்பையும் தராது.

எடுத்துக்காட்டு # 1: 'os._exit()' முறையைப் பயன்படுத்தி பல செயல்முறைகளில் இருந்து வெளியேற எந்த துப்புரவு கையாளுதலையும் அழைக்காமல்

வெளியேறும் முறையை எந்த இயக்க முறைமையிலும், முதன்மையாக 'விண்டோஸ்' அல்லது 'லினக்ஸ்' இயக்க முறைமைகளில் இயக்கலாம். எங்கள் முதல் எடுத்துக்காட்டில், பெற்றோர் செயல்முறை மற்றும் குழந்தை செயல்முறை என நிகழும் பல செயல்முறைகளைப் பார்ப்போம், அங்கு செயல்பாடு அல்லது நிரலில் தூய்மைப்படுத்தும் கையாளுபவரை அழைக்காமல் செயலாக்கம் செய்கிறது. இந்த தொகுதி 'லினக்ஸ்' இயக்க முறைமையில் மிகவும் திறமையாக வேலை செய்யும். எக்ஸிகியூட் அளவுருக்கான பூஜ்ஜியமற்ற மதிப்பைக் கொண்ட 'பாப்()' த்ரெட் கிளீனிங் ஹேண்ட்லரை அழைக்கிறது. தள்ளப்பட்ட ஆனால் இன்னும் வெளியிடப்படாத அனைத்து துப்புரவு நடைமுறைகளும் சானிட்டேஷன் ஸ்டேக்கில் இருந்து பாப் செய்யப்பட்டு, த்ரெட் நிறுத்தப்படும்போது கடைசியாக மற்றும் முதல் அவுட் (LIFO) வரிசையில் செயல்படுத்தப்படும், ஆனால் இந்த எடுத்துக்காட்டில் அதை அழைக்க வேண்டிய அவசியமில்லை.

பைதான் ஓஎஸ் எக்சிட்டின் முதல் உதாரணத்திற்கான குறியீடு துணுக்கு கீழே விளக்கப்பட்டுள்ளது:

எங்கள் சாதனத்தின் ஆப்பரேட்டிங் சிஸ்டத்துடன் இணைப்பதற்கான நிபந்தனைகள் மற்றும் விதிமுறைகளைச் செய்வதில் நாங்கள் அக்கறை கொண்டுள்ளதால், 'os' நூலகத்தை இறக்குமதி செய்வதன் மூலம் நிரல் தொடங்கப்பட்டது. பின்னர் 'PID' ஐ உருவாக்கி 'Python' ஐ 'os' நூலகத்துடன் இணைத்தோம். 'if' நிபந்தனை 'PID 0 ஐ விட அதிகமாக உள்ளது' என்ற நிபந்தனை அறிக்கையை இப்போது பயன்படுத்துகிறோம்.

அதன் பிறகு, நாங்கள் “print()” செயல்பாட்டைப் பயன்படுத்தினோம், அதில் “\nProcessing in Parent” என்ற அறிக்கையை அச்சிட வேண்டும், அங்கு “\n” என்பது “if” நிபந்தனைக்குள் கர்சரை புதிய வரிக்கு மாற்ற பயன்படுகிறது. மாறி 'தகவல்' என்பது 'os.waitpid(pid,0)' என்ற அழைப்பிற்கு துவக்கப்படுகிறது, அங்கு 'PID' என்பது '0' இடைவெளியில் இருந்து தொடங்குகிறது. மேலும் தொடர, 'os.WIFEXITED()' இல் மற்றொரு 'if' நிபந்தனையைப் பயன்படுத்தினோம், அதன் செயலாக்கத்திற்கான தகவல் விளக்கத்தை '1' வழங்கியுள்ளோம். இது 'பைதான்_கோட்' இன் பயனர் வரையறுக்கப்பட்ட செயல்பாட்டில் அதன் செயலாக்கத் தகவலைச் சேமிக்கிறது, இது 'வெளியேற வேண்டும்' என்ற அச்சு அறிக்கையை வைத்திருக்கும் மற்றும் 'அச்சு()' செயல்பாட்டிற்குள் 'பைதான்_கோட்' மதிப்பை வழங்குகிறது.

இப்போது, ​​நாங்கள் எங்கள் 'வேறு' நிலையை நோக்கி வருகிறோம், அதில் நான்கு அச்சு அறிக்கைகள் உள்ளன. முதல் 'அச்சு()' செயல்பாட்டில் உள்ள அறிக்கை 'குழந்தையில் செயலாக்கம்' ஆகும். இரண்டாவது அச்சு அறிக்கையானது 'செயலாக்கத்தின் ஐடி:' மற்றும் அதனுடன், குழந்தை செயலாக்கத்திற்கான பைத்தானின் குறியீட்டு கோப்பைக் கொண்ட செயல்பாடு 'os.getpid()' மதிப்பைக் கொண்டுள்ளது. இங்கே பயன்படுத்தப்படும் மூன்றாவது அச்சு அறிக்கை “ஏய் பைதான்!!” மற்றும் நான்காவது அச்சு அறிக்கை 'குழந்தை செயலாக்கம் உள்ளது!' கடைசியாக, 'os._exit()' மற்றும் செயலாக்கத்திற்கான எந்தச் செயல்பாட்டையும் வழங்காமல் 'os.EX_OK' என்ற மாறி ஒதுக்கப்பட்டிருக்கும் கோப்பின் நிரல் செயலாக்கத்தின் செயலாக்கத்திலிருந்து வெளியேற எங்கள் முக்கிய தொகுதியைப் பயன்படுத்தினோம்.

குழந்தை செயலாக்கம் முதன்மையாக இயங்குவதற்கும், பெற்றோர் செயலாக்கத்திலிருந்து நிரலிலிருந்து வெளியேறுவதற்கும் முன்னுரிமை அளிக்கப்படுகிறது, ஏனெனில் அதற்கு அதிக நேரம் தேவைப்படுகிறது. எனவே, அவுட்புட் ஸ்னாப்ஷாட் முந்தைய குறியீட்டில் நாம் வழங்கிய அச்சு அறிக்கைகளைக் காட்டுகிறது, ஆனால் கணினியில் நாம் உருவாக்கிய கோப்பு அதன் செயலாக்க ஐடியான “78695” ஐக் காட்டுகிறது, அதை நாம் கடைசி ஸ்னாப்ஷாட்டில் காணலாம். பின்னர், பெற்றோர் வெளியேறுதலின் செயலாக்கம் '0' ஆக இருக்கும், ஏனெனில் இது முழுமையான செயலாக்கத்திற்கு உட்படாது, ஏனெனில், மேலும், அதற்கு கையாளுபவர் தேவை.

எடுத்துக்காட்டு # 2: 'os._exit()' முறையைப் பயன்படுத்தி, பஃபர்களை ஃப்ளஷிங் செய்யாமல் பொது செயல்முறையிலிருந்து வெளியேறவும்

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

பைதான் நூலகமான “os” ஐ இறக்குமதி செய்த குறியீட்டைப் பார்ப்போம். நிரல் ஒரு ஃபார்-லூப்பில் தொடங்குகிறது, அங்கு சில தரவை வைத்திருக்க 'p' மாறியைப் பயன்படுத்துகிறோம் மற்றும் அதன் வரம்பை '6' ஆக அமைக்கிறோம். அதன் பிறகு, 'p' மாறியில் 'if' நிபந்தனையைப் பயன்படுத்தினோம், இது மொத்த இடைவெளிகளை '4' க்கு சமன் செய்கிறது. செயலாக்க அமைப்பு '0' குறியீட்டிலிருந்து தொடங்குவதால், அது '0' முதல் '4' வரை செயல்முறையை இயக்கும். நிபந்தனை பொருந்தியவுடன், “p” இன் மதிப்பு 4 க்கு சமமாக மாறும், நிரல் அடுத்த அறிக்கையை செயல்படுத்தும், இது “print()” செயல்பாடாகும், மேலும் செயலாக்க அலகு “வெளியேறும்” ஐ வழங்கும். கடைசி வரியில், '0' இலிருந்து தொடங்கி, பின்னர் செயலாக்கத்திலிருந்து வெளியேற 'os._exit()' செயல்பாட்டைப் பயன்படுத்தினோம். முடிவில், “p” மாறியை ஒதுக்குவதன் மூலம் “print()” செயல்பாட்டைப் பயன்படுத்தியதால், செயலாக்கத்திற்குப் பிறகு “p” மாறியில் சேமிக்கப்பட்ட அனைத்து மதிப்புகளும் வெளியீட்டு காட்சியில் அச்சிடப்படும்.

வெளியீட்டு காட்சியானது '0', '1', '2' மற்றும் '3' எண்களைக் காண்பிக்கும், ஏனெனில் இவை செயலாக்கத்திற்குப் பிறகு அடைந்த நான்கு எண்களாகும், அதன் பிறகு, செயலாக்கம் வெளியேறும்.

எடுத்துக்காட்டு#3: இடையகத்தில் இல்லாத ஒரு செயல்முறையிலிருந்து வெளியேற “os._exit()” முறையைப் பயன்படுத்துதல்

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

'எண்கள்' ஒரு மாறியாகப் பயன்படுத்திய எங்கள் குறியீடு துணுக்கைப் பார்ப்போம் மற்றும் அதை '0' முதல் '7' வரை அமைக்கவும். இப்போது, ​​'எண்கள்' '5' இன்டெக்ஸ்களுக்கு சமமாக இருக்கும் 'if' நிபந்தனையைப் பயன்படுத்தினோம், பின்னர் 'வெளியேறு' மதிப்பை அச்சிட 'print()' அறிக்கையைப் பயன்படுத்தினோம். பின்னர், 'os._exit' போன்ற செயலாக்கத்திலிருந்து வெளியேற 'raise SystemExit' என்ற குறிப்பிட்ட தொகுதியைப் பயன்படுத்தினோம், மேலும் செயல்முறை வெளியேறிய பிறகு 'எண்கள்' மாறியில் சேமிக்கப்பட்ட எண்களைக் காட்ட மீண்டும் 'print()' செயல்பாட்டைப் பயன்படுத்தினோம்.

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

முடிவுரை

இந்த கட்டுரையில், பைதான் ஓஎஸ் வெளியேறும் முறை தொடர்பான மூன்று எடுத்துக்காட்டுகளைப் பற்றி விவாதித்தோம். முதல் எடுத்துக்காட்டில், எந்த ஃப்ளஷிங் மற்றும் க்ளீனப் ஹேண்ட்லரையும் பயன்படுத்தாமல் சைல்ட் செயல்முறையிலிருந்து வெளியேற பைதான் ஓஎஸ் எக்சிட் மாட்யூலைப் பயன்படுத்தினோம். இரண்டாவது எடுத்துக்காட்டில், இடையகத்தை சுத்தப்படுத்தாமல் குறியீட்டின் ஒரு பொதுவான நிரலில் செயல்முறை வெளியேறும் போது os வெளியேறும் தொகுதியைப் பயன்படுத்தினோம். மூன்றாவது உதாரணம், தற்போது இல்லாத அல்லது கணினியில் சேமிக்கப்படாத செயலியை விட்டு வெளியேறுவது தொடர்பானது.