Hvordan analysere argumenter på kommandolinje i Python

Kommandolinjeargumentene brukes til å formidle data i programmet på tidspunktet for utførelsen av programmet. Denne funksjonen er tilgjengelig på de fleste populære programmeringsspråk. Men behandlingen av kommandolinjeargumenter er forskjellig for forskjellige språk. Argumentverdiene er gitt med programnavnet på tidspunktet for å kjøre programmet. Python -språk støtter denne funksjonen. Hvordan kommandolinjeargumenter er analysert i Python-skriptet vises i denne artikkelen.

Analysere kommandolinjeargument ved bruk av sys modul

Kommandolinjeargumenter lagres i en liste ved hjelp av sys modul. sys.Argv brukes til å lese verdiene til kommandolinjeargumentene. Det totale antallet kommandolinjeargumenter kan telles ved å bruke Len () funksjon. Bruken av denne modulen er beskrevet i den delen av artikkelen.

Eksempel 1: Lesing av antall argumenter og argumentverdier

Lag en fil med følgende Python -skript. Her lagres kommandolinjeargumentverdiene i variabelen, Argv som andre språk. Len () Metoden teller det totale antall argumenter som ble bestått på tidspunktet for utførelsen av skriptet. Argumentverdier skrives ut som en matrise på slutten av skriptet.

# Importer SYS -modul
Importer Sys
# Skriv ut totalt antall argumenter
trykk ('Total argumenter:', len (SYS.argv))
trykk ('Argumentverdiene er:', STR (SYS.argv))

Produksjon:

Ovennevnte skript blir utført her ved hjelp av fire kommandolinjeargumenter. Det første argumentet er skriptnavnet og andre er numeriske verdier. Følgende utgang vises etter å ha kjørt skriptet.

Eksempel 2: Lese argumentverdier ved hjelp av loopen

I forrige eksempel er argumentverdier skrevet ut som en matrise. Lag en fil med følgende skript for å skrive ut typen argumentvariabel og skrive ut hver argumentverdi i hver linje ved å bruke for loop.

# Importer SYS -modul
Importer Sys
# Skriv ut typen av variabelen, SYS.Argv
Print (Type (SYS.argv))
# Skriv ut hvert kommandolinje-argument i hver linje
trykk ('Kommandolinje -argumentene er:')
for jeg i sys.Argv:
trykk (i)

Produksjon:

Ovennevnte skript blir utført ved å gi tre argumenter med skriptnavnet. Følgende utgang vises etter å ha kjørt skriptet.

Parsing kommandolinje argument ved hjelp av getopt-modul

Getopt Modul brukes til å analysere kommandolinjeargumenter med alternativene. getopt () Metode for denne modulen brukes til å lese argumentene. Denne metoden har tre argumenter. De to første argumentene er obligatoriske og det siste argumentet er valgfritt. Bruken av disse argumentene er gitt nedenfor.

args: Den inneholder argumentet hentet fra kommandolinjeargumentet.

short_option: Det kan være ethvert brev som går med argumentet.

long_option: Det brukes til å definere lange alternativer med to deler. Dette er alternativnavnet og alternativverdien.

Syntaks: getopt.getopt (args, short_option, [long_option])

Eksempel 3: Lese argumentverdier ved hjelp av korte getopt -alternativer

getopt modulen inneholder flere funksjoner enn sys modul. Følgende eksempel viser hvordan korte alternativer kan brukes i getopt () metode. Argv Variabel vil lagre kommandolinje-argumentene ved å utelate skriptnavnet. Deretter er to alternativer definert i getopt () metode som kan brukes med argumentet på kjøretid. Hvis det oppstår noen feil, vises en feilmelding.

# Importer getopt -modul
Importer getopt
# Importer SYS -modul
Importer Sys
# Store argumentvariabel utelater skriptnavnet
argv = sys.Argv [1:]
prøve:
# Definere getopt korte alternativer
alternativer, args = getopt.getopt (argv, 'x: y:')
# Skriv ut alternativene og argumentet
trykk (alternativer)
trykk (args)
Bortsett fra GetOpt.Getopterror:
# Skriv ut feilmeldingen hvis feil alternativ er gitt
utskrift ('feil alternativ er gitt')
# Avslutte skriptet
sys.Avslutt (2)

