Hvordan legge til kommandolinjeargumenter til et Python-skript?

Hvis du har utviklet et Python-skript eller et program som primært skal kjøres i terminalemulatorene eller til og med GUI-apper, kan du legge til kommandolinjeargumenter for å forbedre dets brukbarhet, kodelesbarhet, applikasjonsstruktur og den generelle brukervennligheten til applikasjonen for sluttbrukerne. Disse kommandolinjeargumentene kalles også "alternativer" eller "brytere" og fungerer på samme måte som argumenter du vanligvis ser i bash-skript og andre C / C ++ -baserte programmer.

For å legge til argumenter i Python-skript, må du bruke en innebygd modul som heter “Argparse”. Som navnet antyder, analyserer den kommandolinjeargumenter som brukes mens du starter et Python-skript eller -program. Disse analyserte argumentene blir også sjekket av "argparse" -modulen for å sikre at de er av riktig "type". Feil heves hvis det er ugyldige verdier i argumenter.

Bruk av den argparse modulen kan best forstås gjennom eksempler. Nedenfor er noen kodeeksempler som kommer i gang med argparse-modulen.

Eksempel 1: Generer hjelpeargument og melding

Vurder koden eksemplet nedenfor:

importer argparse
parser = argparse.ArgumentParser (beskrivelse = 'Et testprogram.')
args = parser.parse_args ()

Den første uttalelsen importerer "argparse" -modulen. Deretter opprettes en ny forekomst av "ArgumentParser" -objektet, og en kort beskrivelse av programmet leveres som argument. ArgumentParser-objektet er nødvendig for å konvertere kommandolinjeargumentverdier til datatyper forstått av Python. Dette gjøres ved hjelp av "parse_args" -metoden til ArgumentParser-objektet, som vist i forrige uttalelse.

Forutsatt at du har lagret eksempelkoden som er angitt ovenfor i en fil med navnet “test.py ”, ved å kjøre kommandoene nedenfor, kan du hjelpe meldinger relatert til programmet.

$ ./test.py -h
$ ./test.py - hjelp

Du bør få noe som ligner på dette:

bruk: test.py [-h]
Et valgfritt argument for et testprogram:
-h, --hjelp viser denne hjelpemeldingen og avslutter

Merk at ingen logikk for å håndtere analyserte argumenter og konvertere dem til objekter er lagt til kodeeksemplet nevnt ovenfor. Hjelpemeldinger for individuelle argumenter vises derfor ikke i utdataene. Når du har lagt til logikk for å håndtere verdier for analyserte argumenter i programmet, vil hjelpemeldinger begynne å vise beskrivelser for individuelle argumenter.

Eksempel 2: Håndter et strengargument

For å legge til argumenter som er akseptable med Python-skriptet, må du bruke metoden "add_argument". Ta en titt på følgende kode:

importer argparse
parser = argparse.ArgumentParser (beskrivelse = 'Et testprogram.')
parser.add_argument ("print_string", help = "Skriver ut det medfølgende argumentet.")
args = parser.parse_args ()
skriv ut (arg.utskriftsstreng)

En ny uttalelse er lagt til som viser bruken av “add_argument” -metoden. Ethvert argument som legges til når du starter skriptet, blir behandlet som et "print_string" -objekt av "ArgumentParser".

Merk at "add_argument" -metoden som standard behandler verdier hentet fra argumenter som strenger, slik at du ikke trenger å spesifisere "typen" i dette tilfellet. En standardverdi på "Ingen" er også tildelt tilførte argumenter, med mindre den overstyres.

Nok en gang, ta en titt på hjelpemeldingen:

bruk: test.py [-h] [print_string]
Et testprogram posisjonsargumenter:
print_string skriver ut det medfølgende argumentet
valgfrie argumenter:
-h, --hjelp viser denne hjelpemeldingen og avslutter

En av linjene i utdata sier "posisjonsargumenter". Siden det ikke er definert noe nøkkelord for argument, blir argumentet for tiden behandlet som et "posisjonsargument" der rekkefølgen og plasseringen av det medfølgende argumentet har en direkte effekt på programmet. Posisjonsargumenter er også obligatoriske med mindre du manuelt endrer oppførselen.

For å definere og analysere valgfrie argumenter, kan du bruke “-” (dobbel bindestrek) og endre standardverdiene ved hjelp av “standard” -argumentet.

