పైథాన్ నుండి సిస్టమ్ ఆదేశాలను అమలు చేస్తోంది
మీ స్క్రిప్ట్‌ల నుండి నేరుగా బాహ్య ప్రోగ్రామ్‌లు మరియు సిస్టమ్ ఆదేశాలను అమలు చేయడానికి పైథాన్ శక్తివంతమైన సామర్థ్యాలను అందిస్తుంది. మీ ఆపరేటింగ్ సిస్టమ్‌లో అందుబాటులో ఉన్న విస్తారమైన సాధనాలను సద్వినియోగం చేసుకుంటూ పైథాన్ యొక్క సరళతను ఉపయోగించుకోవడానికి ఈ ఫీచర్ మిమ్మల్ని అనుమతిస్తుంది.
మీరు పునరావృతమయ్యే పనులను ఆటోమేట్ చేస్తున్నా లేదా సంక్లిష్టమైన వర్క్‌ఫ్లోలను ఏకీకృతం చేస్తున్నా, పైథాన్‌లో సిస్టమ్ ఆదేశాలను ఎలా కాల్ చేయాలో అర్థం చేసుకోవడం మీ ఉత్పాదకతను గణనీయంగా పెంచుతుంది. ఈ గైడ్‌లో, దీన్ని సమర్థవంతంగా సాధించడానికి మేము వివిధ పద్ధతులను అన్వేషిస్తాము.
| ఆదేశం | వివరణ |
|---|---|
| subprocess.run | సబ్‌షెల్‌లో ఆదేశాన్ని అమలు చేస్తుంది. అవుట్‌పుట్ మరియు ఎర్రర్‌లను క్యాప్చర్ చేయగలదు. |
| subprocess.run([...], capture_output=True) | అమలు చేయబడిన కమాండ్ యొక్క ప్రామాణిక అవుట్‌పుట్ మరియు ప్రామాణిక దోషాన్ని క్యాప్చర్ చేస్తుంది. |
| subprocess.run([...], shell=True) | షెల్ ద్వారా ఆదేశాన్ని అమలు చేస్తుంది, వైల్డ్‌కార్డ్‌ల వంటి షెల్ ఫీచర్‌లను అనుమతిస్తుంది. |
| subprocess.Popen | కొత్త ప్రక్రియలో ఆదేశాన్ని అమలు చేస్తుంది, దాని అమలుపై మరింత నియంత్రణను అందిస్తుంది. |
| process.stdout.readline() | ప్రాసెస్ యొక్క ప్రామాణిక అవుట్‌పుట్ నుండి అవుట్‌పుట్ లైన్‌ను చదువుతుంది. |
| os.system | సాధారణ కమాండ్ ఎగ్జిక్యూషన్ కోసం సాధారణంగా ఉపయోగించే సబ్‌షెల్‌లో ఆదేశాన్ని అమలు చేస్తుంది. |
| subprocess.check_output | ఆదేశాన్ని అమలు చేసి దాని అవుట్‌పుట్‌ను అందిస్తుంది. కమాండ్ విఫలమైతే మినహాయింపును పెంచుతుంది. |
| os.environ.copy() | ప్రస్తుత ఎన్విరాన్మెంట్ వేరియబుల్స్ యొక్క కాపీని సృష్టిస్తుంది, మార్పులను అనుమతిస్తుంది. |
| env parameter in subprocess.run | కొత్త ప్రక్రియ కోసం ఎన్విరాన్మెంట్ వేరియబుల్స్ నిర్దేశిస్తుంది. |
పైథాన్‌లో స్క్రిప్ట్ ఎగ్జిక్యూషన్‌ను అర్థం చేసుకోవడం
అందించిన స్క్రిప్ట్‌లు పైథాన్‌ని ఉపయోగించి బాహ్య ఆదేశాలను అమలు చేయడానికి వివిధ మార్గాలను ప్రదర్శిస్తాయి. ది subprocess.run కమాండ్ బహుముఖమైనది, ఇది మీ పైథాన్ స్క్రిప్ట్ నుండి నేరుగా షెల్ ఆదేశాలను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఉదాహరణకి, subprocess.run(['echo', 'Hello, World!']) కన్సోల్‌కు సందేశాన్ని ప్రింట్ చేస్తుంది subprocess.run(['ls', '-l'], capture_output=True, text=True) యొక్క అవుట్‌పుట్‌ను సంగ్రహిస్తుంది ls -l కమాండ్, వివరణాత్మక డైరెక్టరీ జాబితాను ప్రదర్శిస్తుంది. ఉపయోగించి shell=True తో subprocess.run వైల్డ్‌కార్డ్ విస్తరణ వంటి షెల్ ఫీచర్‌ల వినియోగాన్ని అనుమతిస్తుంది, ఇది మరింత సంక్లిష్టమైన ఆదేశాలకు ఉపయోగపడేలా చేస్తుంది.
ది subprocess.Popen కమాండ్ అసమకాలిక కమాండ్ రన్నింగ్ మరియు ప్రాసెస్ యొక్క ఇన్‌పుట్ మరియు అవుట్‌పుట్ స్ట్రీమ్‌లతో పరస్పర చర్యను అనుమతించడం ద్వారా కమాండ్ ఎగ్జిక్యూషన్‌పై మరింత నియంత్రణను అందిస్తుంది. ఉదాహరణకు, స్క్రిప్ట్ ఉదాహరణతో subprocess.Popen(['ping', 'localhost'], stdout=subprocess.PIPE) లోకల్ మెషీన్‌ను నిరంతరం పింగ్ చేస్తుంది మరియు అవుట్‌పుట్ యొక్క ప్రతి పంక్తిని చదువుతుంది. అదనంగా, os.system సాధారణ కమాండ్ ఎగ్జిక్యూషన్ కోసం ఉపయోగించబడుతుంది, కానీ దాని సౌలభ్యం లేదు subprocess. ఎన్విరాన్మెంట్ వేరియబుల్స్‌ని సవరించవచ్చు మరియు ఉపయోగించి సబ్‌ప్రాసెస్‌కి పంపవచ్చు os.environ.copy() ఇంకా env లో పారామితి subprocess.run, పర్యావరణం ఆధారంగా డైనమిక్ కమాండ్ ఎగ్జిక్యూషన్‌ను అనుమతిస్తుంది.
పైథాన్‌లో బాహ్య ఆదేశాలను అమలు చేయడం
పైథాన్ సబ్‌ప్రాసెస్ మాడ్యూల్‌ని ఉపయోగించడం
import subprocess# Example 1: Running a simple shell commandsubprocess.run(['echo', 'Hello, World!'])# Example 2: Capturing the output of a commandresult = subprocess.run(['ls', '-l'], capture_output=True, text=True)print(result.stdout)# Example 3: Running a command with shell=Truesubprocess.run('echo Hello from the shell', shell=True)# Example 4: Checking the return coderesult = subprocess.run(['ls', 'nonexistentfile'], capture_output=True)if result.returncode != 0:print('Command failed')# Example 5: Using subprocess.Popen for more controlprocess = subprocess.Popen(['ping', 'localhost'], stdout=subprocess.PIPE)while True:output = process.stdout.readline()if output == b'' and process.poll() is not None:breakif output:print(output.strip().decode())
పైథాన్‌తో సిస్టమ్ టాస్క్‌లను ఆటోమేట్ చేస్తోంది
os.system మరియు సబ్‌ప్రాసెస్ మాడ్యూల్‌లను ఉపయోగించడం
import osimport subprocess# Example 1: Using os.system to run a commandos.system('echo This is a test')# Example 2: Running a command and capturing output with subprocessresult = subprocess.run(['date'], capture_output=True, text=True)print('Current date and time:', result.stdout)# Example 3: Executing multiple commandscommands = ['echo First command', 'echo Second command']for cmd in commands:os.system(cmd)# Example 4: Running a command with environment variablesenv = os.environ.copy()env['MY_VAR'] = 'Hello'subprocess.run('echo $MY_VAR', shell=True, env=env)# Example 5: Handling command errorstry:subprocess.check_output(['false_command'], stderr=subprocess.STDOUT)except subprocess.CalledProcessError as e:print('An error occurred:', e.output.decode())
సిస్టమ్ కమాండ్ ఎగ్జిక్యూషన్ కోసం అధునాతన సాంకేతికతలు
పైథాన్‌లో సిస్టమ్ కమాండ్‌లను అమలు చేయడంలో మరొక అంశం ఉపయోగించడాన్ని కలిగి ఉంటుంది shlex షెల్ కమాండ్ పార్సింగ్‌ను నిర్వహించడానికి మాడ్యూల్. ఈ మాడ్యూల్ షెల్ కమాండ్‌లను లిస్ట్ ఫార్మాట్‌లో విభజించడానికి ఒక మార్గాన్ని అందిస్తుంది, తర్వాత దానిని పంపవచ్చు subprocess విధులు. ఖాళీలతో వాదనలు సరిగ్గా నిర్వహించబడుతున్నాయని ఇది నిర్ధారిస్తుంది. అదనంగా, మీరు ఉపయోగించవచ్చు subprocess.PIPE మాతృ ప్రక్రియకు ప్రామాణిక ఇన్‌పుట్, అవుట్‌పుట్ మరియు ఎర్రర్ స్ట్రీమ్‌లను నిర్దేశించడానికి, మరింత సంక్లిష్టమైన ఇంటర్-ప్రాసెస్ కమ్యూనికేషన్‌ను అనుమతిస్తుంది.
ఉదాహరణకు, ఒక కమాండ్ యొక్క అవుట్‌పుట్‌ను మరొక దానిలోకి పైప్ చేయడం ద్వారా ఆదేశాలను చైనింగ్ చేయడం మరియు వాటి అవుట్‌పుట్‌ను వరుసగా ప్రాసెస్ చేయడం ద్వారా సాధించవచ్చు. subprocess.Popen. ఇది మీరు షెల్ స్క్రిప్ట్‌లో చేసే దానిలాగే శక్తివంతమైన కమాండ్ సీక్వెన్స్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు కూడా ఉపయోగించవచ్చు threading బహుళ సబ్‌ప్రాసెస్ ఆదేశాలను ఏకకాలంలో అమలు చేయడానికి, మీ స్క్రిప్ట్ యొక్క సామర్థ్యాన్ని మెరుగుపరుస్తుంది, ప్రత్యేకించి I/O-బౌండ్ టాస్క్‌లతో వ్యవహరించేటప్పుడు.
పైథాన్‌లో సిస్టమ్ ఆదేశాలను అమలు చేయడంపై తరచుగా అడిగే ప్రశ్నలు
- నేను షెల్ కమాండ్‌ను ఎలా అమలు చేయగలను మరియు పైథాన్‌లో దాని అవుట్‌పుట్‌ను ఎలా పొందగలను?
- వా డు subprocess.run తో capture_output=True కమాండ్ యొక్క అవుట్‌పుట్‌ను సంగ్రహించడానికి.
- రెండింటిలో తేడా ఏంటి subprocess.run మరియు subprocess.Popen?
- subprocess.run కమాండ్ పూర్తి అయ్యే వరకు వేచి ఉండే సరళమైన ఇంటర్‌ఫేస్ subprocess.Popen కమాండ్ ఎగ్జిక్యూషన్‌పై మరింత నియంత్రణను ఇస్తుంది, ఇది అసమకాలిక ఆపరేషన్‌ను అనుమతిస్తుంది.
- సిస్టమ్ ఆదేశాన్ని అమలు చేస్తున్నప్పుడు నేను లోపాలను ఎలా నిర్వహించగలను?
- వా డు try మరియు except తో బ్లాక్స్ subprocess.CalledProcessError లోపాలను పట్టుకోవడానికి మరియు నిర్వహించడానికి.
- నేను ఎన్విరాన్మెంట్ వేరియబుల్స్‌ని కమాండ్‌కి పాస్ చేయవచ్చా?
- అవును, ఉపయోగించండి env లో పారామితి subprocess.run లేదా subprocess.Popen ఎన్విరాన్మెంట్ వేరియబుల్స్ పాస్ చేయడానికి.
- నేను బహుళ ఆదేశాలను క్రమంలో ఎలా అమలు చేయాలి?
- వా డు subprocess.run లేదా subprocess.Popen తో పైపులను ఉపయోగించి లూప్ లేదా చైన్ ఆదేశాలలో subprocess.Popen.
- వినియోగదారు ఇన్‌పుట్ అవసరమయ్యే ఆదేశాన్ని నేను ఎలా అమలు చేయగలను?
- వా డు subprocess.Popen తో stdin=subprocess.PIPE మరియు ఉపయోగించి ప్రక్రియతో కమ్యూనికేట్ చేయండి process.communicate.
- ఏమి ఉపయోగం shlex కమాండ్ అమలులో?
- shlex షెల్ ఆదేశాలను సరిగ్గా అన్వయించడంలో సహాయపడుతుంది, ఖాళీలతో ఆర్గ్యుమెంట్‌లు సరిగ్గా నిర్వహించబడుతున్నాయని నిర్ధారిస్తుంది.
- నేను నేపథ్యంలో ఆదేశాన్ని ఎలా అమలు చేయాలి?
- వా డు subprocess.Popen ప్రక్రియ పూర్తయ్యే వరకు వేచి ఉండకుండా, లేదా ఉపయోగించడానికి threading నేపథ్య అమలును నిర్వహించడానికి.
సిస్టమ్ కమాండ్ ఎగ్జిక్యూషన్ కోసం అధునాతన సాంకేతికతలు
పైథాన్‌లో సిస్టమ్ కమాండ్‌లను అమలు చేయడంలో మరొక అంశం ఉపయోగించడాన్ని కలిగి ఉంటుంది shlex షెల్ కమాండ్ పార్సింగ్‌ను నిర్వహించడానికి మాడ్యూల్. ఈ మాడ్యూల్ షెల్ కమాండ్‌లను లిస్ట్ ఫార్మాట్‌లో విభజించడానికి ఒక మార్గాన్ని అందిస్తుంది, తర్వాత దానిని పంపవచ్చు subprocess విధులు. ఖాళీలతో వాదనలు సరిగ్గా నిర్వహించబడుతున్నాయని ఇది నిర్ధారిస్తుంది. అదనంగా, మీరు ఉపయోగించవచ్చు subprocess.PIPE మాతృ ప్రక్రియకు ప్రామాణిక ఇన్‌పుట్, అవుట్‌పుట్ మరియు ఎర్రర్ స్ట్రీమ్‌లను నిర్దేశించడానికి, మరింత సంక్లిష్టమైన ఇంటర్-ప్రాసెస్ కమ్యూనికేషన్‌ను అనుమతిస్తుంది.
ఉదాహరణకు, కమాండ్‌లను చైనింగ్ చేయడం మరియు వాటి అవుట్‌పుట్‌ను సీక్వెన్షియల్‌గా ప్రాసెస్ చేయడం ద్వారా ఒక కమాండ్ యొక్క అవుట్‌పుట్‌ను మరొక దానిలోకి పైప్ చేయడం ద్వారా సాధించవచ్చు. subprocess.Popen. ఇది మీరు షెల్ స్క్రిప్ట్‌లో చేసే దానిలాగే శక్తివంతమైన కమాండ్ సీక్వెన్స్‌లను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు కూడా ఉపయోగించవచ్చు threading బహుళ సబ్‌ప్రాసెస్ ఆదేశాలను ఏకకాలంలో అమలు చేయడానికి, మీ స్క్రిప్ట్ యొక్క సామర్థ్యాన్ని మెరుగుపరుస్తుంది, ప్రత్యేకించి I/O-బౌండ్ టాస్క్‌లతో వ్యవహరించేటప్పుడు.
పైథాన్‌లో ఆదేశాలను అమలు చేయడంపై తుది ఆలోచనలు
పైథాన్‌లో బాహ్య ఆదేశాలను అమలు చేయడం అనేది మీ స్క్రిప్టింగ్ మరియు ఆటోమేషన్ పనులను గణనీయంగా మెరుగుపరచగల బహుముఖ మరియు శక్తివంతమైన సామర్ధ్యం. ఉపయోగించడం ద్వారా subprocess మాడ్యూల్, మీరు షెల్ ఆదేశాలను అమలు చేయవచ్చు, వాటి అవుట్‌పుట్‌లను సంగ్రహించవచ్చు మరియు లోపాలను సమర్థవంతంగా నిర్వహించవచ్చు. ది os.system ఫంక్షన్ ప్రాథమిక కమాండ్ ఎగ్జిక్యూషన్ కోసం సరళమైన ప్రత్యామ్నాయాన్ని అందిస్తుంది. అదనంగా, చేర్చడం shlex మాడ్యూల్ సంక్లిష్ట షెల్ కమాండ్‌ల సరైన పార్సింగ్‌ను నిర్ధారిస్తుంది. మీ ఆపరేటింగ్ సిస్టమ్ యొక్క కమాండ్-లైన్ సాధనాల యొక్క పూర్తి సామర్థ్యాన్ని ఉపయోగించుకునేటప్పుడు ఈ పద్ధతులను అర్థం చేసుకోవడం వలన మీరు పైథాన్ యొక్క బలాన్ని పెంచుకోవచ్చు.