Produksjon:

Kjør skriptet uten noe argument, argumenter med riktige alternativer og argumenter med feil alternativ.

Eksempel 4: Lese argumentverdier ved bruk av korte og lange getopt -alternativer

Dette eksemplet viser hvordan både korte og lange alternativer kan brukes med argumentverdiene. Det vil legge til to tall når '-en' eller '-Legg til' vil bli brukt som alternativ og trekke fra to tall når '-s ' eller '-under' vil bli brukt som alternativ ved kjøretid.

# Importer getopt -modul
Importer getopt
# Importer SYS -modul
Importer Sys
# Store argumentvariabel utelater skriptnavnet
argv = sys.Argv [1:]
# Initialiser resultatvariabel
Resultat = 0
prøve:
# Definere getopt korte og lange alternativer
alternativer, args = getopt.GetOpt (Sys.argv [1:], 'a: s', ['add =', 'sub ='])
# Les hvert alternativ som bruker for loop
For opt, arg i alternativer:
# Beregn summen hvis alternativet er -A eller -Legg til
Hvis du velger ('-a', '-Legg til'):
Resultat = int (argv [1]) + int (argv [2])
# Beregn suntraksjonen hvis alternativet er -S eller -Sub
elif opt inn ('-s', '--sub'):
Resultat = int (argv [1]) - int (argv [2])
print ('resultat =', resultat)
Bortsett fra GetOpt.Getopterror:
# Skriv ut feilmeldingen hvis feil alternativ er gitt
utskrift ('feil alternativ er gitt')
# Avslutte skriptet
sys.Avslutt (2)

Produksjon:

Kjør skriptet uten noen argumenter og alternativer, argumenter med '-a' -alternativet, argumenter med '-s' alternativ og argumenter med feil alternativ.

Parsing kommandolinje argument ved hjelp av argparse-modul

ArgParse-modulen inneholder mange alternativer for å lese kommandolinjeargumenter. Standard argumentverdier, argumentet med datatypen, posisjonsargumenter, hjelpemelding osv. kan leveres av denne modulen.

Eksempel 5: Lesing av kommandolinjeargumenter ved bruk av Argparse

Følgende eksempel viser bruken av Argparse Modul for å lese kommandolinjeargument. Her er to alternativer definert for å lese kommandolinjeargumenter. Disse er '-n' eller '-navn' og '-e' eller '--e-post'. Hvis brukeren gir noe feil argument, vil det vise en feil med en bruksmelding. Hvis brukeren gir riktige alternativer med argumentene, vil den vise argumentverdiene. Hvis brukeren kjører skriptet med '-hjelp' -alternativet, vil det gi nødvendig melding for å kjøre skriptet.

# Importer ArgParse -modulen
Importer Argparse
# Importer SYS -modul
Importer Sys
# Erklære funksjon for å definere kommandolinjeargumenter
def readoptions (args = sys.Argv [1:]):
Parser = Argparse.ArgumentParser (beskrivelse = "Parsing -kommandoene.")
analyser.add_argument ("-n", "-name", hjelp = "skriv navnet ditt.")
analyser.add_argument ("-e", "-e-post", hjelp = "Skriv inn e-posten din.")
OPTS = Parser.parse_args (args)
Returner velger
# Ring funksjonen for å lese argumentverdiene
Alternativer = ReadOptions (SYS.Argv [1:])
Skriv ut (alternativer.Navn)
Skriv ut (alternativer.e -post)

Produksjon:

Kjør skriptet med feil alternativ, riktig alternativ og hjelpemål.

Konklusjon:

Ulike måter å lese kommandolinjeargumenter blir forklart i denne opplæringen ved å bruke tre Python-moduler. Jeg håper, denne opplæringen vil hjelpe koderen som vil lese data ved hjelp av kommandolinjeargumenter i Python.

Se forfatterens video: Her