Wilt u Python-scripts uitvoeren met opdrachtregelargumenten? Leer hoe u opdrachtregelargumenten kunt parseren met behulp van sys-, getopt- en argparse-modules in Python.
Als u in Python gebruikersinvoer wilt inlezen, gebruikt u de functie input(). Voor sommige toepassingen wilt u misschien bepaalde argumenten doorgeven terwijl u het script op de opdrachtregel uitvoert.
In deze zelfstudie leren we hoe u een Python-script uitvoert met opties en argumenten op de opdrachtregel. Vervolgens leren we hoe we de ingebouwde modules van Python kunnen gebruiken om dergelijke opties en argumenten te ontleden.
Laten we beginnen!
Inzicht in sys.argv in Python
Als je in C hebt geprogrammeerd, weet je dat een van de eenvoudigste manieren om argumenten aan het programma door te geven, via de opdrachtregel is. Om dit te doen, kunt u de hoofdfunctie als volgt structureren:
#include<stdio.h>
int main(int argc, char **argv){
//argc: argument count
//argv: argument vector
//do something on the args
return 0;
}
Hier staat argc voor argument count en argv voor argument vector.
Python-scripts uitvoeren met opdrachtregelargumenten
In Python kunt u het Python-script op de opdrachtregel uitvoeren met behulp van python3 bestandsnaam.py. Daarbij kunt u ook een willekeurig aantal opdrachtregelargumenten doorgeven:
$ python3 filename.py arg1 arg2 ... argn
De sys-module biedt out-of-the-box ondersteuning voor toegang tot en verwerking van deze opdrachtregelargumenten. sys.argv is de lijst met alle opdrachtregelargumenten die we doorgeven wanneer we het Python-script uitvoeren.
Hier is een voorbeeld waarbij we main.py uitvoeren met opdrachtregelargumenten:
$ python3 main.py hello world python script
We kunnen de argumentvector doorlopen met een eenvoudige for-lus en de opsommingsfunctie:
# main.py
import sys
for idx, arg in enumerate(sys.argv):
print(f"arg{idx}: {arg}")
# Output arg0:main.py arg1:hello arg2:world arg3:python arg4:script
We zien dat het eerste argument (bij index 0) de naam is van het Python-bestand. En volgende argumenten beginnen bij index 1.
Dit is een minimaal werkend programma dat opdrachtregelargumenten accepteert en verwerkt. We zien echter enkele problemen:
- Hoe weten gebruikers van het programma welke argumenten ze moeten doorgeven?
- En waar staan deze argumenten voor?
Dit is niet erg duidelijk. Om dit aan te pakken, kunt u de getopt- of de argparse-modules gebruiken. En dat zullen we in de volgende secties leren.✅
Commandoregelargumenten parseren met behulp van Python’s getopt
Laten we leren hoe we opdrachtregelargumenten kunnen ontleden met behulp van de ingebouwde getopt-module.
Na het importeren van getopt uit de getopt-module, kunt u de argumenten specificeren die moeten worden geparseerd en de korte opties en lange opties om het script mee uit te voeren. We moeten alle argumenten ontleden die beginnen bij index 1 in sys.argv. Het te ontleden segment is dus sys.argv[1:].
Hier hebben we een berichtenreeks en bestandsnaam nodig. Laten we m en f gebruiken als korte opties en bericht en bestand als lange opties.
Maar hoe zorgen we ervoor dat een bepaalde optie om een argument vraagt?
- In korte opties kunt u ervoor zorgen dat een optie een argument vereist door een dubbele punt (:) toe te voegen na de korte optienaam.
- Evenzo kunt u in lange opties een =-teken toevoegen na de lange optie. We kunnen deze opties en hun respectievelijke argumenten vastleggen.
Als we deze toevoegen, hebben we de volgende code in main.py:
# main.py import sys from getopt import getopt opts, args = getopt(sys.argv[1:],'m:f:',['message=","file="]) print(opts) print(args)
Hier bevat de variabele opts de opties en argumenten als een lijst met tupels. Elk ander positioneel argument dat we doorgeven, wordt verzameld in de variabele args.
We kunnen het bericht en de bestandsnaam doorgeven om het script uit te voeren, en we kunnen de korte of de lange opties gebruiken.
Door main.py uit te voeren met de lange opties, hebben we:
$ python3 main.py --message hello --file somefile.txt
We hebben de opties en argumenten als tuples in de opts-variabele. Aangezien we geen enkel positioneel argument hebben doorgegeven, is args een lege lijst.
# Output
[("--message', 'hello'), ('--file', 'somefile.txt')]
[]
Op equivalente wijze kunnen we ook de korte opties gebruiken zoals weergegeven:
$ python3 main.py -m hello -f somefile.txt
# Output
[('-m', 'hello'), ('-f', 'somefile.txt')]
[]
⚠️ De korte optie -m in dit voorbeeld moet niet worden verward met de opdrachtregelvlag -m die wordt gebruikt om een module uit te voeren als de hoofdmodule bij het uitvoeren van een Python-script.
U gebruikt bijvoorbeeld python3 -m unittest main.py om unittest uit te voeren als de hoofdmodule bij het uitvoeren van main.py.
We hebben vermeld dat alle andere positionele argumenten die we doorgeven, worden verzameld in de variabele args. Hier is een voorbeeld:
$ python3 main.py -m hello -f somefile.txt another_argument
De lijst met argumenten bevat het positionele argument een ander_argument.
# Output
[('-m', 'hello'), ('-f', 'somefile.txt')]
['another_argument']
Hier is opts een lijst met tuples. We kunnen er dus doorheen lopen, de tuple uitpakken en de argumenten eruit halen die overeenkomen met de specifieke opties.
Maar wat doen we met de bestandsnaam en het bericht nadat we deze argumenten hebben verwerkt? We openen het bestand in de schrijfmodus en schrijven de in hoofdletters geconverteerde berichtenreeks naar het bestand.
# main.py
import sys
from getopt import getopt
opts, args = getopt(sys.argv[1:],'m:f:',['message=","file="])
print(opts)
print(args)
for option, argument in opts:
if option == "-m':
message = argument
if option == '-f':
file = argument
with open(file,'w') as f:
f.write(message.upper())
Laten we main.py uitvoeren met de korte opties en opdrachtregelargumenten.
$ python main.py -m hello -f thisfile.txt
[('-m', 'hello'), ('-f', 'thisfile.txt')]
[]
Na het uitvoeren van main.py zien we ’thisfile.txt’ in onze werkdirectory. Het bevat de tekenreeks ‘hallo’ geconverteerd naar hoofdletters (‘HELLO’).
$ ls main.py thisfile.txt
$ cat thisfile.txt HELLO
Opdrachtregelargumenten parseren met Argparse
De argparse-module, ook ingebouwd in de standaardbibliotheek van Python, biedt functionaliteit voor het ontleden van opdrachtregelargumenten en het bouwen van opdrachtregelinterfaces.
Om opdrachtregelargumenten te ontleden, importeren we de ArgumentParser-klasse uit de argparse-module. Hier hebben we arg_parser geïnstantieerd, een ArgumentParser-object:
from argparse import ArgumentParser arg_parser = ArgumentParser()
Vervolgens willen we twee opdrachtregelargumenten toevoegen:
- bericht: de berichtenreeks, en
- bestand: de naam van het bestand waarmee we willen werken.
Nu roepen we de methode add_argument() op arg_parser aan om beide argumenten toe te voegen. In de methodeaanroep add_argument() kunt u help instellen op een tekenreeks (een beschrijving van het argument).
arg_parser.add_argument('message',help='message string')
arg_parser.add_argument('file',help='filename')
Tot nu toe hebben we arg_parser geïnstantieerd en de opdrachtregelargumenten toegevoegd. Wanneer het programma wordt uitgevoerd vanaf de opdrachtregel, kunt u de methode parse_args() op arg_parser gebruiken om de waarden van de argumenten te verkrijgen.
Hier leggen we de argumentnaamruimte vast in de variabele args. U kunt dus args.argument_name gebruiken om de waarden van de argumenten te krijgen.
Nadat we de waarden van de argumenten hebben verkregen, schrijven we de berichtstring met case swapped (met behulp van de swapcase() stringmethode) naar het bestand.
args = arg_parser.parse_args()
message = args.message
file = args.file
with open(file,'w') as f:
f.write(message.swapcase())
Alles bij elkaar genomen, hier is ons main.py-bestand:
# main.py
from argparse import ArgumentParser
arg_parser = ArgumentParser()
arg_parser.add_argument('message',help='message string')
arg_parser.add_argument('file',help='filename')
args = arg_parser.parse_args()
print(args)
message = args.message
file = args.file
with open(file,'w') as f:
f.write(message.swapcase())
Inzicht in het gebruik van opdrachtregelargumenten
Om het gebruik van de argumenten bij het uitvoeren van main.py te begrijpen, kunt u de optie –help long gebruiken, zoals weergegeven:
$ python3 main.py --help usage: main.py [-h] message file positional arguments: message message string file filename optional arguments: -h, --help show this help message and exit
Er zijn geen optionele argumenten en zowel bericht als bestand zijn vereiste positionele argumenten. Als alternatief kunt u ook de korte optie -h gebruiken:
$ python3 main.py -h usage: main.py [-h] message file positional arguments: message message string file filename optional arguments: -h, --help show this help message and exit
Zoals te zien is, zijn beide argumenten standaard positionele argumenten. Dus als u een of meer van deze argumenten niet doorgeeft, zult u fouten tegenkomen.
Hier hebben we een positioneel argument (Hallo) voor de berichtenreeks ingevoerd, maar we hebben geen waarde opgegeven voor het bestandsargument.
En we krijgen een foutmelding dat het bestandsargument vereist is.
$ python3 main.py Hello usage: main.py [-h] message file main.py: error: the following arguments are required: file
Wanneer we main.py uitvoeren met beide positionele argumenten, zien we dat de naamruimte args de waarden van de argumenten bevat.
$ python3 main.py Hello file1.txt
# Output Namespace(file="file1.txt", message="Hello")
Als we nu de inhoud van de huidige werkmap bekijken, zien we dat het script het bestand ‘file1.txt’ aanmaakt:
$ ls file1.txt main.py
De oorspronkelijke berichtenreeks is ‘Hallo’; na het verwisselen van de hoofdletters is de berichtenreeks in het bestand ‘file1.txt’ ‘hELLO’.
$ cat file1.txt hELLO
Opdrachtregelargumenten optioneel maken
Om deze opdrachtregelargumenten optioneel te maken, kunt u de naam van het argument laten voorafgaan door –.
Laten we main.py aanpassen om zowel de bericht- als de bestandsargumenten optioneel te maken.
# main.py
from argparse import ArgumentParser
arg_parser = ArgumentParser()
arg_parser.add_argument('--message',help='message string')
arg_parser.add_argument('--file',help='filename')
Omdat de opdrachtregelargumenten beide optioneel zijn, kunnen we standaardwaarden voor deze argumenten instellen.
if args.message and args.file:
message = args.message
file = args.file
else:
message="Python3"
file="myfile.txt"
Op dit moment bevat het bestand main.py de volgende code:
# main.py
from argparse import ArgumentParser
arg_parser = ArgumentParser()
arg_parser.add_argument('--message',help='message string')
arg_parser.add_argument('--file',help='filename')
args = arg_parser.parse_args()
print(args)
if args.message and args.file:
message = args.message
file = args.file
else:
message="Python3"
file="myfile.txt"
with open(file,'w') as f:
f.write(message.swapcase())
Als we het gebruik controleren, zien we dat zowel bericht als bestand optionele argumenten zijn. Dit betekent dat u main.py nu kunt uitvoeren zonder beide argumenten.
$ python3 main.py --help usage: main.py [-h] [--message MESSAGE] [--file FILE] optional arguments: -h, --help show this help message and exit --message MESSAGE message string --file FILE filename
$ python3 main.py
In de argumentnaamruimte zijn zowel bestand als bericht Geen.
# Output Namespace(file=None, message=None)
We zien dat de standaard bestandsnaam en bericht ‘myfile.txt’ en ‘Python3’ worden gebruikt. Het bestand ‘myfile.txt’ staat nu in de werkmap:
$ ls file1.txt main.py myfile.txt
En het bevat de string ‘Python3’ met het hoofdlettergebruik verwisseld:
$ cat myfile.txt pYTHON3
U kunt ook zowel de argumenten –message als –file gebruiken om de opdracht leesbaarder te maken.
$ python3 main.py --message Coding --file file2.txt
# Output Namespace(file="file2.txt", message="Coding")
We zien de ‘file2.txt’ in de werkmap:
$ ls file1.txt file2.txt main.py myfile.txt
En het bevat zoals verwacht de string ‘cODING’.
$ cat file2.txt cODING
Conclusie
Hier is een samenvatting van wat we in deze zelfstudie hebben geleerd:
- Net als bij de programmeertaal C, heb je in Python toegang tot de opdrachtregelargumenten door de argumentvector sys.argv te doorlopen. sys.argv[0] is de naam van het Python-script. We zijn dus geïnteresseerd in het ontleden van de argumenten sys.argv[1:].
- Om de leesbaarheid te verbeteren en om opties toe te voegen, kunt u echter modules getopt en argparse gebruiken.
- U kunt de getopt-module gebruiken om de lijst met opdrachtregelargumenten te ontleden vanaf index 1 tot aan het einde van de lijst. U kunt zowel korte opts als lange opts specificeren.
- Wanneer een optie een argument heeft, kunt u een dubbele punt (:) en = specificeren na respectievelijk de korte optie en de lange optie.
- Met de argparse-module van Python kunt u een object ArgumentParser instantiëren en de methode add_argument() gebruiken om een vereist positioneel argument toe te voegen. Gebruik — voor de naam van het argument om deze optioneel te maken.
- Roep de methode parse_args() op het object ArgumentParser aan om de waarden van de opdrachtregelargumenten op te halen.
Leer vervolgens hoe u veilige hashing uitvoert in Python.
