Handledning för argparse

författare:

Tshepang Mbambo

Denna handledning är avsedd att vara en mild introduktion till argparse, den rekommenderade modulen för kommandoradsanalys i Pythons standardbibliotek.

Anteckning

Standardbiblioteket innehåller två andra bibliotek som är direkt relaterade till bearbetning av kommandoradsparametrar: modulen optparse på lägre nivå (som kan kräva mer kod för att konfigureras för en viss applikation, men som också gör det möjligt för en applikation att begära beteenden som argparse inte stöder) och modulen getopt på mycket låg nivå (som specifikt fungerar som en motsvarighet till getopt()-familjen av funktioner som är tillgängliga för C-programmerare). Även om ingen av dessa moduler behandlas direkt i den här guiden, har många av kärnkoncepten i argparse sitt ursprung i optparse, så vissa aspekter av denna handledning kommer också att vara relevanta för optparse-användare.

Koncept

Låt oss visa den typ av funktionalitet som vi kommer att utforska i denna inledande handledning genom att använda kommandot ls:

$ ls
cpython devguide prog.py pypy rm-unused-function.patch
$ ls pypy
ctypes_configure demo dotviewer include lib_pypy lib-python ...
$ ls -l
totalt 20
drwxr-xr-x 19 wena wena 4096 feb 18 18:51 cpython
drwxr-xr-x 4 wena wena 4096 8 feb 12:04 devguide
-rwxr-xr-x 1 wena wena 535 19 februari 00:05 prog.py
drwxr-xr-x 14 wena wena 4096 feb 7 00:59 pypy
-rw-r--r-- 1 wena wena 741 feb 18 01:01 rm-unused-function.patch
$ ls --hjälp
Användning: ls [OPTION]... [FIL]...
Visar information om FILEs (den aktuella katalogen som standard).
Sorterar posterna i alfabetisk ordning om varken -cftuvSUX eller --sort har angetts.
...

Några begrepp som vi kan lära oss av de fyra kommandona:

• Kommandot ls är användbart när det körs utan några alternativ alls. Standardinställningen är att visa innehållet i den aktuella katalogen.

• Om vi vill ha mer än vad den tillhandahåller som standard, berättar vi lite mer för den. I det här fallet vill vi att den ska visa en annan katalog, pypy. Vad vi gjorde var att ange vad som kallas ett positionellt argument. Det kallas så eftersom programmet ska veta vad det ska göra med värdet, enbart baserat på var det visas på kommandoraden. Det här konceptet är mer relevant för ett kommando som cp, vars mest grundläggande användning är cp SRC DEST. Den första positionen är det du vill kopiera och den andra positionen är där du vill att det ska kopieras till.

• Låt oss nu säga att vi vill ändra programmets beteende. I vårt exempel visar vi mer information för varje fil i stället för att bara visa filnamnen. I det fallet kallas -l för ett valfritt argument.

• Det är ett utdrag ur hjälptexten. Det är mycket användbart eftersom du kan stöta på ett program som du aldrig har använt tidigare och kan ta reda på hur det fungerar genom att läsa dess hjälptext.

Grunderna

Låt oss börja med ett mycket enkelt exempel som gör (nästan) ingenting:

import argparse
parser = argparse.ArgumentParser()
parser.parse_args()

Följande är ett resultat av att köra koden:

$ python prog.py
$ python prog.py --hjälp
användning: prog.py [-h]

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
$ python prog.py --verbose
användning: prog.py [-h]
prog.py: fel: oigenkända argument: --verbose
$ python prog.py foo
användning: prog.py [-h]
prog.py: fel: oigenkända argument: foo

Det här är vad som händer:

• Om du kör skriptet utan några alternativ visas ingenting i utdatan. Inte så användbart.

• Den andra börjar visa hur användbar modulen argparse är. Vi har nästan inte gjort någonting, men redan nu får vi ett trevligt hjälpmeddelande.