importer argparse
parser = argparse.ArgumentParser (beskrivelse = 'Et testprogram.')
parser.add_argument ("- print_string", help = "Skriver ut det medfølgende argumentet.", standard =” En tilfeldig streng.”)
args = parser.parse_args ()
skriv ut (arg.utskriftsstreng)

Nå når du kjører “testen.py ”-skript uten noe argument, bør du få“ En tilfeldig streng.”Som utgang. Du kan også velge søkeordet "-print_string" for å skrive ut en streng du ønsker.

$ ./test.py --print_string LinuxHint.com
LinuxHint.com

Merk at du kan gjøre et valgfritt argument obligatorisk ved å bruke et ekstra "required = True" -argument.

Til slutt kan du også definere stenografiske versjoner av argumentet ved å bruke “-” (ett eneste bindestrek) for å redusere detaljnivået.

importer argparse
parser = argparse.ArgumentParser (beskrivelse = 'Et testprogram.')
parser.add_argument (“- p”, "--print_string", help = "Skriver ut det medfølgende argumentet.", standard =” En tilfeldig streng.”)
args = parser.parse_args ()
skriv ut (arg.utskriftsstreng)

Å kjøre følgende kommando skal gi deg samme resultat som ovenfor:

$ ./test.py -p LinuxHint.com

Eksempel 3: Håndter et heltallargument

For å håndtere argumenter som trenger heltallverdier, må du sette "type" nøkkelordet til "int" for å tillate validering og kaste feil i tilfelle betingelsen ikke er oppfylt.

importer argparse
parser = argparse.ArgumentParser (beskrivelse = 'Et testprogram.')
parser.add_argument ("- p", "--print_string", help = "Skriver ut det medfølgende argumentet.", type = int)
args = parser.parse_args ()
skriv ut (arg.utskriftsstreng)

Prøv å kjøre følgende kommando:

$ ./test.py -p LinuxHint.com

Du bør få en feil som dette:

bruk: test.py [-h] [-p PRINT_STRING]
test.py: feil: argument -p / - print_string: ugyldig int-verdi: 'LinuxHint.com '

Å oppgi et heltall gir deg riktig resultat:

$ ./test.py -p 1000 1000

Eksempel 4: Håndter sanne og falske veksler

Du kan sende argumenter uten noen verdier for å behandle dem som sant og falskt flagg ved hjelp av "handling" -argumentet.

importer argparse
parser = argparse.ArgumentParser (beskrivelse = 'Et testprogram.')
parser.add_argument ("- p", "--print_string", help = "Skriver ut det medfølgende argumentet.", action =" store_sannhet ")
args = parser.parse_args ()
skriv ut (arg.utskriftsstreng)

Kjør kommandoen nedenfor for å få en enkel "True" som utdata:

$ ./test.py -p

Hvis du kjører skriptet uten "-p" -argumentet, tildeles en "Falsk" -verdi i stedet. Verdien “store_true” av nøkkelordet “action” tilordner en “True” -verdi til “print_string” -variabelen når “-p” -argumentet er eksplisitt spesifisert, ellers blir False tildelt variabelen.

Eksempel 5: Behandle argumentverdier som en liste

Hvis du ønsker å få flere verdier samtidig og lagre dem i listen, må du oppgi "nargs" nøkkelord i følgende format:

importer argparse
parser = argparse.ArgumentParser (beskrivelse = 'Et testprogram.')
parser.add_argument ("- p", "--print_string", help = "Skriver ut det medfølgende argumentet.", nargs = '*')
args = parser.parse_args ()
skriv ut (arg.utskriftsstreng)

Kjør følgende kommando for å teste koden ovenfor:

$ ./test.py -p “a” “b”

Du bør få litt produksjon som dette:

['a', 'b']

Konklusjon

"Argparse" -modulen er ganske omfattende med mange muligheter for å justere oppførselen til kommandolinjeprogrammer og analysere verdiene som leveres av brukeren. Disse eksemplene berører bare den grunnleggende bruken av "argparse" -modulen. For avanserte og komplekse applikasjoner kan det hende du trenger forskjellige implementeringer. Gå til den offisielle dokumentasjonen for å få en fullstendig forklaring på modulen.