పైథాన్ అనేది ఒక ఉన్నత-స్థాయి భాష, ఇది సాధారణ కోడ్‌లను చేయడం కోసం రూపొందించబడింది మరియు ఏదైనా నిర్దిష్ట సమస్య కోసం కాదు. పైథాన్‌ని ఉపయోగించి వెబ్‌సైట్‌లను రూపొందించడం లేదా ఈ పైథాన్ భాషను ఉపయోగించి డేటాను విశ్లేషించడం వంటి సాధారణ ప్రయోజనాల కోసం మేము దీనిని ఉపయోగించుకోవచ్చు. “పైథాన్” ప్రోగ్రామింగ్ కమాండ్_లైన్ ఆర్గ్యుమెంట్‌లను కూడా అందిస్తుంది. ఫైల్ ఎక్స్‌టెన్షన్‌తో పాటు కోడ్ ఫైల్ పేరును పేర్కొన్న తర్వాత ఏదైనా ఆపరేటింగ్ సిస్టమ్ యొక్క కన్సోల్ లేదా టెర్మినల్‌లో మనం ఇచ్చిన ఆర్గ్యుమెంట్‌లను కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లు అంటారు. ఏదైనా ప్రోగ్రామ్‌లో, కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లుగా చెప్పబడే కమాండ్ ప్రాంప్ట్ ద్వారా పంపబడే విలువగా కూడా మనం నిర్వచించవచ్చు. ఈ గైడ్‌లో, మేము “పైథాన్” ప్రోగ్రామింగ్‌లో కమాండ్ లైన్ ఆర్గ్యుమెంట్ గురించి చర్చిస్తాము.
పైథాన్‌లో కమాండ్ లైన్ ఆర్గ్యుమెంట్‌ల కోసం పద్ధతులు
- “sys.argv”ని ఉపయోగించడం ద్వారా
- 'argparse' మాడ్యూల్ ఉపయోగించడం ద్వారా
- 'గెటాప్ట్' మాడ్యూల్ను ఉపయోగించడం ద్వారా
మేము ఈ గైడ్‌లో అన్ని పద్ధతులను వివరంగా వివరిస్తాము మరియు ఆ అన్ని పద్ధతుల యొక్క ఆచరణాత్మక ప్రదర్శనను కూడా చూపుతాము.
ఉదాహరణ # 01: sys.argv పద్ధతి ద్వారా
మేము ఈ పైథాన్ కోడ్‌లను “స్పైడర్” యాప్‌లో చేస్తున్నాము. సిస్టమ్‌ను దిగుమతి చేయడం ద్వారా మనం కమాండ్ లైన్ వేరియబుల్స్ మరియు ఫంక్షన్‌లను యాక్సెస్ చేయవచ్చు. కాబట్టి, మేము “sys”ని దిగుమతి చేసి, ఆపై “len(sys.argv)”తో “num” వేరియబుల్‌ని డిక్లేర్ చేస్తాము మరియు ప్రారంభించాము. “argv” అనేది స్ట్రింగ్ విలువల జాబితా అవుతుంది, అవి మా కమాండ్ లైన్‌గా మారే ఆర్గ్యుమెంట్‌లు. 'len' అనేది ఆమోదించబడిన ఆర్గ్యుమెంట్‌ల పొడవును సూచిస్తుంది. కాబట్టి, 'num' వేరియబుల్‌లో కమాండ్ లైన్ నిల్వ చేయబడినందున టెర్మినల్‌లో ఆమోదించబడిన విలువల సంఖ్య.
'ప్రింట్'ని ఉపయోగించడం ద్వారా ఆమోదించబడిన ఆర్గ్యుమెంట్ నంబర్‌లను కూడా మేము ప్రదర్శిస్తాము. దీని క్రింద, మేము ప్రింట్ స్టేట్‌మెంట్‌లో “sys.argv[0]”ని ఉంచాము. “argv” ఎల్లప్పుడూ ప్రోగ్రామ్ పేరు లేదా కోడ్ ఫైల్ పేరును కలిగి ఉంటుంది. కాబట్టి, మేము సృష్టించిన ఫైల్ పేరు టెర్మినల్‌లో రెండర్ చేయబడుతుంది. దీని తరువాత, మేము టెర్మినల్‌లో ఆమోదించబడిన ఆ ఆర్గ్యుమెంట్‌లను ప్రింట్ చేస్తాము. ఇది కన్సోల్ స్క్రీన్‌పై కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లుగా మనం పాస్ చేసిన అన్ని సంఖ్యలను ప్రింట్ చేస్తుంది.
దీని క్రింద, మేము లూప్ కోసం a నిర్వచించాము మరియు అక్కడ 'a' వేరియబుల్‌ని ప్రకటించాము, దాని పరిధి '1' నుండి 'num'లో నిల్వ చేయబడిన argv పొడవు వరకు ఉంటుంది. కన్సోల్‌లో అన్ని ఆర్గ్యుమెంట్‌లను ప్రింట్ చేయండి. “argv[a]” అన్ని కమాండ్_లైన్ ఆర్గ్యుమెంట్‌లను కలిగి ఉంది. ఇది వాటిని కన్సోల్‌లో కూడా ప్రదర్శిస్తుంది. ఇప్పుడు, మేము 'మొత్తం' ప్రారంభిస్తున్నాము ఎందుకంటే మేము టెర్మినల్‌లో అమలు చేసే సమయంలో పాస్ చేసే అన్ని విలువల మొత్తాన్ని లెక్కించాలనుకుంటున్నాము.
మేము మళ్ళీ 'ఫర్' లూప్‌ని ఉపయోగించుకుంటాము మరియు పరిధిని దాటుతాము. కానీ ఈసారి, మేము టెర్మినల్‌లో పాస్ చేసిన అన్ని విలువల మొత్తాన్ని గణిస్తున్నాము. ఈ మొత్తం “మొత్తం” వేరియబుల్‌లో నిల్వ చేయబడుతుంది. అప్పుడు, మేము టెర్మినల్‌లో అమలు చేసే సమయంలో పాస్ చేసే అన్ని విలువల మొత్తాన్ని కూడా ముద్రిస్తాము.
దిగుమతి sysఒకదానిపై = మాత్రమే ( sys . argv )
ముద్రణ ( 'మొత్తం వాదనలు ఇక్కడ ఆమోదించబడ్డాయి :' , ఒకదానిపై )
ముద్రణ ( ' \n పైథాన్ ఫైల్ పేరు:' , sys . argv [ 0 ] )
ముద్రణ ( ' \n మేము ఆమోదించిన వాదనలు:' , ముగింపు = '' )
కోసం a లో పరిధి ( 1 , ఒకదానిపై ) :
ముద్రణ ( sys . argv [ a ] , ముగింపు = '' )
మొత్తం = 0
కోసం i లో పరిధి ( 1 , ఒకదానిపై ) :
మొత్తం + = int ( sys . argv [ i ] )
ముద్రణ ( ' \n \n ఆమోదించబడిన వాదనల మొత్తం: ' , మొత్తం )
టెర్మినల్‌లో, మేము మొదట 'రన్' కీవర్డ్‌ను ఉంచాము. అప్పుడు, ఫైల్ పేరును సరైన పొడిగింపుతో పాటు ఉంచండి మరియు కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను ఇక్కడ పాస్ చేయండి. కాబట్టి, పై కోడ్‌లో మనం నిర్వచించినట్లుగా ఇది అన్ని పంక్తులను ప్రదర్శిస్తుంది. ఇది మొదట కమాండ్ లైన్ ఆర్గ్యుమెంట్‌ల పొడవును ఆపై ఫైల్ పేరును అందిస్తుంది. దీని తరువాత, ఇది అన్ని కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను అందిస్తుంది మరియు వాటన్నింటి మొత్తాన్ని కూడా అందిస్తుంది.
ఉదాహరణ # 02: argparse పద్ధతి ద్వారా
ఇప్పుడు, మేము ఈ ఉదాహరణలో “argparse” పద్ధతిని ఉపయోగిస్తున్నాము. మేము మొదట 'argparse' ను దిగుమతి చేస్తాము. కాబట్టి, మేము దీని యొక్క వేరియబుల్స్ మరియు ఫంక్షన్‌ను యాక్సెస్ చేస్తాము. మేము 'డేటా' వేరియబుల్‌ని ప్రారంభించాము మరియు మా కోడ్‌లో ఉపయోగించుకునే పంక్తిని నిల్వ చేస్తాము. దీని తర్వాత, మేము “పార్సర్”ని ప్రారంభిస్తున్నాము మరియు “వివరణ”లో “డేటా” వేరియబుల్‌ను పాస్ చేస్తాము, దీనిలో మనం ప్రదర్శించదలిచిన సందేశాన్ని నిల్వ చేస్తాము మరియు వీటన్నింటినీ “my_parser” వేరియబుల్‌లో ఉంచాము. మేము చివరలో “parse.args()” కూడా ఉంచాము.
దిగుమతి argparseసమాచారం = 'మేము ఇక్కడ argparse పద్ధతిని ఉపయోగిస్తున్నాము'
నా_పార్సర్ = argparse. ఆర్గ్యుమెంట్ పార్సర్ ( వివరణ = సమాచారం )
నా_పార్సర్. పార్స్_ఆర్గ్స్ ( )
దిగువ ఫలితాన్ని చూడండి. మేము కమాండ్ లైన్ ఆర్గ్యుమెంట్‌గా “-h”ని పాస్ చేసినప్పుడు అది మొదట మనం “డేటా” వేరియబుల్‌లో నిల్వ చేసిన సందేశాన్ని రెండర్ చేస్తుంది మరియు ఈ “h” సహాయ సందేశాన్ని చూపుతున్నందున “ఐచ్ఛిక ఆర్గ్యుమెంట్” కూడా చూపుతుంది. మేము కమాండ్ లైన్ ఆర్గ్యుమెంట్‌గా “-o”ని ఉంచినప్పుడు, ఇది గుర్తించబడని ఆర్గ్యుమెంట్ అని దోష సందేశాన్ని అందిస్తుంది.
ఉదాహరణ # 03: గెటాప్ట్ పద్ధతి ద్వారా
ఈ కోడ్‌లో మేము ఉపయోగిస్తున్న చివరి పద్ధతి ఇక్కడ ఉంది. మేము ఈ కోడ్‌లో “sys” అలాగే “getopt”ని దిగుమతి చేస్తున్నాము. ఈ “గెటోప్ట్” అనేది కమాండ్ లైన్ ఆర్గ్యుమెంట్‌ల కోసం మనం ఉపయోగించిన పార్సర్. అప్పుడు, “argumentList” వేరియబుల్‌లో, మేము కమాండ్ లైన్‌లో పాస్ చేస్తున్న మొదటి ఆర్గ్యుమెంట్‌ను తీసివేయడానికి “sys.argv[1:]”ని పాస్ చేసాము. మేము 'hmo:'తో 'my_option'ని ప్రారంభిస్తాము.
దీని తర్వాత, మేము “my_long_option” వేరియబుల్‌ని ప్రారంభిస్తున్నాము. మేము ఇక్కడ 'ప్రయత్నించు'ని ఉపయోగిస్తాము, ఇది లోపాన్ని తనిఖీ చేస్తుంది. దీని తరువాత, మేము వాదనలను అన్వయిస్తున్నాము. 'getopt' విలువను సూచించే ఎంపికతో పాటు చిన్న మరియు పొడవైన ఎంపికలను అందిస్తుంది. దీని తరువాత, మేము కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లుగా పాస్ చేసే అన్ని ఆర్గ్యుమెంట్‌లను తనిఖీ చేస్తున్నాము. కమాండ్ లైన్ ఆర్గ్యుమెంట్ “-h” లేదా “–Help” అయితే, ఇది క్రింద ఇవ్వబడిన సందేశాన్ని ప్రింట్ చేస్తుంది. కమాండ్ లైన్ ఆర్గ్యుమెంట్ “-m” లేదా “—My_file” అయితే, ఇది దీని తర్వాత వ్రాసిన సందేశాన్ని ప్రదర్శిస్తుంది.
అలాగే, కమాండ్ లైన్ ఆర్గ్యుమెంట్ “-o” లేదా “–ఔట్‌పుట్” అయితే, ఇది మనం ఇక్కడ వ్రాసిన సందేశాన్ని కూడా ప్రదర్శిస్తుంది. కమాండ్ లైన్ ఆర్గ్యుమెంట్ పైన పేర్కొన్న అన్నిటి నుండి కాకపోతే, అది మనం “getopt”ని ఉంచినట్లుగా దోష సందేశాన్ని ప్రదర్శిస్తుంది. కోడ్‌లో లోపం'.
దిగుమతి అగ్రస్థానంలో నిలిచింది , sysవాదనల జాబితా = sys . argv [ 1 : ]
my_options = 'రాత్రి:'
new_long_options = [ 'సహాయం' , 'My_file' , 'అవుట్‌పుట్='
ప్రయత్నించండి :
వాదనలు , విలువలు = అగ్రస్థానంలో నిలిచింది . అగ్రస్థానంలో నిలిచింది ( వాదనల జాబితా , my_options , new_long_options )
కోసం నా_వాదన , నా_విలువ లో వాదనలు:
ఉంటే నా_వాదన లో ( '-h' , '--సహాయం' ) :
ముద్రణ ( 'సహాయాన్ని ప్రదర్శిస్తోంది' )
ఎలిఫ్ నా_వాదన లో ( '-m' , '--My_file' ) :
ముద్రణ ( 'ఫైల్_పేరును ప్రదర్శిస్తోంది:' , sys . argv [ 0 ] )
ఎలిఫ్ నా_వాదన లో ( '-ఓ' , '--అవుట్‌పుట్' ) :
ముద్రణ ( ( 'ప్రత్యేక అవుట్‌పుట్ మోడ్‌ను ప్రారంభిస్తోంది (% s)' ) % ( నా_విలువ ) )
తప్ప అగ్రస్థానంలో నిలిచింది . లోపం వంటి తప్పు:
ముద్రణ ( str ( తప్పు ) )
కమాండ్ లైన్‌గా “-h”ని ఉంచినప్పుడు అది మనం కోడ్‌లో వ్రాసిన అదే సందేశాన్ని ప్రదర్శిస్తుందని ఇక్కడ మీరు చూస్తారు. మేము రెండు కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లను “–Help” మరియు “-m”గా ఉంచినప్పుడు, అది క్రింద రెండు సందేశాలను ప్రదర్శిస్తుంది. “-o” కమాండ్ లైన్ ఆర్గ్యుమెంట్‌లో, మేము సందేశంలో ప్రదర్శించబడే స్ట్రింగ్‌ను కూడా పాస్ చేసాము.
ముగింపు
'పైథాన్'లో 'కమాండ్ లైన్ ఆర్గ్యుమెంట్స్' అనే భావనను నేర్చుకోవడంలో మీకు సహాయపడటానికి మేము ఈ గైడ్‌ని అందించాము. మేము 'కమాండ్ లైన్ ఆర్గ్యుమెంట్'ని అన్వేషించాము మరియు ఇక్కడ మూడు పద్ధతులను కూడా వివరించాము. కమాండ్ ప్రాంప్ట్ ద్వారా అమలు చేసే సమయానికి ప్రోగ్రామ్ పేరుతో పాటు ప్రోగ్రామ్‌కు విలువలను పంపే ప్రక్రియ కమాండ్ లైన్ వాదనను మేము వివరించాము.