Phenquestions
För att lägga till argument i Python-skript måste du använda en inbyggd modul med namnet “Argparse”. Som namnet antyder analyserar den kommandoradsargument som används när du startar ett Python-skript eller -program. Dessa analyserade argument kontrolleras också av modulen "argparse" för att säkerställa att de är av rätt "typ". Fel uppstår om det finns ogiltiga värden i argumenten.
Användningen av argparse-modulen kan förstås bäst genom exempel. Nedan följer några kodprover som kommer att komma igång med argparse-modulen.
Exempel 1: Skapa hjälpargument och meddelande
Överväg kodprovet nedan:
importera argparseparser = argparse.ArgumentParser (beskrivning = 'Ett testprogram.')
args = parser.parse_args ()
Det första uttalandet importerar modulen ”argparse”. Därefter skapas en ny instans av "ArgumentParser" -objektet och en kort beskrivning av programmet tillhandahålls som ett argument. ArgumentParser-objektet behövs för att konvertera argumentvärden för kommandoraden till datatyper som Python förstår. Detta görs med "parse_args" -metoden för ArgumentParser-objektet, som visas i det senaste uttalandet.
Förutsatt att du har sparat exempelkoden som anges ovan i en fil med namnet “test.py ”, när du kör kommandona nedan får du hjälpmeddelanden relaterade till programmet.
$ ./testa.py -h$ ./testa.py --hjälp
Du borde få lite output som liknar detta:
användning: test.py [-h]Ett testprogram valfria argument:
-h, --hjälp visa detta hjälpmeddelande och avsluta
Observera att ingen logik för att hantera analyserade argument och konvertera dem till objekt har lagts till i kodprovet som nämns ovan. Hjälpmeddelanden för enskilda argument visas därför inte i utdata. När du har lagt till logik för att hantera värden för analyserade argument i ditt program kommer hjälpmeddelanden att börja visa beskrivningar för enskilda argument.
Exempel 2: Hantera ett strängargument
För att lägga till argument som godtas av ditt Python-skript måste du använda metoden “add_argument”. Ta en titt på följande kod:
importera argparseparser = argparse.ArgumentParser (beskrivning = 'Ett testprogram.')
parser.add_argument ("print_string", help = "Skriver ut det medföljande argumentet.")
args = parser.parse_args ()
skriva ut (args.trycksträng)
Ett nytt uttalande har lagts till som visar användningen av "add_argument" -metoden. Alla argument som läggs till när man startar skriptet kommer att behandlas som ett "print_string" -objekt av "ArgumentParser".
Observera att "add_argument" -metoden som standard behandlar värden som hämtats från argument som strängar, så du behöver inte uttryckligen ange "typen" i det här fallet. Ett standardvärde "Ingen" tilldelas också tillagda argument, såvida de inte åsidosätts.
Återigen, titta på hjälpmeddelandet:
användning: test.py [-h] [print_string]Ett testprogram positionella argument:
print_string skriver ut det medföljande argumentet
valfria argument:
-h, --hjälp visa detta hjälpmeddelande och avsluta
En av raderna i utdata säger "positionella argument". Eftersom inget nyckelord för argument definieras behandlas för närvarande argumentet som ett ”positionellt argument” där ordningen och positionen för det angivna argumentet har en direkt effekt på programmet. Positionsargument är också obligatoriska om du inte ändrar deras beteenden manuellt.
För att definiera och analysera valfria argument kan du använda “-” (dubbelstreck) och ändra deras standardvärden med hjälp av ”standard” -argumentet.
importera argparseparser = argparse.ArgumentParser (beskrivning = 'Ett testprogram.')
parser.add_argument ("- print_string", help = "Skriver ut det medföljande argumentet.", default =” En slumpmässig sträng.”)
args = parser.parse_args ()
skriva ut (args.trycksträng)
Nu när du kör “testet.py ”-skript utan argument, bör du få” En slumpmässig sträng.”Som utgång. Du kan också använda nyckelordet "-print_string" för att skriva ut valfri sträng.
$ ./testa.py --print_string LinuxHint.comLinuxHint.com
Observera att du kan göra ett valfritt argument obligatoriskt genom att använda ett ytterligare "required = True" -argument.
Slutligen kan du också definiera stenografiska versioner av argumentet med hjälp av “-” (ett enda streck) för att minska storheten.
importera argparseparser = argparse.ArgumentParser (beskrivning = 'Ett testprogram.')
parser.add_argument (“- p”, "--print_string", help = "Skriver ut det medföljande argumentet.", default =” En slumpmässig sträng.”)
args = parser.parse_args ()
skriva ut (args.trycksträng)
Att köra följande kommando ska ge dig samma resultat som ovan:
$ ./testa.py -p LinuxHint.comExempel 3: Hantera ett heltalargument
För att hantera argument som kräver heltal måste du ställa in nyckelordet "typ" på "int" för att möjliggöra validering och kasta fel om villkoret inte uppfylls.
importera argparseparser = argparse.ArgumentParser (beskrivning = 'Ett testprogram.')
parser.add_argument ("- p", "--print_string", help = "Skriver ut det angivna argumentet.", typ = int)
args = parser.parse_args ()
skriva ut (args.trycksträng)
Försök att köra följande kommando:
$ ./testa.py -p LinuxHint.comDu bör få ett fel så här:
användning: test.py [-h] [-p PRINT_STRING]testa.py: fel: argument -p / - print_string: ogiltigt int-värde: 'LinuxHint.com '
Att ange ett heltal ger dig rätt resultat:
$ ./testa.py -p 1000 1000Exempel 4: Hantera sanna och falska växlar
Du kan skicka argument utan några värden för att behandla dem som sanna och falska flaggor med argumentet ”action”.
importera argparseparser = argparse.ArgumentParser (beskrivning = 'Ett testprogram.')
parser.add_argument ("- p", "--print_string", help = "Skriver ut det angivna argumentet.", action =" store_true ")
args = parser.parse_args ()
skriva ut (args.trycksträng)
Kör kommandot nedan för att få en enkel "True" som utdata:
$ ./testa.py -pOm du kör skriptet utan "-p" -argumentet tilldelas istället ett "Falskt" värde. Värdet "store_true" för "action" nyckelordet tilldelar ett "True" -värde till "print_string" -variabeln när "-p" -argumentet anges uttryckligen, annars tilldelas False till variabeln.
Exempel 5: Behandla argumentvärden som en lista
Om du vill få flera värden samtidigt och lagra dem i listan måste du ange "nargs" nyckelord i följande format:
importera argparseparser = argparse.ArgumentParser (beskrivning = 'Ett testprogram.')
parser.add_argument ("- p", "--print_string", help = "Skriver ut det medföljande argumentet.", nargs = '*')
args = parser.parse_args ()
skriva ut (args.trycksträng)
Kör följande kommando för att testa koden ovan:
$ ./testa.py -p “a” “b”Du borde få utdata så här:
['a', 'b']Slutsats
"Argparse" -modulen är ganska omfattande med massor av alternativ för att justera beteendet hos kommandoradsapplikationer och analysera användarlevererade värden. Dessa exempel berör bara den grundläggande användningen av modulen ”argparse”. För avancerade och komplexa applikationer kan du behöva olika implementeringar. Besök den officiella dokumentationen för en fullständig förklaring av modulen.
