పైథాన్ ఆర్గ్‌పార్స్ బూలియన్ జెండా

ఫ్లాగ్ అనేది బూలియన్ వేరియబుల్, ఇది ఒక నిర్దిష్ట పరిస్థితి సంభవించినప్పుడు ప్రోగ్రామర్‌లను హెచ్చరిస్తుంది. బూలియన్ ఫ్లాగ్ నిజాన్ని సూచిస్తే, అది కొంత పరిస్థితి ఉందని సూచిస్తుంది. బూలియన్ ఫ్లాగ్ తప్పుని సూచించినప్పుడు, అది ఒక నిర్దిష్ట షరతు నిజం కాదని సూచిస్తుంది. ప్రిడికేట్ పార్స్ 'నిజం' లేదా 'తప్పు' అని నిర్ధారించడానికి, 'ఆర్గ్‌పార్స్' బూలియన్ ఫ్లాగ్ పాస్ అయ్యే ఆర్గ్యుమెంట్‌లను అన్వయిస్తుంది. కమాండ్-లైన్ ఆర్గ్యుమెంట్‌లను అర్థం చేసుకోవడానికి “argparse” అనే ప్రామాణిక పైథాన్ ప్యాకేజీని ఉపయోగించవచ్చు. ఇది కార్యాచరణను మెరుగ్గా నియంత్రిస్తుంది మరియు కోడ్ చేయడం సులభం. మేము కొన్ని తప్పుడు వాదనలను అందించినప్పుడు వినియోగదారు కోసం మార్గదర్శకత్వం మరియు వినియోగ సందేశం రూపొందించబడుతుంది. అదనంగా, ఇది వినియోగదారు సమస్యల లోపాలను చూపుతుంది. 'argparse' మాడ్యూల్ ఉపయోగించడానికి సులభమైనది. స్టోర్ నిజమైన ఎంపిక యొక్క డిఫాల్ట్ విలువ తప్పు, అయితే స్టోర్ తప్పు యొక్క డిఫాల్ట్ విలువ ఒప్పు. “argparse” మాడ్యూల్‌ను ఉపయోగించడానికి, మనం తప్పనిసరిగా మూడు కీలక దశలకు కట్టుబడి ఉండాలి: ముందుగా పార్సర్‌ను రూపొందించడం, పార్సర్‌కు మరిన్ని ఆర్గ్యుమెంట్‌లను ఇవ్వడం మరియు పారామితులను అన్వయించడం.

సింటాక్స్:

పైథాన్ “ఆర్గ్‌పార్స్” బూలియన్ ఫ్లాగ్‌కు అవసరమైన సింటాక్స్ కింది వాటిలో ఇవ్వబడింది:

సింటాక్స్ ముందుగా ఆర్గ్యుమెంట్ ఆమోదించబడిన వేరియబుల్స్ మరియు లైబ్రరీలను నిల్వ చేసే ఫంక్షన్‌ను సృష్టించాలి మరియు ఆవశ్యకతకు అనుగుణంగా షరతు సెట్ చేయబడుతుంది. మా షరతుల కోసం రెండు బూలియన్ వెర్బోస్‌లు 'ఒప్పు' లేదా 'తప్పు' కోసం తనిఖీ చేయబడ్డాయి.

ఉదాహరణ 1: పైథాన్ “ఆర్గ్‌పార్స్” బూలియన్ ఫ్లాగ్ యొక్క ప్రశాంతమైన పరిధిని ఉపయోగించడం

సాధారణ బూలియన్ ఫ్లాగ్, ఆమోదించబడిన షరతు 'నిజం' లేదా 'తప్పు' అయినా, ఆర్గ్యుమెంట్ దృష్టాంతం వైపు చూసే సింగిల్ లేదా బహుళ ఆర్గ్యుమెంట్‌లుగా ఉండే ఆర్గ్యుమెంట్‌లను అన్వయిస్తుంది.

