Ang Flag ay isang Boolean variable na nag-aalerto sa mga programmer kapag naganap ang isang partikular na pangyayari. Kung ang isang Boolean flag ay kumakatawan sa totoo, ito ay nagpapahiwatig na may ilang kundisyon. Kapag ang isang Boolean flag ay kumakatawan sa false, ito ay nagpapahiwatig na ang isang tiyak na kundisyon ay hindi totoo. Upang matukoy kung ang predicate parse ay 'True' o 'False,' ang 'argparse' Boolean flag ay nag-parse ng mga argumento na pumasa. Ang isang karaniwang pakete ng Python na tinatawag na 'argparse' ay maaaring gamitin upang bigyang-kahulugan ang mga argumento ng command-line. Mas mahusay nitong kinokontrol ang aktibidad at simpleng i-code. Ang mensahe ng gabay at paggamit ay nabuo para sa user kapag nagbigay kami ng ilang maling argumento. Bukod pa rito, ipinapakita nito ang mga error sa isyu ng user. Ang 'argparse' module ay simpleng gamitin. Ang default na value ng store true na opsyon ay False, samantalang ang default na value ng store false ay True. Upang magamit ang module na 'argparse', dapat tayong sumunod sa tatlong pangunahing hakbang: pagbuo muna ng parser, pagbibigay ng parser ng higit pang mga argumento, at ang pag-parse ng mga parameter.
Syntax:
Ang syntax na kinakailangan para sa Python 'argparse' Boolean flag ay ibinibigay sa sumusunod:
Kailangan muna ng syntax na lumikha ng isang function na nag-iimbak ng mga variable at library kung saan ipinapasa ang argumento, at ang kundisyon ay itinakda ayon sa kinakailangan. Dalawang Boolean verbose ang naka-check para sa “True” o “False” para sa aming mga kundisyon.
Halimbawa 1: Paggamit ng Tranquil Extent ng Python 'Argparse' Boolean Flag
Ang simpleng Boolean flag ay nag-parse lang ng mga argumento na maaaring isa o maramihang argumento na tumitingin sa senaryo ng argumento, kung ang naipasa na kundisyon ay 'true' o 'false'.
Ngayon, talakayin natin ang ating code snippet mula rito.
Sa simula ng aming code, ini-import namin ang library ng 'argparse' na tumatalakay sa pag-parse ng mga argumento ng Python. Pagkatapos, gagawin namin ang aming function na 'argparse_Boolean' na tinukoy ng user, at kung saan ito ilalaan sa library. Pagkatapos, ipinapasa namin ang aming unang argumento sa aming function na 'argparse_Boolean' na 'mga kotse' gamit ang function na 'add_argument()'. Ang ikalawang argumentong naipasa ay nagtalaga lamang ng isang 'verbose' kung saan ang aksyon na gagawin na ibinigay namin sa kanila ay nag-iimbak ng 'totoo' na verbose. Ngayon, gumawa kami ng bagong function ng 'Boolean_flag' na ginagamit upang tawagan ang paunang natukoy na library para sa pag-parse ng mga argumento. Panghuli, ginagamit namin ang function na 'print()' para sa parehong mga argumento na 'mga kotse' at 'verbose'.
Mula sa nakaraang snippet ng code, nakuha namin ang output na ito kung saan hindi ito nakakatanggap ng anumang argumento, kaya ipinapakita nito ang 'wala'. Ang pangalawang argumento ay hindi nahahanap o hindi tumutugma, kaya nagbibigay ito ng 'Maling' verbose.
Halimbawa 2: Paggamit ng Argument Parsing na Induced ng Python bilang Boolean Values
Ang halimbawang ito ay kahit papaano ay katulad ng naunang halimbawa. Dito, tatalakayin natin ang mga pagkilos ng Boolean values para sa mga argumentong tinukoy ng user. Kung gusto naming piliin ang mga argumento para sa Boolean verbose action, maaari naming gamitin ang paraang ito.
Sa halimbawa ng code na ito, ang library ay nananatiling parehong 'argparse' na ginamit sa nauna. Ang ginawang function ay pinangalanang 'Boolean_parser'. Ang mga argumentong ibinibigay namin ay dalawang variable – “First_Variable” at “Second_Variable” – kung saan ang aksyon para sa unang argument ay naka-store bilang “false” at ang pangalawang argument ay naka-store bilang “true”. Panghuli, tinatawag namin ang function na 'Boolean_parser' gamit ang function na 'parser_args()' at iimbak ito sa 'Flag_Argument'. Para sa visualization nito, ginagamit namin ang function na 'print()' at itinalaga ito sa 'Flag_Argument'.
Ito ang output snapshot ng nakaraang halimbawa ng code na nagpapaliwanag sa mga halaga ng Boolean bilang 'True' para sa 'First_Variable' at 'False' para sa 'Second_Variable'.
Halimbawa 3: Paggamit ng 'Argparse' Boolean Flag sa pamamagitan ng Pagpapatakbo ng mga Conditional Statement
Gaya ng ipinahihiwatig ng pangalan, ginagamit ang isang conditional statement sa iyong programa upang pamahalaan ang mga kundisyon. Ang mga kasanayang ito ay ang mga alituntunin ng programa kapag gumagawa ito ng mga paghuhusga bilang tugon sa mga pangyayaring nararanasan nito. Ang mga pangunahing conditional na pahayag sa Python ay 'If', 'if-else', at 'switch' na mga pahayag. Dito, dadaan tayo sa 'if-else' conditional statement.
Ang library ay nananatiling parehong 'argparse' habang tinatalakay natin ang pag-parse ng argumento. Ang function na ginawa namin dito ay pinangalanang 'parser_flag'. Ang unang argumento na aming itinalaga ay 'perform-action' at ang default na value na ibinibigay dito ay 'False' kung saan ang 'action' ay nag-iimbak ng 'true'. Pagkatapos ipasa ang argumento, gumawa kami ng bagong function na pinangalanang 'arguments_flag' at tinatawag ito kasama ng dating function na tinukoy ng user na 'parser_flag' kasama ng mga argumento nito. Dito, inilalapat namin ang aming conditional statement ng 'if-else'. Ang aming 'kung-kondisyon' ay nag-iimbak kung ang argumentong naipasa ay totoo kasunod ng function na “print()” at ang print statement na “Isagawa ang Iyong Pagkilos”. Sa 'ibang kondisyon', kung ang unang argument parse ay hindi 'totoo', gawin ang 'ibang pahayag' ng 'false' sa 'default'. Panghuli, ginagamit namin ang function na “print()” nang dalawang beses para sa mga print statement na nagpapakita ng aksyon sa pamamagitan ng pagsasagawa ng mga argumento.
Tinutukoy ng output snapshot na ang argument na naipasa ay nagpapatakbo ng 'else-statement' na may 'False' verbose kasama ang mga print statement na ibinibigay namin sa code.
Halimbawa 4: Paggamit ng Python 'Argparse' Boolean Flag sa pamamagitan ng Operating ang 'Distutils' Module
Ang isang pag-install ng Python ay maaaring mag-compile at muling mag-install ng mga aklatan sa tulong ng 'distutils' na module. Ang mga bagong module ay maaaring mga outgrowth na nakasulat sa C, plain Python module, o mga koleksyon ng mga tool at feature na naglalaman ng mga module na nakasulat sa Python language.
Pagkatapos i-import ang 'argparse' library, inilalapat namin ang 'distutils.util' module sa pamamagitan ng pag-import ng karagdagang library ng 'strtobool'. Pagkatapos, i-cremate namin ang 'python_argparse r' at i-link ito sa library. Pagkatapos nito, nagdagdag kami ng argumento sa “python_argparse r” ng “Boolean”. Ang uri na ibinigay ay 'lambda' at naka-imbak sa variable na 'b' na itinalaga sa 'strtobool' library. Ang Boolean value dito para sa 'default' na kundisyon ay nakatakda sa 'True' at ang 'const' ay nakatakda sa 'False'. Pagkatapos i-parse, iimbak namin ito sa 'boolean_arguments' pagkatapos itong gawin. Pagkatapos, tinatawag namin ang 'boolean_arguments' sa function na 'print()'.
Habang binabasa ang argumento, ipinapakita ng output ang 'True' habang ipinapatupad ang kundisyon bilang default.
Halimbawa 5: Paggamit ng Python 'Argparse' Boolean Flag sa pamamagitan ng Pagpapatakbo ang 'Distutils' na Module na may mga Conditional Statement
Maaaring patakbuhin ang mga conditional statement kasama ng distutils module para ipatupad ang phenomenon ng argument parsing sa Boolean flag.
Tingnan natin ang code snippet para matuklasan ang paggamit ng conditional statement at distutils module nang sabay-sabay. Para sa layuning ito, ini-import namin ang 'argparse' library at inilapat ang module na 'distutils.util.' Pagkatapos, pareho naming ini-import ang 'strtobool' library na ginamit sa nakaraang halimbawa. Ang function na nilikha namin ay pinangalanang 'bool_parser' upang lumikha ng isang parse para sa mga argumento. Idinaragdag namin ang argumentong 'mabait' at 'uri' na itinakda bilang 'str', 'nargs' bilang '?', 'const' bilang 'False' at 'default' bilang 'True'. Ngayon, gumawa kami ng bagong function ng 'bool_arguments' kung kanino namin itinalaga ang nakaraang function kasama ang argumento nito na aming na-parse. Dito, inilalapat namin ang pahayag ng kundisyon kung saan tinutukoy ng kundisyong 'kung' na kung naroroon ang naipasa na argumento, ipinapakita nito ang 'True' kasama ng mensahe sa pag-print, 'Ang iyong boolean na bandila ay.' Pagkatapos, ipi-print nito ang verbose ng argumentong 'uri' na itinalaga namin sa 'print()'. Kung hindi, ito ay magiging 'false' bilang default bilang Boolean expression.
Sa output snapshot, makikita natin na ang if-statement ay totoo kaya ito ay nagpapakita ng 'True' kasama ng aming print statement.
Konklusyon
Sa aming artikulo, tinakpan namin ang mga pangunahing konsepto ng argument parse sa Boolean flag. Para sa layuning ito, gumamit kami ng limang halimbawa upang maipaliwanag nang malalim at madali ang paksa. Tinalakay namin ang argument parse sa pamamagitan ng paggamit ng mga conditional statement ng 'if' o 'else', 'distutils' module, at conditional statement na paggamit kasama ng 'distutil' module. Sa pamamagitan ng mga paraang ito, ipinasa namin ang argument kasama ang konsepto ng Boolean flag na “True” o “False”. Pagkatapos i-parse ang argumento, kinakatawan nito ang verbose ayon sa aming data ng kinatawan.