Python Command Line Parsing Tutorial

Parsingen for kommandolinjeargumenter ble tidligere inkludert i standard Python -biblioteket "Argparse". Ved å gjøre det mulig for brukerinngangsverdier på en eller annen måte kan analyseres og deretter brukes, "Argparse". Det gir fleksibilitet og gjenbruker koden din i stedet for manuelt innstilling av variabler som en del av koden.

Eksempel 1

Vi vil implementere den påfølgende koden for å vise strukturen og bruken av et Argparse -bibliotek.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyser.add_argument ('-navn', type = str, påkrevd = true)
Args = Parser.parse_args ()
trykk ('Hei,', args.Navn)

"Argparse" -biblioteket vil bli importert ved start av koden. Parseren initialiseres av ArgumentParser (), så vi kan begynne å legge til tilpassede parametere. Bruk analyser.add_argument () funksjon for å legge til ønskede argumenter. "Navnet", "Type" og "påkrevd" vil bli gitt som argumenter for denne metoden. Den "nødvendige" attributtet er et boolsk som indikerer om følgende kommandolinjefelt utføres, og "Type" -argumentet viser den variable typen som er spesifisert som en inngang. Vi setter verdien av "Type" -argumentet som "STR" og "påkrevd" som "sann". Funksjonen Parse_Args () vil bli kalt. “Args.Navn ”-attributt ser ut til å være navnet på et slikt argument identifisert med Add_Argument () -funksjonen.

Den forrige koden produserer denne typen resultat som vist:

Som vi kan se, vil dette øke en feil siden "navn" -argumentet er nødvendig, men mangler. Når vi legger til -navn, får vi følgende utdata:

Eksempel 2

Det er visse situasjoner når vi ikke vil krangle om navnet som kan brukes til flagget. Man kan bruke en posisjonsparameter for å unngå å måtte levere -navnsflagget før du legger inn den faktiske verdien.

Her vil vi multiplisere posisjonsargumentene ved å spesifisere parametrene.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyser.add_argument ('-i', type = int, påkrevd = true)
analyser.add_argument ('-j', type = int, nødvendig = true)
Args = Parser.parse_args ()
Produkt = args.jeg * args.j
trykk ('Produkt:', produkt)

Parseren ble først generert etter import av "Argparse" -modulen. Variablene “I” og “J”, to argumenter av heltallstype som må være sanne, ble deretter lagt til. Etter det vil produktformler bli brukt etter analysering av parametrene. Vi bruker utskriftsfunksjonen () for å vise produktet.

Eksempel 3

I dette tilfellet gjør vi multiplikasjon uten å spesifisere posisjonsparametrene.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyser.add_argument ('k', type = int)
analyser.add_argument ('l', type = int)
Args = Parser.parse_args ()
Produkt = args.k * args.l
trykk ('Produkt:', produkt)

For det første, integrering av "Argparse" -pakken, ble analyseren opprinnelig konstruert ved hjelp av ArgumentParser () -metoden. “K” og “L” er de to argumentene som er spesifisert med heltallstypen. Selv om posisjonsargumenter holder en kommandolinje klarere, gir vi ikke den "nødvendige" attributtet her. Etterpå ble de gitte parametrene analysert ved hjelp av metoden Parse_Args (). Vi vil definere en produktfunksjon ved å bruke variablene “K” og “L”. For å vise utfallet, vil vi bruke utskriftserklæringen.

Eksempel 4

Valgfrie argumenter kan være nyttige når vi ønsker å gi en bruker et valg om å bruke funksjonalitet. Vi spesifiserer ganske enkelt den valgfrie parameteren ved å bruke Add_Argument () -funksjonen for å legge til et valgfritt argument.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyser.add_argument ('-navn', type = str, påkrevd = true)
analyser.add_argument ('-klasse', type = int)
Args = Parser.parse_args ()
Hvis args.Klasse:
Trykk (Args.Navn, 'in', args.Klasse, 'klasse.')
ellers:
trykk ('Hei,', args.Navn + '!')

Vi starter programmet ved å innlemme "Argparse" -biblioteket. Vi etablerte først en analyser ved å bruke ArgumentParser () -metoden for å utføre to analyserargumenter. Nå vil vi ringe add_argument () -funksjon for å legge til forskjellige parametere. Disse argumentene inkluderer to variabler, navn og klasse, der "navn" -argumentet er av typen "streng", og det må være sant. "Klassen" -parameteren har typen "heltall".

Etter å ha analysert parametrene, bruker vi dessuten "IF-Else" -tilstanden. Inne i dette har vi brukt print () -funksjonen to ganger, en gang av "if" -uttalelsen og igjen av "ellers" -uttalelsen, for å representere utgangen. Argumentene på trykk () metoder varierer i begge disse tilfellene. Argumentene gitt i den første utskriften () -funksjonen inkluderer navn og klasse. Samtidig inkluderer argumentene presentert i den andre trykket () -metoden Args.Navn.

Etter å ha kjørt koden, får vi de to utgangene som gitt nedenfor. Vi får den første utgangen etter å ha brukt valgfrie argumenter og den andre uten valgfrie argumenter.

Fra de to foregående forskjellige utgangene kan vi observere at det er en forskjell mellom begge utgangene på grunn av å bruke de valgfrie argumentene i det ene og ikke i det andre.

Eksempel 5

La oss forestille oss at i stedet for å be brukeren gi "X" og "Y" -inngang. Siden vi ikke kan forutsi hvor mange verdier en bruker vil angi, er det ikke nødvendig å bygge et nytt argument for hver ny verdi. Antallet (eller inngangene) Argumentet kan godta kan spesifiseres ved hjelp av "NARGS" -alternativet i Add_Argument () -funksjonen.

Vi vil gi flere inngangsargumenter og skrive ut resultatet i denne saken.

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyser.add_argument ('-verdier', type = int, nargs = 5)
Args = Parser.parse_args ()
sum = sum (args.verdier)
trykk ('Sum:', sum)

Vi starter ved å importere "Argparse" -biblioteket, som er nødvendig for å utføre forrige kode. Vi vil opprette en analyser ved å ringe ArgumentParser () -metoden. Denne funksjonen inneholder ingen argumenter. Deretter vil Add_Argument () -metoden bli påkalt. Denne metoden har tre parametere. Når det gjelder flere inngangsargumenter, har vi brukt "NARGS" -attributtet i Add_Argument () -metoden. Nå vil vi kalle Parse_Args () -funksjonen for parsing. Vi bruker sum () -metoden for å finne summen av verdiene. For å skildre utdataene, benyttet vi utskriftserklæringen.

Eksempel 6

Hva om vi vil ha summen av flere innganger enn fem verdier? Vi kan få argumentet til å akseptere et hvilket som helst antall verdier ved å sette NARGS = "+".

Importer Argparse
Parser = Argparse.ArgumentParser ()
analyser.add_argument ('-verdier', type = int, nargs = '+')
Args = Parser.parse_args ()
sum = sum (args.verdier)
trykk ('Sum:', sum)

Vi kan utføre skriptet med omtrent et hvilket som helst antall inngangsverdier. Her bruker vi den samme koden som tidligere, men i denne koden vil vi endre 'NARGS' = 5 til 'NARGS' = '+'.

Konklusjon

Denne artikkelen dekket en rekke Python-kommandolinje-analyseteknikker, for eksempel enkle argumenter, posisjonsargumenter, valgfrie argumenter og flere inngangsargumenter. Det ga også eksempler for å se hvordan utgangen endres avhengig av om et argument brukes eller ikke. Vi kan bruke eksempler for å undersøke og forstå om et argument er passende i en viss omstendighet.