ఇప్పుడు, ఇక్కడ నుండి మన కోడ్ స్నిప్పెట్‌ని చర్చిద్దాం.

మా కోడ్ ప్రారంభంలో, మేము పైథాన్ ఆర్గ్యుమెంట్‌లను అన్వయించడంతో వ్యవహరించే “argparse” లైబ్రరీని దిగుమతి చేస్తాము. ఆపై, మేము మా వినియోగదారు నిర్వచించిన “argparse_Boolean” ఫంక్షన్‌ని సృష్టిస్తాము మరియు దానిని లైబ్రరీకి ఎక్కడ కేటాయించాలి. అప్పుడు, 'add_argument()' ఫంక్షన్‌ని ఉపయోగించి 'కార్లు' అయిన మా 'argparse_Boolean' ఫంక్షన్‌లో మన మొదటి వాదనను పాస్ చేస్తాము. ఆమోదించబడిన రెండవ వాదన కేవలం 'వెర్బోస్'ని కేటాయిస్తుంది, ఇక్కడ మేము వారికి అందించిన చర్య 'నిజం' వెర్బోస్‌ను నిల్వ చేస్తుంది. ఇప్పుడు, మేము ఆర్గ్యుమెంట్‌లను అన్వయించడం కోసం ముందే నిర్వచించిన లైబ్రరీకి కాల్ చేయడానికి ఉపయోగించే “Boolean_flag” యొక్క కొత్త ఫంక్షన్‌ని సృష్టిస్తాము. చివరగా, మేము “కార్లు” మరియు “వెర్బోస్” అనే రెండు ఆర్గ్యుమెంట్‌ల కోసం “ప్రింట్()” ఫంక్షన్‌ని ఉపయోగిస్తాము.

మునుపటి కోడ్ స్నిప్పెట్ నుండి, మేము ఈ అవుట్‌పుట్‌ను ఏ ఆర్గ్యుమెంట్‌ని స్వీకరించని చోట పొందుతాము, కనుక ఇది “ఏదీ లేదు” అని ప్రదర్శిస్తుంది. రెండవ వాదన కనుగొనబడలేదు లేదా సరిపోలలేదు, కనుక ఇది 'తప్పు' వెర్బోస్ ఇస్తుంది.

ఉదాహరణ 2: పైథాన్ చేత ప్రేరేపించబడిన ఆర్గ్యుమెంట్ పార్సింగ్‌ను బూలియన్ విలువలుగా ఉపయోగించడం

ఈ ఉదాహరణ మునుపటి ఉదాహరణతో సమానంగా ఉంటుంది. ఇక్కడ, మేము వినియోగదారు నిర్వచించిన వాదనల కోసం బూలియన్ విలువల చర్యలను చర్చిస్తాము. మేము బూలియన్ వెర్బోస్ చర్య కోసం ఆర్గ్యుమెంట్‌లను ఎంచుకోవాలనుకుంటే, మేము ఈ పద్ధతిని ఉపయోగించవచ్చు.

ఈ కోడ్ ఉదాహరణలో, లైబ్రరీ మునుపటి దానిలో ఉపయోగించిన అదే 'argparse'గా ఉంటుంది. సృష్టించబడిన ఫంక్షన్‌కి ఇప్పుడు “Boolean_parser” అని పేరు పెట్టారు. మేము అందించే ఆర్గ్యుమెంట్‌లు రెండు  వేరియబుల్‌లు – “ఫస్ట్_వేరియబుల్” మరియు “సెకండ్_వేరియబుల్” – ఇక్కడ మొదటి ఆర్గ్యుమెంట్ కోసం చర్య “తప్పు”గా నిల్వ చేయబడుతుంది మరియు రెండవ ఆర్గ్యుమెంట్ “నిజం”గా నిల్వ చేయబడుతుంది. చివరగా, మేము “parser_args()” ఫంక్షన్‌ని ఉపయోగించి “Boolean_parser” ఫంక్షన్‌ని పిలుస్తాము మరియు దానిని “Flag_Argument”లో నిల్వ చేస్తాము. దాని విజువలైజేషన్ కోసం, మేము “print()” ఫంక్షన్‌ని ఉపయోగిస్తాము మరియు దానిని “Flag_Argument”లో కేటాయిస్తాము.