• Alternativet --help, som också kan förkortas till -h, är det enda alternativ vi får gratis (dvs. vi behöver inte ange det). Om man anger något annat resulterar det i ett fel. Men även då får vi ett användbart användningsmeddelande, också det gratis.

Introduktion till positionella argument

Ett exempel:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo")
args = parser.parse_args()
print(args.echo)

Och kör koden:

$ python prog.py
användning: prog.py [-h] echo
prog.py: fel: följande argument krävs: echo
$ python prog.py --hjälp
användning: prog.py [-h] echo

positionella argument:
  echo

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
$ python prog.py foo
foo

Det här är vad som händer:

• Vi har lagt till metoden add_argument(), som vi använder för att ange vilka kommandoradsalternativ som programmet är villigt att acceptera. I det här fallet har jag döpt den till echo så att den är i linje med sin funktion.

• För att anropa vårt program måste vi nu ange ett alternativ.

• Metoden parse_args() returnerar faktiskt data från de angivna alternativen, i det här fallet echo.

• Variabeln är någon form av ”magi” som argparse utför gratis (dvs. du behöver inte ange vilken variabel värdet lagras i). Du kommer också att märka att dess namn matchar det strängargument som ges till metoden, echo.

Observera dock att även om hjälpvisningen ser trevlig ut är den för närvarande inte så hjälpsam som den skulle kunna vara. Vi ser till exempel att vi har echo som ett positionellt argument, men vi vet inte vad det gör, annat än genom att gissa eller läsa källkoden. Så, låt oss göra det lite mer användbart:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("echo", help="echo the string you use here")
args = parser.parse_args()
print(args.echo)

Och vi får..:

$ python prog.py -h
användning: prog.py [-h] echo

positionella argument:
  echo echo echo den sträng du använder här

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta

Nu, vad sägs om att göra något ännu mer användbart:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number")
args = parser.parse_args()
print(args.square**2)

Följande är ett resultat av att köra koden:

$ python prog.py 4
Traceback (senaste anropet senast):
  Fil "prog.py", rad 5, i <module>
    print(args.kvadrat**2)
TypeError: operandtyp(er) som inte stöds för ** eller pow(): 'str' och 'int'

Det gick inte så bra. Det beror på att argparse behandlar de alternativ vi ger den som strängar, om vi inte säger något annat. Så, låt oss säga till argparse att behandla den inmatningen som ett heltal:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", help="display a square of a given number",
                    type=int)
args = parser.parse_args()
print(args.square**2)

Följande är ett resultat av att köra koden:

$ python prog.py 4
16
$ python prog.py fyra
användning: prog.py [-h] kvadrat
prog.py: fel: argument square: ogiltigt int-värde: 'four'

Det gick bra. Programmet avbryter nu till och med på ett hjälpsamt sätt vid dålig olaglig inmatning innan det fortsätter.

Introduktion av valfria argument

Hittills har vi lekt med positionella argument. Låt oss ta en titt på hur man lägger till valfria argument:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbosity", help="increase output verbosity")
args = parser.parse_args()
if args.verbosity:
    print("verbosity turned on")

Och utmatningen:

$ python prog.py --verbosity 1
ordrikhet aktiverad
$ python prog.py
$ python prog.py --hjälp
användning: prog.py [-h] [--verbosity VERBOSITY]

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
  --verbositet VERBOSITET
                        öka utmatningens ordrikedom
$ python prog.py --verbosity
användning: prog.py [-h] [--verbosity VERBOSITY]
prog.py: fel: argument --verbosity: förväntade ett argument

Det här är vad som händer:

• Programmet är skrivet så att det visar något när --verbosity anges och ingenting när så inte är fallet.

• För att visa att alternativet faktiskt är valfritt, blir det inget fel när programmet körs utan det. Observera att som standard, om ett valfritt argument inte används, får den relevanta variabeln, i det här fallet args.verbosity, None som värde, vilket är anledningen till att den inte klarar sanningstestet i if-satsen.

• Hjälpmeddelandet är lite annorlunda.

• När man använder alternativet --verbosity måste man också ange ett värde, vilket som helst.

