పైథాన్ యొక్క ఆపరేటింగ్ సిస్టమ్స్ మాడ్యూల్ ఆపరేటింగ్ సిస్టమ్‌తో ప్రసారం చేయడానికి వివిధ రకాల సాధనాలను అందిస్తుంది. ఈ మాడ్యూల్ ఆపరేటింగ్ సిస్టమ్‌పై ఆధారపడి ఫీచర్‌ను ఉపయోగించే మాడ్యులర్ పద్ధతిని అందిస్తుంది. పైథాన్ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో వివిధ పద్ధతులు ఉపయోగించబడతాయి మరియు “పైథాన్ ఓఎస్ ఎగ్జిట్” వాటిలో ఒకటి. ఈ ఫంక్షన్‌ని ఉపయోగించి, క్లీనింగ్ హ్యాండ్లర్‌లు లేదా ఫ్లషింగ్ బఫర్‌లను రన్ చేయకుండా ఒక నిర్దిష్ట స్థితితో పైథాన్ ప్రాసెస్‌ను ముగించవచ్చు, ఉదాహరణ కోసం, “os ఫోర్క్()” సిస్టమ్ కాల్‌తో, ఈ ఫంక్షన్ సాధారణంగా చైల్డ్ ప్రాసెస్‌లో ఉపయోగించబడుతుంది.
అనేక కంప్యూటర్ల ఆపరేటింగ్ సిస్టమ్‌లలో నిష్క్రమణ సిస్టమ్ కాల్‌ని ప్రారంభించడం ద్వారా కంప్యూటర్ ఫంక్షన్ దాని అమలును ముగించవచ్చు. మల్టీథ్రెడింగ్ సిస్టమ్‌లో, నిష్క్రమణ తరచుగా కార్యాచరణ థ్రెడ్‌ను నిలిపివేయడాన్ని సూచిస్తుంది. ఆపరేటింగ్ సిస్టమ్ వనరుల నిర్వహణ కోసం ఫైల్‌లు మరియు మెమరీని కలిగి ఉన్న వనరులను తిరిగి పొందుతుంది. కానీ, మేము నిష్క్రమించడానికి ప్రామాణికమైనది గురించి మాట్లాడినట్లయితే, అది బహుశా “sys.exit(n)” పద్ధతి కావచ్చు.
వాక్యనిర్మాణం
పైథాన్ os నిష్క్రమణ పద్ధతి యొక్క వాక్యనిర్మాణం క్రింద ఇవ్వబడింది:
పైథాన్ os నిష్క్రమణ పద్ధతి యొక్క సింటాక్స్ రెండు విషయాలను నిర్ణయిస్తుంది: మొదటి భాగం ప్రక్రియ యొక్క నిష్క్రమణ స్థితిని సూచిస్తుంది మరియు ఈ మాడ్యూల్ ఏ విలువను అందించదు.
ఉదాహరణ # 1: 'os._exit()' పద్ధతిని ఉపయోగించడం ద్వారా ఏ క్లీనప్ హ్యాండ్లర్‌ని కాల్ చేయకుండానే బహుళ ప్రక్రియల నుండి నిష్క్రమించండి
నిష్క్రమణ పద్ధతిని ఏదైనా ఆపరేటింగ్ సిస్టమ్‌లో, ప్రధానంగా “Windows” లేదా “Linux” ఆపరేటింగ్ సిస్టమ్‌లలో ఆపరేట్ చేయవచ్చు. మా మొదటి ఉదాహరణలో, మేము పేరెంట్ ప్రాసెస్ మరియు చైల్డ్ ప్రాసెస్‌గా సంభవించే బహుళ ప్రక్రియలను పరిశీలిస్తాము, ఇక్కడ అది ఫంక్షన్ లేదా ప్రోగ్రామ్‌లో క్లీనప్ హ్యాండ్లర్‌ను కాల్ చేయకుండా ప్రాసెసింగ్ చేస్తుంది. ఈ మాడ్యూల్ 'Linux' ఆపరేటింగ్ సిస్టమ్‌లో మరింత సమర్థవంతంగా పని చేస్తుంది. ఎగ్జిక్యూట్ పారామీటర్ కోసం నాన్ జీరో విలువతో థ్రెడ్ క్లీనప్ “పాప్()” క్లీనింగ్ హ్యాండ్లర్‌ని పిలవడానికి కారణమవుతుంది. పుష్ చేయబడిన కానీ ఇంకా విడుదల చేయని అన్ని క్లీనప్ విధానాలు శానిటేషన్ స్టాక్ నుండి పాప్ చేయబడతాయి మరియు థ్రెడ్ ఆపివేసినప్పుడు చివరి ఇన్ మరియు ఫస్ట్-అవుట్ (LIFO) క్రమంలో అమలు చేయబడతాయి, కానీ ఈ ఉదాహరణలో కాల్ చేయవలసిన అవసరం ఉండదు.
పైథాన్ os ఎగ్జిట్ యొక్క మా మొదటి ఉదాహరణ కోసం కోడ్ స్నిప్పెట్ క్రింద వివరించబడింది:
మా పరికరం యొక్క ఆపరేటింగ్ సిస్టమ్‌తో లింక్ చేయడానికి షరతులు మరియు నిబంధనలను చేయడం గురించి మేము ఆందోళన చెందుతున్నందున “os” లైబ్రరీని దిగుమతి చేయడం ద్వారా ప్రోగ్రామ్ ప్రారంభించబడింది. అప్పుడు మేము 'PID'ని సృష్టించాము మరియు 'పైథాన్'ని 'os' లైబ్రరీతో లింక్ చేసాము. మేము ఇప్పుడు షరతులతో కూడిన స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము, ఇక్కడ “if” షరతు “PID 0 కంటే ఎక్కువ”.
ఆ తర్వాత, మేము “ప్రింట్()” ఫంక్షన్‌ని ఉపయోగించాము, ఇది “\nపేరెంట్‌లో ప్రాసెసింగ్” అనే స్టేట్‌మెంట్‌ను ప్రింట్ చేయాలి, ఇక్కడ “\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'ని దిగుమతి చేసుకున్న కోడ్‌ని చూద్దాం. ప్రోగ్రామ్ ఫర్-లూప్‌తో ప్రారంభమవుతుంది, ఇక్కడ మేము కొంత డేటాను ఉంచడానికి మరియు దాని పరిధిని '6'కి సెట్ చేయడానికి వేరియబుల్ “p”ని ఉపయోగిస్తాము. ఆ తర్వాత, మేము వేరియబుల్ 'p' పై 'if' షరతును వర్తింపజేసాము, ఇది మొత్తం విరామాలను '4'కి సమం చేస్తుంది. ప్రాసెసింగ్ సిస్టమ్ ఇండెక్స్ '0' నుండి ప్రారంభమైనందున, ఇది '0' నుండి '4' వరకు ప్రక్రియను అమలు చేస్తుంది. షరతు సరిపోలిన వెంటనే, ఇది “p” విలువ 4కి సమానం అవుతుంది, ప్రోగ్రామ్ “ప్రింట్()” ఫంక్షన్ అయిన తదుపరి స్టేట్‌మెంట్‌ను అమలు చేస్తుంది మరియు ప్రాసెసింగ్ యూనిట్ “నిష్క్రమణ”ని అందిస్తుంది. చివరి పంక్తిలో, '0' నుండి ప్రారంభించి, ఆపై ప్రాసెసింగ్ నుండి నిష్క్రమించడానికి మేము 'os._exit()' ఫంక్షన్‌ని ఉపయోగించాము. చివరగా, ప్రాసెస్ చేసిన తర్వాత వేరియబుల్ “p”లో నిల్వ చేయబడిన అన్ని విలువలు అవుట్‌పుట్ డిస్‌ప్లేలో మేము “p” వేరియబుల్‌ని కేటాయించడం ద్వారా “print()” ఫంక్షన్‌ని ఉపయోగించినట్లుగా ముద్రించబడతాయి.
అవుట్‌పుట్ డిస్‌ప్లే కేవలం “0”, “1”, “2” మరియు “3” నంబర్‌లను ప్రదర్శిస్తుంది, ఎందుకంటే ఇవి ప్రాసెస్ చేసిన తర్వాత చేరుకున్న నాలుగు సంఖ్యలు మరియు ఆ తర్వాత, ప్రాసెసింగ్ నిష్క్రమణ అవుతుంది.
ఉదాహరణ#3: బఫర్‌లో లేని ప్రక్రియ నుండి నిష్క్రమించడానికి “os._exit()” పద్ధతిని ఉపయోగించడం
కొన్నిసార్లు, సిస్టమ్ ప్రాసెసింగ్‌ను నిర్వహించడం లేదా ఏ కారణం చేతనైనా ఆపివేయడం సులభం కాని కొన్ని ప్రక్రియలను పాస్ చేయడానికి మేము ప్రయత్నిస్తాము—ఎక్కువగా ఏదైనా నిర్దిష్ట మెటీరియల్, లైబ్రరీ లేదా ఫైల్ కేటాయింపు కారణంగా నిర్దిష్ట ప్రోగ్రామ్‌కు ప్రాసెసింగ్ లేనప్పుడు .
మనం 'సంఖ్యలు'ను వేరియబుల్‌గా ఉపయోగించిన మా కోడ్ స్నిప్పెట్‌ను చూద్దాం మరియు దానిని '0' నుండి '7' వరకు సెట్ చేయండి. ఇప్పుడు, 'సంఖ్యలు' '5' సూచికలకు సమానం అయ్యే 'if' కండిషన్‌ను మేము వర్తింపజేస్తాము, ఆపై 'నిష్క్రమణ' విలువను ముద్రించడానికి మేము 'print()' స్టేట్‌మెంట్‌ను ఉపయోగించాము. తరువాత, మేము 'os._exit' వంటి ప్రాసెసింగ్ నుండి నిష్క్రమించడానికి 'రైజ్ SystemExit' యొక్క నిర్దిష్ట మాడ్యూల్‌ని ఉపయోగించాము మరియు ప్రాసెస్ నిష్క్రమించిన తర్వాత వేరియబుల్ 'సంఖ్యలు'లో నిల్వ చేయబడిన సంఖ్యలను ప్రదర్శించడానికి మళ్లీ 'print()' ఫంక్షన్‌ని ఉపయోగించాము.
అవుట్‌పుట్ స్నాప్‌షాట్ నిష్క్రమణ వినియోగం యొక్క మాడ్యూల్ తర్వాత “సంఖ్యలు” విలువలను ప్రదర్శించదని స్పష్టంగా వివరిస్తుంది. లైబ్రరీ మరియు ఇనిషియలైజేషన్ వంటి ప్రధాన అంశాలు లేనందున, ఇది ప్రోగ్రామ్‌ను ప్రాసెస్ చేసిన తర్వాత అవుట్‌పుట్ డిస్‌ప్లేలో “ఖాళీ”గా తిరిగి వస్తుంది మరియు ఏ విలువను చదవకుండా తిరిగి వస్తుంది లేదా ప్రోగ్రామ్ అమలుకు వెళ్లకపోవచ్చు.
ముగింపు
ఈ వ్యాసంలో, మేము పైథాన్ os నిష్క్రమణ పద్ధతికి సంబంధించిన మూడు ఉదాహరణలను చర్చించాము. మొదటి ఉదాహరణలో, మేము ఎటువంటి ఫ్లషింగ్ మరియు క్లీనప్ హ్యాండ్లర్‌ను ఉపయోగించకుండా చైల్డ్ ప్రాసెస్ నుండి నిష్క్రమించడానికి పైథాన్ os ఎగ్జిట్ మాడ్యూల్‌ని ఉపయోగించాము. రెండవ ఉదాహరణలో, మేము బఫర్‌ను ఫ్లషింగ్ చేయకుండా కోడ్ యొక్క ఒకే సాధారణ ప్రోగ్రామ్‌లో ప్రాసెస్ ఎగ్జిట్‌లో os ఎగ్జిట్ మాడ్యూల్‌ని ఉపయోగించాము. మూడవ ఉదాహరణ ప్రస్తుతం సిస్టమ్‌లో లేని లేదా నిల్వ చేయబడని ఆబ్సెంట్ ప్రాసెస్ నుండి నిష్క్రమించడానికి సంబంధించినది.