ఇది మునుపటి కోడ్ ఉదాహరణ యొక్క అవుట్‌పుట్ స్నాప్‌షాట్, ఇది బూలియన్ విలువలను “First_Variable” కోసం “True”గా మరియు “Second_Variable” కోసం “False”గా వివరిస్తుంది.

ఉదాహరణ 3: షరతులతో కూడిన ప్రకటనలను నిర్వహించడం ద్వారా “ఆర్గ్‌పార్స్” బూలియన్ ఫ్లాగ్‌ను ఉపయోగించడం

పేరు సూచించినట్లుగా, షరతులను నిర్వహించడానికి మీ ప్రోగ్రామ్‌లో షరతులతో కూడిన ప్రకటన ఉపయోగించబడుతుంది. ఇది ఎదుర్కొనే పరిస్థితులకు ప్రతిస్పందనగా తీర్పులు ఇచ్చినప్పుడు ఈ అభ్యాసాలు ప్రోగ్రామ్ యొక్క మార్గదర్శకాలు. పైథాన్‌లోని ప్రధాన షరతులతో కూడిన స్టేట్‌మెంట్‌లు “If”, “if-else” మరియు “switch” స్టేట్‌మెంట్‌లు. ఇక్కడ, మేము 'if-else' షరతులతో కూడిన ప్రకటన ద్వారా వెళ్తాము.

మేము ఆర్గ్యుమెంట్ పార్సింగ్‌తో వ్యవహరించేటప్పుడు లైబ్రరీ అదే 'argparse' గా ఉంటుంది. మేము ఇక్కడ సృష్టించిన ఫంక్షన్‌కి “parser_flag” అని పేరు పెట్టారు. మేము కేటాయించిన మొదటి వాదన “పెర్ఫార్మ్-యాక్షన్” మరియు ఇక్కడ ఇవ్వబడిన డిఫాల్ట్ విలువ “తప్పు”, ఇక్కడ “చర్య” “నిజం” అని నిల్వ చేస్తుంది. ఆర్గ్యుమెంట్‌ను పాస్ చేసిన తర్వాత, మేము 'arguments_flag' పేరుతో కొత్త ఫంక్షన్‌ని సృష్టిస్తాము మరియు దాని ఆర్గ్యుమెంట్‌లతో పాటు మునుపటి వినియోగదారు నిర్వచించిన ఫంక్షన్ 'parser_flag'తో కాల్ చేస్తాము. ఇక్కడ, మేము 'if-else' యొక్క మా షరతులతో కూడిన ప్రకటనను వర్తింపజేస్తాము. 'ప్రింట్()' ఫంక్షన్ మరియు 'పర్ఫార్మ్ యువర్ యాక్షన్' అనే ప్రింట్ స్టేట్‌మెంట్‌ను అనుసరించి ఆమోదించబడిన ఆర్గ్యుమెంట్   నిజమైనట్లయితే మా “ఇఫ్-కండిషన్” స్టోర్ చేస్తుంది. 'else-condition'లో, మొదటి ఆర్గ్యుమెంట్ పార్స్ 'నిజం' కాకపోతే, 'default'లో 'false' యొక్క 'else-statement'ని అమలు చేయండి. చివరగా, మేము ప్రింట్ స్టేట్‌మెంట్‌ల కోసం “ప్రింట్()” ఫంక్షన్‌ను రెండుసార్లు ఉపయోగిస్తాము, ఇది ఆర్గ్యుమెంట్‌లను అమలు చేయడం ద్వారా చర్యను ప్రదర్శిస్తుంది.