Exemplet ovan accepterar godtyckliga heltalsvärden för --verbosity, men för vårt enkla program är det bara två värden som är användbara, True eller False. Låt oss modifiera koden i enlighet med detta:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbose", help="increase output verbosity",
                    action="store_true")
args = parser.parse_args()
if args.verbose:
    print("verbosity turned on")

Och utmatningen:

$ python prog.py --verbose
ordrikhet aktiverad
$ python prog.py --verbose 1
användning: prog.py [-h] [--verbose]
prog.py: fel: oigenkända argument: 1
$ python prog.py --hjälp
användning: prog.py [-h] [--verbose]

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
  --verbose ökar utmatningens ordrikedom

Det här är vad som händer:

• Alternativet är nu mer av en flagga än något som kräver ett värde. Vi har även ändrat namnet på alternativet för att matcha den idén. Observera att vi nu anger ett nytt nyckelord, action, och ger det värdet "store_true". Detta innebär att, om alternativet är specificerat, tilldela värdet True till args.verbose. Om det inte specificeras innebär det False.

• Den klagar när du anger ett värde, i sann anda av vad flaggor faktiskt är.

• Lägg märke till de olika hjälptexterna.

Korta alternativ

Om du är bekant med kommandoradsanvändning kommer du att märka att jag ännu inte har berört ämnet kortversioner av alternativen. Det är ganska enkelt:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", help="increase output verbosity",
                    action="store_true")
args = parser.parse_args()
if args.verbose:
    print("verbosity turned on")

Och här kommer det:

$ python prog.py -v
ordrikedom aktiverad
$ python prog.py --hjälp
användning: prog.py [-h] [-v]

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
  -v, --verbose öka utmatningens ordrikedom

Observera att den nya förmågan också återspeglas i hjälptexten.

Kombination av positionella och valfria argument

Vårt program blir alltmer komplext:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbose", action="store_true",
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbose:
    print(f"the square of {args.square} equals {answer}")
else:
    print(answer)

Och nu till resultatet:

$ python prog.py
användning: prog.py [-h] [-v] kvadrat
prog.py: fel: följande argument krävs: square
$ python prog.py 4
16
$ python prog.py 4 --verbose
kvadraten av 4 är lika med 16
$ python prog.py --verbose 4
kvadraten på 4 är lika med 16

• Vi har återinfört ett positionsargument, därav klagomålet.

• Observera att ordningen inte spelar någon roll.

Vad sägs om att vi ger vårt program tillbaka möjligheten att ha flera verbosity-värden, och faktiskt får använda dem:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int,
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

Och utmatningen:

$ python prog.py 4
16
$ python prog.py 4 -v
användning: prog.py [-h] [-v VERBOSITY] kvadrat
prog.py: fel: argument -v/--verbosity: förväntade ett argument
$ python prog.py 4 -v 1
4^2 == 16
$ python prog.py 4 -v 2
kvadraten på 4 är lika med 16
$ python prog.py 4 -v 3
16

Alla dessa ser bra ut utom den sista, som avslöjar en bugg i vårt program. Låt oss åtgärda det genom att begränsa de värden som alternativet --verbosity kan acceptera:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", type=int, choices=[0, 1, 2],
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

Och utmatningen:

$ python prog.py 4 -v 3
användning: prog.py [-h] [-v {0,1,2}] kvadrat
prog.py: fel: argument -v/--verbosity: ogiltigt val: 3 (välj mellan 0, 1, 2)
$ python prog.py 4 -h
användning: prog.py [-h] [-v {0,1,2}] kvadrat

positionella argument:
  square visa en kvadrat av ett givet tal

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
  -v, --förtydligande {0,1,2}
                        öka utmatningens ordrikedom

Observera att ändringen också återspeglas både i felmeddelandet och i hjälpsträngen.

