Paggamit ng argument ng linya ng command-line gamit ang sys modyul
Ang mga argumento sa command-line ay nakaimbak sa isang listahan gamit ang sys modyul sys.argv ay ginagamit upang basahin ang mga halaga ng mga argumento ng command-line. Ang kabuuang bilang ng mga argumento sa linya ng utos ay maaaring mabibilang sa pamamagitan ng paggamit len () pagpapaandar Ang paggamit ng modyul na ito ay inilarawan sa bahagi ng artikulo.
Halimbawa 1: Pagbasa ng bilang ng mga argumento at halaga ng argument
Lumikha ng isang file gamit ang sumusunod na python script. Dito, ang mga halaga ng argument ng linya ng utos ay nakaimbak sa variable, argv kagaya ng ibang mga wika. len () binibilang ng pamamaraan ang kabuuang bilang ng mga argumentong naipasa sa oras ng pagpapatupad ng script. Ang mga halaga ng argumento ay naka-print bilang isang array sa dulo ng script.
# Mag-import ng module ng sys
angkat sys
# I-print ang kabuuang bilang ng mga argumento
mag-print('Kabuuang mga argumento:', len(sys.argv))
mag-print('Ang mga halaga ng argumento ay:', p(sys.argv))
Output:
Ang script sa itaas ay naisakatuparan dito gamit ang apat na mga argumento sa linya ng utos. Ang unang argumento ay ang pangalan ng script at ang iba pa ay mga halagang bilang. Lilitaw ang sumusunod na output pagkatapos patakbuhin ang script.
Halimbawa 2: Pagbasa ng mga halagang argumento gamit ang loop
Sa nakaraang halimbawa, ang mga halaga ng argument ay nai-print bilang isang array. Lumikha ng isang file na may sumusunod na script upang mai-print ang uri ng variable ng argumento at mai-print ang bawat halaga ng argument sa bawat linya sa pamamagitan ng paggamit para sa loop.
# Mag-import ng module ng sysangkat sys
# I-print ang uri ng variable, sys.argv
mag-print(uri(sys.argv))
# I-print ang bawat argumento ng linya ng utos sa bawat linya
mag-print('Ang mga argumento ng linya ng utos ay:')
para saakosa sys.argv:
mag-print(ako)
Output:
Ang script sa itaas ay naisakatuparan sa pamamagitan ng pagbibigay ng tatlong mga argumento na may pangalan ng script. Lilitaw ang sumusunod na output pagkatapos patakbuhin ang script.
Pag-parse ng argument ng command-line gamit ang module ng getopt
Napunta sa tuktok ginamit ang module upang ma-parse ang mga argumento ng command-line na may mga pagpipilian. topped () ang pamamaraan ng modyul na ito ay ginagamit sa pagbasa ng mga argumento. Ang pamamaraang ito ay may tatlong mga argumento. Ang unang dalawang argumento ay sapilitan at ang huling argumento ay opsyonal. Ang mga gamit ng mga argumentong ito ay ibinibigay sa ibaba.
args: Naglalaman ito ng argument na kinuha mula sa argument ng command-line.
short_option: Maaari itong maging anumang liham na pumasa sa argumento.
long_option: Ginagamit ito upang tukuyin ang mga mahahabang pagpipilian na may dalawang bahagi. Ito ang pangalan ng pagpipilian at halaga ng pagpipilian.
Syntax: getopt.getopt (args, short_option, [long_option])
Halimbawa 3: Pagbasa ng mga halagang argumento gamit ang mga maikling pagpipilian ng getopt
nangunguna naglalaman ang module ng higit pang mga tampok kaysa sa sys modyul Ipinapakita ng sumusunod na halimbawa kung paano magagamit ang mga maiikling pagpipilian topped () pamamaraan argv iimbak ng variable ang mga argumento sa linya ng utos sa pamamagitan ng pag-alis ng pangalan ng script. Susunod, ang dalawang mga pagpipilian ay tinukoy sa topped () pamamaraan na maaaring magamit sa argument sa run-time. Kung may anumang error na nangyayari pagkatapos ay isang mensahe ng error ang ipapakita.
# Mag-import ng module ng getoptangkat nangunguna
# Mag-import ng module ng sys
angkat sys
# Variable ng argument sa store na tinatanggal ang pangalan ng script
argv= sys.argv[1:]
subukan mo:
# Tukuyin ang mga maikling pagpipilian ng getopt
mga pagpipilian,mga pagtatalo= nangunguna.nangunguna(argv, 'x: y:')
# i-print ang mga pagpipilian at argumento
mag-print(mga pagpipilian)
mag-print(mga pagtatalo)
maliban sa nangunguna.GetoptError:
# I-print ang mensahe ng error kung ang maling pagpipilian ay ibinigay
mag-print('Ang maling pagpipilian ay ibinigay')
# Tapusin ang script
sys.labasan(2)
Output:
Patakbuhin ang script nang walang anumang pagtatalo, mga argumento na may wastong mga pagpipilian at argument na may maling pagpipilian.
Halimbawa 4: Pagbasa ng mga halagang argumento gamit ang maikli at mahabang mga pagpipilian ng getopt
Ipinapakita ng halimbawang ito kung paano maaaring magamit ang parehong maikli at mahabang mga pagpipilian sa mga halaga ng argument. Magdaragdag ito ng dalawang numero kung kailan '-to' o ‘–Add’ gagamitin bilang pagpipilian at ibawas ang dalawang numero kapag ‘ -s ' o ‘ –Sub ’ ay gagamitin bilang isang pagpipilian sa run-time.
# Mag-import ng module ng getoptangkat nangunguna
# Mag-import ng module ng sys
angkat sys
# Variable ng argument sa store na tinatanggal ang pangalan ng script
argv= sys.argv[1:]
# Pinasimulan ang variable ng resulta
resulta=0
subukan mo:
# Tukuyin ang getopt maikli at mahabang mga pagpipilian
mga pagpipilian,mga pagtatalo= nangunguna.nangunguna(sys.argv[1:], 'a: s', ['add =','sub ='])
# Basahin ang bawat pagpipilian gamit ang para sa loop
para sasumali,galitsamga pagpipilian:
# Kalkulahin ang kabuuan kung ang pagpipilian ay isang o - magdagdag
kungsumalisa ('-to', '--add'):
resulta= int(argv[1])+int(argv[2])
# Kalkulahin ang suntraction kung ang pagpipilian ay -s o --sub
elifsumalisa ('-s', '--sub'):
resulta= int(argv[1])-int(argv[2])
mag-print('Resulta =',resulta)
maliban sa nangunguna.GetoptError:
# I-print ang mensahe ng error kung ang maling pagpipilian ay ibinigay
mag-print('Ang maling pagpipilian ay ibinigay')
# Tapusin ang script
sys.labasan(2)
Output:
Patakbuhin ang script nang walang anumang mga argumento at pagpipilian, mga argument na may pagpipiliang '-a', mga argument na may opsyong '-s' at mga argument na may maling pagpipilian.
Pag-parse ng command-line argument gamit ang argparse module
Naglalaman ang module ng Argparse ng maraming mga pagpipilian upang mabasa ang mga argument ng linya ng utos. Ang mga default na halaga ng argument, ang argument na may uri ng data, mga posisyonal na argumento, mensahe ng tulong, atbp ay maaaring ibigay ng modyul na ito.
Halimbawa 5: Pagbasa ng mga argumento sa linya ng utos gamit ang argparse
Ipinapakita ng sumusunod na halimbawa ang paggamit ng makipagtalo module para sa pagbabasa ng argumento ng command-line. Dito, tinukoy ang dalawang pagpipilian para sa pagbabasa ng mga argumento ng command-line. Ito ay '-N' o '–name' at ‘-E’ o ‘–email’. Kung ang gumagamit ay nagbibigay ng anumang maling argumento pagkatapos ay magpapakita ito ng isang error sa isang mensahe sa paggamit. Kung ang gumagamit ay nagbibigay ng tamang mga pagpipilian sa mga argumento pagkatapos ay ipapakita nito ang mga halaga ng argument. kung pinapatakbo ng gumagamit ang script na may pagpipiliang '–tulong' pagkatapos ay magbibigay ito ng kinakailangang mensahe upang patakbuhin ang script.
# Mag-import ng module ng argparseangkatmakipagtalo
# Mag-import ng module ng sys
angkat sys
# Ideklara ang pagpapaandar upang tukuyin ang mga argumento ng linya ng utos
defbasahin ang Mga Pagpipilian(mga pagtatalo=sys.argv[1:]):
parser =makipagtaloArgumentParser(paglalarawan='Ang mga listahan ng mga utos ng pag-parse.')
parser.add_argument('-n', '--pangalan', tulungan='I-type ang iyong pangalan.')
parser.add_argument('-At', '--email', tulungan='I-type ang iyong email.')
pinipili= parser.parse_args(mga pagtatalo)
bumalik kapinipili
# Tumawag sa pagpapaandar upang mabasa ang mga halaga ng argument
mga pagpipilian=basahin ang Mga Pagpipilian(sys.argv[1:])
mag-print(mga pagpipilianpangalan)
mag-print(mga pagpipilianemail)
Output:
Patakbuhin ang script na may maling pagpipilian, tamang pagpipilian at opsyon sa tulong.
Konklusyon:
Ang iba't ibang mga paraan ng pagbabasa ng mga argumento ng command-line ay ipinaliwanag sa tutorial na ito sa pamamagitan ng paggamit ng tatlong mga module ng sawa. Inaasahan kong, makakatulong ang tutorial na ito sa coder na nais na basahin ang data gamit ang mga argumento ng linya ng utos sa sawa.
Panoorin ang Video ng May-akda: dito