అవుట్‌పుట్ స్నాప్‌షాట్ ఆమోదించిన ఆర్గ్యుమెంట్ మేము కోడ్‌లో అందించే ప్రింట్ స్టేట్‌మెంట్‌లతో “తప్పుడు” వెర్బోస్‌తో “else-statement”ని అమలు చేస్తుందని నిర్ధారిస్తుంది.

ఉదాహరణ 4: 'డిస్టటిల్స్' మాడ్యూల్‌ని ఆపరేట్ చేయడం ద్వారా పైథాన్ “ఆర్గ్‌పార్స్” బూలియన్ ఫ్లాగ్‌ని ఉపయోగించడం

పైథాన్ ఇన్‌స్టాలేషన్ “డిస్టటిల్స్” మాడ్యూల్ సహాయంతో లైబ్రరీలను కంపైల్ చేసి మళ్లీ ఇన్‌స్టాల్ చేయగలదు. కొత్త మాడ్యూల్స్ C, ప్లెయిన్ పైథాన్ మాడ్యూల్స్ లేదా పైథాన్ లాంగ్వేజ్‌లో వ్రాసిన మాడ్యూల్‌లను కలిగి ఉన్న టూల్స్ మరియు ఫీచర్ల సేకరణలలో వ్రాయబడిన అవుట్‌గ్రోత్‌లు కావచ్చు.

'argparse' లైబ్రరీని దిగుమతి చేసిన తర్వాత, 'strtobool' యొక్క అదనపు లైబ్రరీని దిగుమతి చేయడం ద్వారా మేము 'distutils.util' మాడ్యూల్‌ని వర్తింపజేస్తాము. అప్పుడు, మేము “python_argparse r”ని దహనం చేసి, దానిని లైబ్రరీతో లింక్ చేస్తాము. ఆ తర్వాత, మేము 'బూలియన్' యొక్క 'python_argparse r'లో ఆర్గ్యుమెంట్‌ని జోడిస్తాము. అందించిన రకం “లాంబ్డా” మరియు “strtobool” లైబ్రరీతో కేటాయించబడిన వేరియబుల్ “b”లో నిల్వ చేయబడుతుంది. ఇక్కడ 'డిఫాల్ట్' కండిషన్ కోసం బూలియన్ విలువ 'నిజం' మరియు 'const' 'తప్పు'కి సెట్ చేయబడింది. అన్వయించిన తర్వాత, మేము దానిని సృష్టించిన తర్వాత 'boolean_arguments'లో నిల్వ చేస్తాము. అప్పుడు, మేము 'ప్రింట్()' ఫంక్షన్‌లో 'బూలియన్_ఆర్గ్యుమెంట్స్' అని పిలుస్తాము.

ఆమోదించబడిన వాదన చదవబడినప్పుడు, షరతు డిఫాల్ట్‌గా అమలు చేయబడినందున అవుట్‌పుట్ “నిజం” ప్రదర్శిస్తుంది.

ఉదాహరణ 5: షరతులతో కూడిన స్టేట్‌మెంట్‌లతో “డిస్టటిల్స్” మాడ్యూల్‌ని ఆపరేట్ చేయడం ద్వారా పైథాన్ “ఆర్గ్‌పార్స్” బూలియన్ ఫ్లాగ్‌ను ఉపయోగించడం

బూలియన్ ఫ్లాగ్‌లో ఆర్గ్యుమెంట్ పార్సింగ్ యొక్క దృగ్విషయాన్ని అమలు చేయడానికి  డిస్టిల్స్ మాడ్యూల్‌తో పాటు షరతులతో కూడిన స్టేట్‌మెంట్‌లను ఆపరేట్ చేయవచ్చు.