Låt oss nu använda ett annat tillvägagångssätt för att leka med verbosity, vilket är ganska vanligt. Det stämmer också överens med hur den körbara CPython-filen hanterar sitt eget verbosity-argument (kontrollera utdata från python --help):

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display the square of a given number")
parser.add_argument("-v", "--verbosity", action="count",
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity == 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity == 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

Vi har infört en annan åtgärd, ”count”, för att räkna antalet förekomster av specifika alternativ.

$ python prog.py 4
16
$ python prog.py 4 -v
4^2 == 16
$ python prog.py 4 -vv
kvadraten på 4 är lika med 16
$ python prog.py 4 --verbosity --verbosity
kvadraten på 4 är lika med 16
$ python prog.py 4 -v 1
användning: prog.py [-h] [-v] kvadrat
prog.py: fel: oigenkända argument: 1
$ python prog.py 4 -h
användning: prog.py [-h] [-v] kvadrat

positionella argument:
  square visar en kvadrat av ett givet tal

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
  -v, --verbosity öka utmatningens verbosity
$ python prog.py 4 -vvv
16

• Ja, det är nu mer av en flagga (liknande action="store_true") i den tidigare versionen av vårt skript. Det borde förklara klagomålet.

• Den beter sig också på liknande sätt som åtgärden ”store_true”.

• Här är nu en demonstration av vad ”count”-åtgärden ger. Du har förmodligen sett den här typen av användning tidigare.

• Och om du inte anger flaggan -v, anses den flaggan ha värdet None.

• Som väntat skulle vi få samma resultat om vi angav den långa formen av flaggan.

• Tyvärr är vår hjälputskrift inte särskilt informativ om den nya förmåga som vårt skript har fått, men det kan alltid åtgärdas genom att förbättra dokumentationen för vårt skript (t.ex. via nyckelordsargumentet help).

• Den sista utmatningen avslöjar en bugg i vårt program.

Låt oss fixa:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", action="count",
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2

# bugfix: replace == with >=
if args.verbosity >= 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity >= 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

Och det här är vad det ger:

$ python prog.py 4 -vvv
the square of 4 equals 16
$ python prog.py 4 -vvvv
the square of 4 equals 16
$ python prog.py 4
Traceback (most recent call last):
  File "prog.py", line 11, in <module>
    if args.verbosity >= 2:
TypeError: '>=' not supported between instances of 'NoneType' and 'int'

• Första utmatningen gick bra, och fixar buggen vi hade tidigare. Det vill säga att vi vill att alla värden >= 2 ska vara så utförliga som möjligt.

• Tredje utgången inte så bra.

Låt oss fixa det felet:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("square", type=int,
                    help="display a square of a given number")
parser.add_argument("-v", "--verbosity", action="count", default=0,
                    help="increase output verbosity")
args = parser.parse_args()
answer = args.square**2
if args.verbosity >= 2:
    print(f"the square of {args.square} equals {answer}")
elif args.verbosity >= 1:
    print(f"{args.square}^2 == {answer}")
else:
    print(answer)

Vi har just introducerat ännu ett nyckelord, default. Vi har satt det till 0 för att göra det jämförbart med de andra int-värdena. Kom ihåg att som standard, om ett valfritt argument inte anges, får det värdet None, och det kan inte jämföras med ett int-värde (därav TypeError-undantaget).

Och..:

$ python prog.py 4
16

Du kan komma ganska långt bara med det vi har lärt oss hittills, och vi har bara skrapat på ytan. Modulen argparse är mycket kraftfull, och vi ska utforska lite mer av den innan vi avslutar den här handledningen.

Blir lite mer avancerad

Tänk om vi ville utöka vårt lilla program till att utföra andra krafter, inte bara rutor:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
parser.add_argument("-v", "--verbosity", action="count", default=0)
args = parser.parse_args()
answer = args.x**args.y
if args.verbosity >= 2:
    print(f"{args.x} to the power {args.y} equals {answer}")
elif args.verbosity >= 1:
    print(f"{args.x}^{args.y} == {answer}")
else:
    print(answer)

Utdata:

$ python prog.py
användning: prog.py [-h] [-v] x y
prog.py: fel: följande argument krävs: x, y
$ python prog.py -h
användning: prog.py [-h] [-v] x y

positionella argument:
  x basen
  y exponenten

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
  -v, --verbositet
$ python prog.py 4 2 -v
4^2 == 16

Observera att vi hittills har använt verbosity level för att ändra den text som visas. I följande exempel används istället verbosity level för att visa mer text istället:

import argparse
parser = argparse.ArgumentParser()
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
parser.add_argument("-v", "--verbosity", action="count", default=0)
args = parser.parse_args()
answer = args.x**args.y
if args.verbosity >= 2:
    print(f"Running '{__file__}'")
if args.verbosity >= 1:
    print(f"{args.x}^{args.y} == ", end="")
print(answer)

Utdata:

$ python prog.py 4 2
16
$ python prog.py 4 2 -v
4^2 == 16
$ python prog.py 4 2 -vv
Kör 'prog.py'
4^2 == 16

Specificering av tvetydiga argument

När det är svårt att avgöra om ett argument är positionellt eller för ett argument, kan -- användas för att tala om för parse_args() att allt efter det är ett positionellt argument:

>>> parser = argparse.ArgumentParser(prog='PROG')
>>> parser.add_argument('-n', nargs='+')
>>> parser.add_argument('args', nargs='*')

>>> # ambiguous, so parse_args assumes it's an option
>>> parser.parse_args(['-f'])
usage: PROG [-h] [-n N [N ...]] [args ...]
PROG: error: unrecognized arguments: -f

>>> parser.parse_args(['--', '-f'])
Namespace(args=['-f'], n=None)

>>> # ambiguous, so the -n option greedily accepts arguments
>>> parser.parse_args(['-n', '1', '2', '3'])
Namespace(args=[], n=['1', '2', '3'])

>>> parser.parse_args(['-n', '1', '--', '2', '3'])
Namespace(args=['2', '3'], n=['1'])

Motstridiga alternativ

Hittills har vi arbetat med två metoder i en instans av argparse.ArgumentParser. Låt oss introducera en tredje, add_mutually_exclusive_group(). Den gör det möjligt för oss att ange alternativ som står i konflikt med varandra. Låt oss också ändra resten av programmet så att den nya funktionaliteten blir mer begriplig: vi inför alternativet --quiet, som kommer att vara motsatsen till --verbose:

import argparse

parser = argparse.ArgumentParser()
group = parser.add_mutually_exclusive_group()
group.add_argument("-v", "--verbose", action="store_true")
group.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
args = parser.parse_args()
answer = args.x**args.y

if args.quiet:
    print(answer)
elif args.verbose:
    print(f"{args.x} to the power {args.y} equals {answer}")
else:
    print(f"{args.x}^{args.y} == {answer}")

Vårt program är nu enklare, och vi har förlorat en del funktionalitet för demonstrationens skull. Hur som helst, här är utdata:

$ python prog.py 4 2
4^2 == 16
$ python prog.py 4 2 -q
16
$ python prog.py 4 2 -v
4 till potensen 2 är lika med 16
$ python prog.py 4 2 -vq
användning: prog.py [-h] [-v | -q] x y
prog.py: fel: argument -q/--quiet: inte tillåtet med argument -v/--verbose
$ python prog.py 4 2 -v --quiet
användning: prog.py [-h] [-v | -q] x y
prog.py: fel: argument -q/--quiet: inte tillåtet med argument -v/--verbose

Det borde vara lätt att följa. Jag har lagt till den sista utmatningen så att du kan se vilken typ av flexibilitet du får, dvs. blanda alternativ med lång form med kort form.

Innan vi avslutar vill du förmodligen berätta för dina användare huvudsyftet med ditt program, bara om de inte vet:

import argparse

parser = argparse.ArgumentParser(description="calculate X to the power of Y")
group = parser.add_mutually_exclusive_group()
group.add_argument("-v", "--verbose", action="store_true")
group.add_argument("-q", "--quiet", action="store_true")
parser.add_argument("x", type=int, help="the base")
parser.add_argument("y", type=int, help="the exponent")
args = parser.parse_args()
answer = args.x**args.y

if args.quiet:
    print(answer)
elif args.verbose:
    print(f"{args.x} to the power {args.y} equals {answer}")
else:
    print(f"{args.x}^{args.y} == {answer}")

Notera den lilla skillnaden i användningstexten. Notera [-v | -q], som säger oss att vi antingen kan använda -v eller -q, men inte båda samtidigt:

$ python prog.py --hjälp
användning: prog.py [-h] [-v | -q] x y

beräkna X till potensen av Y

positionella argument:
  x basen
  y exponenten

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
  -v, --överskådlig
  -q, --tyst

Hur man översätter argparse-utdata

Utdata från modulen argparse, t.ex. hjälptext och felmeddelanden, görs översättningsbara med modulen gettext. Detta gör att program enkelt kan lokalisera meddelanden som produceras av argparse. Se även Internationalisera dina program och moduler.

Till exempel i detta argparse-utdata:

$ python prog.py --hjälp
användning: prog.py [-h] [-v | -q] x y

beräkna X till potensen av Y

positionella argument:
  x basen
  y exponenten

alternativ:
  -h, --help visa detta hjälpmeddelande och avsluta
  -v, --överskådlig
  -q, --tyst

Strängarna usage:, positional arguments:, options: och show this help message and exit är alla översättningsbara.

För att kunna översätta dessa strängar måste de först extraheras till en .po-fil. Om du till exempel använder Babel, kör det här kommandot:

$ pybabel extract -o messages.po /usr/lib/python3.12/argparse.py

Detta kommando extraherar alla översättningsbara strängar från modulen argparse och skriver ut dem i en fil med namnet messages.po. Det här kommandot förutsätter att din Python-installation finns i /usr/lib.

Du kan ta reda på var modulen argparse finns i ditt system med hjälp av detta skript:

import argparse
print(argparse.__file__)

När meddelandena i filen .po har översatts och översättningarna har installerats med hjälp av gettext, kommer argparse` att kunna visa de översatta meddelandena.

Om du vill översätta dina egna strängar i argparse-utdata använder du gettext.

Anpassade typomvandlare

Med modulen argparse kan du ange anpassade typkonverterare för dina kommandoradsargument. Detta gör att du kan modifiera användarinmatning innan den lagras i argparse.Namespace. Detta kan vara användbart när du behöver förbehandla inmatningen innan den används i ditt program.

När du använder en anpassad typomvandlare kan du använda valfri callable som tar ett enda strängargument (argumentvärdet) och returnerar det konverterade värdet. Men om du behöver hantera mer komplexa scenarier kan du i stället använda en anpassad åtgärdsklass med parametern action.

Låt oss till exempel säga att du vill hantera argument med olika prefix och bearbeta dem i enlighet med detta:

import argparse

parser = argparse.ArgumentParser(prefix_chars='-+')

parser.add_argument('-a', metavar='<value>', action='append',
                    type=lambda x: ('-', x))
parser.add_argument('+a', metavar='<value>', action='append',
                    type=lambda x: ('+', x))

args = parser.parse_args()
print(args)

Utdata:

$ python prog.py -a värde1 +a värde2
Namespace(a=[('-', 'värde1'), ('+', 'värde2')])

I detta exempel har vi:

• Skapade en parser med anpassade prefixtecken med hjälp av parametern prefix_chars.

• Definierade två argument, -a och +a, som använde parametern type för att skapa anpassade typomvandlare för att lagra värdet i en tupel med prefixet.

Utan de anpassade typkonverterarna skulle argumenten ha behandlat -a och +a som samma argument, vilket inte skulle ha varit önskvärt. Genom att använda anpassade typkonverterare kunde vi skilja mellan de två argumenten.

Slutsats

Modulen argparse erbjuder mycket mer än vad som visas här. Dess dokument är ganska detaljerade och grundliga och fulla av exempel. Efter att ha gått igenom den här handledningen bör du lätt kunna tillgodogöra dig dem utan att känna dig överväldigad.