Ang module ng Operating system ng Python ay nag-aalok ng iba't ibang mga tool para sa pagpapadala gamit ang operating system. Nag-aalok ang module na ito ng modular na paraan ng paggamit ng feature na nakadepende sa operating system. Iba't ibang paraan ang ginagamit sa Python programming language, at isa na rito ang 'Python os exit'. Gamit ang function na ito, maaaring tapusin ng isa ang isang proseso ng Python na may partikular na status nang hindi nagpapatakbo ng mga humahawak ng paglilinis o mga flushing buffer, bilang paglalarawan, gamit ang isang “os fork()” system call, kung saan karaniwang ginagamit ang function na ito sa proseso ng bata.
Maaaring tapusin ng isang function ng computer ang pagpapatupad nito sa pamamagitan ng pagsisimula ng exit system call sa maraming mga operating system ng computer. Sa isang multithreading system, ang isang exit ay madalas na sumasagisag sa paghinto ng isang operational thread. Kinukuha ng operating system ang mga mapagkukunan na kinabibilangan ng mga file at memory, para sa pamamahala ng mapagkukunan. Ngunit, kung pag-uusapan natin ang karaniwang isa para sa paglabas, malamang na ito ay ang 'sys.exit(n)' na paraan.
Syntax
Ang syntax ng Python os exit method ay ibinigay sa ibaba:
Tinutukoy ng syntax ng Python os exit method ang dalawang bagay: ang unang bahagi ay kumakatawan sa exit status ng proseso, at ang module na ito ay hindi magbabalik ng anumang halaga.
Halimbawa # 1: Paggamit ng 'os._exit()' na Paraan Upang Lumabas sa Maramihang Mga Proseso Nang Hindi Tumatawag sa Anumang Tagapangasiwa ng Paglilinis
Ang paraan ng paglabas ay maaaring patakbuhin sa anumang operating system, pangunahin sa mga operating system na 'Windows' o 'Linux'. Sa aming unang halimbawa, titingnan namin ang maraming prosesong nagaganap bilang proseso ng magulang at proseso ng anak, kung saan nagsasagawa ito ng pagproseso nang hindi tinatawagan ang tagapangasiwa ng paglilinis sa function o program. Ang module na ito ay gagana nang mas mahusay sa 'Linux' operating system. Ang paglilinis ng thread na 'pop()' na may nonzero na halaga para sa execute na parameter ay nagiging sanhi ng pagtawag sa cleaning handler. Ang lahat ng mga pamamaraan sa paglilinis na itinulak ngunit hindi pa nailalabas ay lumabas sa sanitation stack at isinasagawa sa last-in at first-out (LIFO) order kapag huminto ang thread, ngunit hindi na kailangang tawagan ito sa halimbawang ito.
Ang code snippet para sa aming unang halimbawa ng Python os exit ay ipinaliwanag sa ibaba:
Ang programa ay pinasimulan sa pamamagitan ng pag-import ng library ng 'os' dahil nag-aalala kami tungkol sa paggawa ng mga kundisyon at tuntunin upang maiugnay sa operating system ng aming device. Pagkatapos ay ginawa namin ang 'PID' at iniugnay ang 'Python' sa 'os' na library. Ginagamit na namin ngayon ang conditional statement kung saan ang “if” condition ay “PID is greater than 0”.
Pagkatapos noon, ginamit namin ang function na 'print()', na kailangang i-print ang statement na '\nProcessing in Parent', kung saan ang '\n' ay ginagamit para sa paglilipat ng cursor sa bagong linya sa loob ng 'if' condition. Ang variable na 'impormasyon' ay sinisimulan sa pagtawag ng 'os.waitpid(pid,0)', kung saan ang 'PID' ay nagsisimula sa '0' na pagitan. Sa karagdagang pagpapatuloy, naglapat kami ng isa pang kundisyon na 'kung' sa 'os.WIFEXITED()' kung saan binigyan namin ito ng paglalarawan ng impormasyon na '1' para sa pagproseso nito. Iniimbak nito ang impormasyon sa pagpoproseso nito sa function na 'python_code' na tinukoy ng user, na nagtataglay ng print statement ng 'Child Code to be Exit' at binibigyan ito ng value na 'python_code' sa loob ng function na 'print()'.
Ngayon, papunta na tayo sa ating 'ibang' kundisyon, na mayroong apat na print statement. Ang pahayag sa unang function na 'print()' ay 'Pagproseso sa Bata'. Ang pangalawang pahayag sa pag-print ay 'ID ng Pagproseso:' at kasama nito, hawak nito ang halaga ng 'os.getpid()', ang function na naglalaman ng code file ng Python para sa pagproseso ng bata. Ang pangatlong print statement na ginamit dito ay 'Hey Python!!' at ang pang-apat na pahayag sa pag-print ay 'Umiiral ang Pagproseso ng Bata!' Panghuli, inilapat namin ang aming pangunahing module upang lumabas sa pagproseso ng pagpapatupad ng programa ng umiiral na file na 'os._exit()' at kung saan itinalaga ang variable na 'os.EX_OK' nang hindi nagbabalik ng anumang function para sa pagproseso.
Dahil ang pagpoproseso ng bata ay ang priyoridad sa pagtakbo muna at pag-alis sa programa mula sa pagpoproseso ng magulang dahil nangangailangan ito ng mas maraming oras. Kaya, ipinapakita lang ng output snapshot ang mga print statement na ibinigay namin sa nakaraang code, ngunit ang file na ginawa namin sa system ay nagpapakita ng processing id nito, '78695', na makikita natin sa huling snapshot. At pagkatapos, ang pagpoproseso ng paglabas ng magulang ay magiging '0' dahil hindi man lang ito sumasailalim sa masusing pagpoproseso dahil, para sa higit pa, nangangailangan ito ng handler.
Halimbawa # 2: Paggamit ng “os._exit()” na Paraan Para Lumabas sa Pangkalahatang Proseso Nang Walang Mga Flushing Buffer
Sa halimbawang ito, titingnan natin ang simpleng pangkalahatang pagproseso ng pagpapatupad ng paglabas na kababalaghan pagkatapos patakbuhin ang mga agwat nito mula sa pagbabasa nito sa system. Dito, hindi rin namin ginagamit ang mga flushing buffer dahil hindi ito kinakailangan para sa pagproseso. Pagkatapos ng lahat, ang 'os._exit' ay gagana nang mas mahusay para sa paglabas sa proseso.
Tingnan natin ang code kung saan namin na-import ang Python library na 'os'. Nagsisimula ang programa sa isang for-loop kung saan ginagamit namin ang variable na 'p' upang hawakan ang ilang data at itakda ang saklaw nito sa '6'. Pagkatapos nito, inilapat namin ang kondisyong 'kung' sa variable na 'p', na katumbas ng kabuuang pagitan sa '4'. Habang nagsisimula ang sistema ng pagpoproseso mula sa index na '0', tatakbo ito mula sa '0' hanggang '4'. Sa sandaling magkatugma ang kundisyon, na ang halaga ng “p” ay magiging katumbas ng 4, isasagawa ng programa ang susunod na pahayag, na siyang function na “print()”, at ibibigay ang processing unit na “exit”. Sa huling linya, ginamit namin ang function na 'os._exit()' upang lumabas sa function pagkatapos magsimula sa '0' at pagkatapos ay huminto sa pagproseso. Sa huli, ang lahat ng mga value na nakaimbak sa variable na 'p' pagkatapos ng pagproseso ay ipi-print sa output display habang ginamit namin ang function na 'print()' sa pamamagitan ng pagtatalaga ng variable na 'p' dito.
Ang display ng output ay magpapakita lamang ng mga numerong '0', '1', '2', at '3', dahil ito ang apat na numero na naabot pagkatapos ng pagproseso, at, pagkatapos noon, ang pagpoproseso ay isang exit.
Halimbawa#3: Paggamit ng “os._exit()” Paraan Para Lumabas sa Prosesong Wala sa Buffer
Minsan, sinusubukan naming ipasa ang ilang proseso na hindi naging madali para sa system na isagawa ang pagpoproseso o ihinto sa anumang kadahilanan—kadalasan kapag wala ang pagproseso para sa partikular na programa dahil sa pagkakaroon ng anumang partikular na materyal, library, o paglalaan ng file .
Tingnan natin ang aming code snippet kung saan ginamit namin ang “Numbers” bilang variable at itakda ito sa range mula sa “0” hanggang “7”. Ngayon, inilapat namin ang kundisyong 'kung' kung saan ang 'Mga Numero' ay katumbas ng '5' na mga index, at pagkatapos ay ginamit namin ang 'print()' na pahayag upang i-print ang halaga ng 'exit'. Pagkatapos, gumamit kami ng isang partikular na module ng 'taasan ang SystemExit' upang lumabas sa pagproseso tulad ng 'os._exit' at ginamit muli ang function na 'print()' upang ipakita ang mga numerong nakaimbak sa variable na 'Numbers' pagkatapos na lumabas ang proseso.
Malinaw na ilalarawan ng output snapshot na hindi nito ipapakita ang mga value ng 'Numbers' pagkatapos ng module ng exit na paggamit. Dahil ang pangunahing materyal ay wala, tulad ng library at initialization, kaya ito ay magbabalik ng 'walang laman' sa output display pagkatapos iproseso ang programa at bumalik nang hindi nagbabasa ng anumang halaga, o maaaring ang programa ay hindi napupunta para sa pagpapatupad.
Konklusyon
Sa artikulong ito, tinalakay namin ang tatlong halimbawa na nauugnay sa pamamaraan ng paglabas ng Python os. Sa unang halimbawa, ginamit namin ang Python os exit module upang lumabas sa proseso ng bata nang hindi gumagamit ng anumang flushing at cleanup handler. Sa pangalawang halimbawa, ginamit namin ang os exit module sa process exit sa isang solong pangkalahatang programa ng code nang walang flushing buffer. Ang pangatlong halimbawa ay nauugnay sa paghinto sa absent na proseso na kasalukuyang hindi naroroon o nakaimbak sa system.