Phenquestions
Om du har utvecklat ett Python-skript eller ett program som är avsett att primärt köras i terminalemulatorer eller till och med GUI-appar kan läggning av kommandoradsargument förbättra dess användbarhet, kodläsbarhet, applikationsstruktur och övergripande användarvänlighet för applikationen för slutanvändarna. Dessa kommandoradsargument kallas också "alternativ" eller "växlar" och fungerar på samma sätt som argument som du brukar se i bash-skript och andra C / C ++ -baserade program.
För att lägga till argument i Python-skript måste du använda en inbyggd modul som heter "argparse". Som namnet antyder, analyserar den kommandoradsargument som används när du startar ett Python-skript eller ett 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 för programmet tillhandahålls som ett argument. ArgumentParser-objektet behövs för att konvertera kommandoradsargumentvärden 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 kodprovet 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 beskrivning 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 metoden "add_argument". 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å att du inte behöver uttryckligen ange "typen" i det här fallet. Ett standardvärde "Ingen" tilldelas också tillagda argument, såvida de inte åsidosätts.
Ta en titt igen i 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 direkt effekt på programmet. Positionsargument är också obligatoriska, såvida du inte ändrar deras beteenden manuellt.
För att definiera och analysera valfria argument kan du använda “-” (dubbel streck) och ändra standardvärdena med hjälp av argumentet “standard”.
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 “test.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.com LinuxHint.comObservera 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 "-" (en 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 medföljande 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 medföljande 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
Modulen "argparse" är ganska omfattande med massor av alternativ för att justera beteendet hos kommandoradsapplikationer och analysera värden från användaren. 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.