ఒకే సమయంలో షరతులతో కూడిన స్టేట్‌మెంట్ మరియు డిస్టిల్స్ మాడ్యూల్ యొక్క వినియోగాన్ని కనుగొనడానికి కోడ్ స్నిప్పెట్‌ను చూద్దాం. ఈ ప్రయోజనం కోసం, మేము “argparse”  లైబ్రరీని దిగుమతి చేస్తాము మరియు “distutils.util” మాడ్యూల్‌ని వర్తింపజేస్తాము. ఆ తర్వాత, మేము మునుపటి ఉదాహరణలో ఉపయోగించిన “strtobool” లైబ్రరీని అదేవిధంగా దిగుమతి చేస్తాము. ఆర్గ్యుమెంట్‌ల కోసం పార్స్‌ను రూపొందించడానికి మేము సృష్టించే ఫంక్షన్‌కు “bool_parser” అని పేరు పెట్టారు. మేము “రకమైన” వాదన మరియు “రకం” సెట్‌ను “str”గా, “nargs”ని “?”గా, “const”ని “False”గా మరియు “default”ని “True”గా జోడిస్తాము. ఇప్పుడు, మేము 'bool_arguments' యొక్క కొత్త ఫంక్షన్‌ని సృష్టిస్తాము, వీరికి మనం మునుపటి ఫంక్షన్‌ను దాని వాదనతో పాటు అన్వయిస్తాము. ఇక్కడ, మేము కండిషన్ స్టేట్‌మెంట్‌ను వర్తింపజేస్తాము, ఇక్కడ ఆమోదించబడిన ఆర్గ్యుమెంట్ ఉన్నట్లయితే, 'మీ బూలియన్ ఫ్లాగ్ ఈజ్' అనే ప్రింట్ మెసేజ్‌తో పాటు 'ట్రూ'ని ప్రదర్శిస్తుందని 'if' షరతు నిర్ణయిస్తుంది. అప్పుడు, ఇది 'ప్రింట్()'లో మనం కేటాయించిన 'రకమైన' వాదన యొక్క వెర్బోస్‌ను ప్రింట్ చేస్తుంది. లేకపోతే, అది బూలియన్ వ్యక్తీకరణగా డిఫాల్ట్‌గా “తప్పు” అవుతుంది.

అవుట్‌పుట్ స్నాప్‌షాట్‌లో, if-స్టేట్‌మెంట్ ఒప్పు అని మనం చూడవచ్చు కాబట్టి అది మన ప్రింట్ స్టేట్‌మెంట్‌తో పాటు “ట్రూ” అని ప్రదర్శిస్తుంది.

ముగింపు

మా వ్యాసంలో, మేము బూలియన్ ఫ్లాగ్‌లోని ఆర్గ్యుమెంట్ పార్స్ యొక్క ప్రధాన భావనలను కవర్ చేసాము. ఈ ప్రయోజనం కోసం, అంశాన్ని లోతుగా మరియు సులభంగా వివరించడానికి మేము ఐదు ఉదాహరణలను ఉపయోగించాము. మేము 'if' లేదా 'else', 'distutils' మాడ్యూల్ యొక్క షరతులతో కూడిన ప్రకటనలు మరియు 'distutil' మాడ్యూల్‌తో పాటు షరతులతో కూడిన స్టేట్‌మెంట్ వినియోగాన్ని ఉపయోగించడం ద్వారా ఆర్గ్యుమెంట్ పార్స్ గురించి చర్చించాము. ఈ పద్ధతుల ద్వారా, మేము 'ఒప్పు' లేదా 'తప్పు' అనే బూలియన్ ఫ్లాగ్ కాన్సెప్ట్‌తో పాటు ఆర్గ్యుమెంట్‌ను ఆమోదించాము. వాదనను అన్వయించిన తర్వాత, ఇది మా ప్రతినిధి డేటా ప్రకారం దాని వెర్బోస్‌ను సూచిస్తుంది.