సబ్ ప్రాసెస్. రన్ మెథడ్
Subprocess.run పద్ధతి వాదనల జాబితాను తీసుకుంటుంది. పద్ధతి అని పిలవబడినప్పుడు, అది ఆదేశాన్ని అమలు చేస్తుంది మరియు ప్రక్రియ పూర్తయ్యే వరకు వేచి ఉంటుంది, చివరికి పూర్తయిన ప్రాసెస్ వస్తువును తిరిగి ఇస్తుంది. కంప్లీటెడ్ ప్రాసెస్ ఆబ్జెక్ట్ stdout, stderr, మెథడ్‌కు కాల్ చేస్తున్నప్పుడు ఉపయోగించిన ఒరిజినల్ ఆర్గ్యుమెంట్‌లు మరియు రిటర్న్ కోడ్‌ను అందిస్తుంది. Stdout అనేది కమాండ్ ద్వారా ఉత్పత్తి చేయబడిన డేటా స్ట్రీమ్‌ని సూచిస్తుంది, అయితే stderr ప్రోగ్రామ్ అమలు సమయంలో ఏవైనా ఎర్రర్‌లను సూచిస్తుంది. ఏదైనా సున్నా కాని రిటర్న్ కోడ్ (నిష్క్రమణ కోడ్) అంటే subprocess.run పద్ధతిలో అమలు చేయబడిన ఆదేశంతో లోపం అని అర్థం.
ఉదాహరణ 1: Subprocess.run పద్ధతిని ఉపయోగించి టెక్స్ట్ ఫైల్ యొక్క అవుట్‌పుట్ కంటెంట్‌లు
దిగువ ఆదేశం ఒక డేటా.టెక్స్ట్ ఫైల్ యొక్క కంటెంట్‌ను అవుట్‌పుట్ చేస్తుంది, అది పేరు = జాన్ స్ట్రింగ్‌ని కలిగి ఉంటుంది.
దిగుమతి ఉప ప్రక్రియ
ఉప ప్రక్రియ.అమలు(['పిల్లి', 'data.txt'])
పైన కోడ్‌ని అమలు చేయడం వలన కింది అవుట్‌పుట్ వస్తుంది:
పేరు=జాన్
ప్రక్రియ పూర్తయింది(వాదిస్తుంది=['పిల్లి', 'data.txt'],తిరిగి కోడ్=0)
జాబితా వాదన యొక్క మొదటి అంశం అమలు చేయవలసిన ఆదేశం పేరు. మొదటి మూలకాన్ని అనుసరించే జాబితాలో ఏదైనా మూలకం కమాండ్-లైన్ ఎంపికలు లేదా స్విచ్‌లుగా పరిగణించబడుతుంది. ఎంపికలను నిర్వచించడానికి మీరు సింగిల్ డాష్ మరియు డబుల్ డాష్‌లను ఉపయోగించవచ్చు. ఉదాహరణకు, డైరెక్టరీలో ఫైల్‌లు మరియు ఫోల్డర్‌లను జాబితా చేయడానికి, కోడ్ subprocess.run ([ls, -l] గా ఉంటుంది. వీటిలో చాలా సందర్భాలలో, మీరు షెల్ కమాండ్‌లోని ఏదైనా స్పేస్ -సెపరేట్ ఆర్గ్యుమెంట్‌ను వ్యక్తిగత అంశంగా పరిగణించవచ్చు. subprocess.run పద్ధతికి జాబితా సరఫరా చేయబడింది.
ఉదాహరణ 2: Subprocess.run పద్ధతి యొక్క అవుట్‌పుట్‌ను అణచివేయండి
Subprocess.run పద్ధతి యొక్క అవుట్‌పుట్‌ను అణచివేయడానికి, మీరు stdout = subprocess.DEVNULL మరియు stderr = subprocess.DEVNULL ని అదనపు వాదనలుగా సరఫరా చేయాలి.
దిగుమతి ఉప ప్రక్రియఉప ప్రక్రియ.అమలు(['పిల్లి', 'data.txt'],stdout=ఉప ప్రక్రియ.DEVNULL,
stderr=ఉప ప్రక్రియ.DEVNULL)
పైన కోడ్‌ని అమలు చేయడం వలన కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:
పూర్తయింది
ఉదాహరణ 3: సబ్‌ప్రోసెస్.రన్ మెథడ్ యొక్క క్యాప్చర్ అవుట్‌పుట్
Subprocess.run పద్ధతి యొక్క అవుట్‌పుట్‌ను సంగ్రహించడానికి, capture_output = ట్రూ అనే అదనపు వాదనను ఉపయోగించండి.
దిగుమతి ఉప ప్రక్రియఅవుట్పుట్= ఉప ప్రక్రియ.అమలు(['పిల్లి', 'data.txt'],capture_output=నిజమే)
ముద్రణ (అవుట్‌పుట్)
పైన కోడ్‌ని అమలు చేయడం వలన కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:
ప్రక్రియ పూర్తయింది(వాదిస్తుంది=['పిల్లి', 'data.txt'],తిరిగి కోడ్=0,stdout=బిపేరు = జాన్ n',stderr=బి'')
అవుట్‌పుట్.స్టడౌట్ మరియు అవుట్‌పుట్.స్టెడెర్ పద్ధతులను ఉపయోగించి మీరు వ్యక్తిగతంగా stdout మరియు stderr విలువలను యాక్సెస్ చేయవచ్చు. అవుట్‌పుట్ బైట్ సీక్వెన్స్‌గా ఉత్పత్తి చేయబడుతుంది. స్ట్రింగ్‌ను అవుట్‌పుట్‌గా పొందడానికి, output.stdout.decode (utf-8) పద్ధతిని ఉపయోగించండి. స్ట్రింగ్ ఫార్మాట్‌లో అవుట్‌పుట్ పొందడానికి మీరు సబ్‌ప్రాసెస్.రన్ కాల్‌కు అదనపు ఆర్గ్యుమెంట్‌గా టెక్స్ట్ = ట్రూని కూడా అందించవచ్చు. నిష్క్రమణ స్థితి కోడ్ పొందడానికి, మీరు output.returncode పద్ధతిని ఉపయోగించవచ్చు.
ఉదాహరణ 4: Subprocess.run పద్ధతి ద్వారా అమలు చేయబడిన కమాండ్ వైఫల్యంపై మినహాయింపును పెంచండి
సున్నా కాని స్థితిలో కమాండ్ నిష్క్రమించినప్పుడు మినహాయింపుని పెంచడానికి, చెక్ = నిజమైన వాదనను ఉపయోగించండి.
దిగుమతి ఉప ప్రక్రియఉప ప్రక్రియ.అమలు(['పిల్లి', 'data.tx'],capture_output=నిజమే,టెక్స్ట్=నిజమే,తనిఖీ=నిజమే)
పైన కోడ్‌ని అమలు చేయడం వలన కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:
కాల్డ్ ప్రాసెస్‌ఎరర్‌ను పెంచండి (రీట్‌కోడ్, ప్రాసెస్.ఆర్గ్స్,subprocess.CalledProcessError: కమాండ్ '[' 'cat', 'data.tx'] '
సున్నా కాని నిష్క్రమణ స్థితి 1 తిరిగి ఇవ్వబడింది.
ఉదాహరణ 5: Subprocess.run పద్ధతి ద్వారా అమలు చేయబడిన కమాండ్‌కు స్ట్రింగ్‌ను పాస్ చేయండి
మీరు ఇన్పుట్ = 'స్ట్రింగ్' ఆర్గ్యుమెంట్ ఉపయోగించి subprocess.run పద్ధతి ద్వారా అమలు చేయవలసిన ఆదేశానికి స్ట్రింగ్‌ను పంపవచ్చు.
దిగుమతి ఉప ప్రక్రియఅవుట్పుట్= ఉప ప్రక్రియ.అమలు(['పిల్లి'], ఇన్పుట్='data.txt',capture_output=నిజమే,
టెక్స్ట్=నిజమే,తనిఖీ=నిజమే)
ముద్రణ (అవుట్‌పుట్)
పైన కోడ్‌ని అమలు చేయడం వలన కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:
పూర్తయిన ప్రక్రియ (ఆర్గ్స్ = ['క్యాట్'], రిటర్న్‌కోడ్ = 0, stdout = 'data.txt', stderr = '')మీరు చూడగలిగినట్లుగా, పై కోడ్ data.txt ను స్ట్రింగ్‌గా పాస్ చేస్తుంది మరియు ఫైల్ ఆబ్జెక్ట్‌గా కాదు. Data.txt ని ఫైల్‌గా పాస్ చేయడానికి, stdin ఆర్గ్యుమెంట్ ఉపయోగించండి.
తో తెరవండి('data.txt') గాf:అవుట్‌పుట్= ఉప ప్రక్రియ.అమలు(['పిల్లి'],stdin=f,capture_output=నిజమే,
టెక్స్ట్=నిజమే,తనిఖీ=నిజమే)
ముద్రణ (అవుట్‌పుట్)
పైన కోడ్‌ని అమలు చేయడం వలన కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:
పూర్తయిన ప్రక్రియ (ఆర్గ్స్ = ['క్యాట్'], రిటర్న్‌కోడ్ = 0, stdout = 'name = John n', stderr = '')ఉదాహరణ 6: Subprocess.run పద్ధతిని ఉపయోగించి కమాండ్‌ను నేరుగా షెల్‌లో అమలు చేయండి
ప్రధాన కమాండ్‌లో స్ట్రింగ్ స్ప్లిట్ మరియు దానిని అనుసరించే ఆప్షన్‌లను ఉపయోగించడానికి బదులుగా కమాండ్‌ను షెల్‌లోకి నేరుగా అమలు చేయడం సాధ్యపడుతుంది. దీన్ని చేయడానికి, మీరు తప్పనిసరిగా అదనపు వాదనగా షెల్ = ట్రూ పాస్ చేయాలి. అయితే ఇది పైథాన్ డెవలపర్‌లచే నిరుత్సాహపరచబడింది, ఎందుకంటే షెల్ = ట్రూ ఉపయోగించడం భద్రతా సమస్యలకు దారితీస్తుంది. మీరు దీని నుండి భద్రతా చిక్కుల గురించి మరింత చదవవచ్చు ఇక్కడ .
దిగుమతి ఉప ప్రక్రియఉప ప్రక్రియ.అమలు('cat' data.txt '',పెంకు=నిజమే)
పైన కోడ్‌ని అమలు చేయడం వలన కింది అవుట్‌పుట్ ఉత్పత్తి అవుతుంది:
పేరు = జాన్ముగింపు
పైథాన్‌లోని subprocess.run పద్ధతి చాలా శక్తివంతమైనది, ఎందుకంటే ఇది పైథాన్‌లోనే షెల్ ఆదేశాలను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ప్రత్యేక ఫైల్స్‌లో అదనపు షెల్ స్క్రిప్ట్ కోడ్ అవసరం లేకుండానే అన్ని కోడ్‌లను పైథాన్‌కి పరిమితం చేయడంలో ఇది సహాయపడుతుంది. అయితే, పైథాన్ జాబితాలో షెల్ ఆదేశాలను సరిగ్గా టోకనైజ్ చేయడం చాలా గమ్మత్తైనది. సాధారణ షెల్ ఆదేశాలను టోకనైజ్ చేయడానికి మీరు shlex.split () పద్ధతిని ఉపయోగించవచ్చు, కానీ పొడవైన, సంక్లిష్టమైన ఆదేశాలలో - ముఖ్యంగా పైప్ చిహ్నాలు ఉన్నవి - shlex సరిగ్గా ఆదేశాన్ని విభజించడంలో విఫలమవుతుంది. అటువంటి సందర్భాలలో, డీబగ్గింగ్ ఒక గమ్మత్తైన సమస్య కావచ్చు. దీనిని నివారించడానికి మీరు షెల్ = నిజమైన వాదనను ఉపయోగించవచ్చు, కానీ ఈ చర్యతో సంబంధం ఉన్న కొన్ని భద్రతా సమస్యలు ఉన్నాయి.