Argumenten ontleden op de opdrachtregel in Python

De opdrachtregelargumenten worden gebruikt om gegevens in het programma door te geven op het moment dat het programma wordt uitgevoerd. Deze functie is beschikbaar in de meeste populaire programmeertalen. Maar de verwerking van opdrachtregelargumenten is voor verschillende talen verschillend. De argumentwaarden worden gegeven met de programmanaam op het moment dat het programma wordt uitgevoerd. Python-taal ondersteunt deze functie. Hoe opdrachtregelargumenten worden geparseerd in het Python-script wordt in dit artikel getoond.

Opdrachtregelargument ontleden met sys module

Opdrachtregelargumenten worden in een lijst opgeslagen met sys module.  sys.argv wordt gebruikt om de waarden van de opdrachtregelargumenten te lezen. Het totale aantal opdrachtregelargumenten kan worden geteld met behulp van len() functie. Het gebruik van deze module wordt beschreven in het deel van het artikel.

Voorbeeld 1: Het aantal argumenten en argumentwaarden lezen

Maak een bestand met het volgende python-script:.  Hier worden de opdrachtregelargumentwaarden opgeslagen in de variabele, argv zoals andere talen. len() methode telt het totale aantal argumenten dat is doorgegeven op het moment dat het script wordt uitgevoerd. Argumentwaarden worden afgedrukt als een array aan het einde van het script.

# Systeemmodule importeren
import systeem
# Print totaal aantal argumenten
print('Totaal aantal argumenten:', len(sys.argv))
print('De argumentwaarden zijn:', str(sys.argv))

Uitgang:

Het bovenstaande script wordt hier uitgevoerd met behulp van vier opdrachtregelargumenten:. Het eerste argument is de scriptnaam en andere zijn numerieke waarden. De volgende uitvoer zal verschijnen na het uitvoeren van het script:.

Voorbeeld 2: Argumentwaarden lezen met behulp van de lus

In het vorige voorbeeld worden argumentwaarden afgedrukt als een array. Maak een bestand met het volgende script om het type argumentvariabele af te drukken en druk elke argumentwaarde in elke regel af met for loop.

# Systeemmodule importeren
import systeem
# Druk het type van de variabele af, sys.argv
print(type(sys).argv))
# Print elk commandoregelargument in elke regel
print('De opdrachtregelargumenten zijn:')
voor ik in sys.argv:
afdrukken (ik)

Uitgang:

Het bovenstaande script wordt uitgevoerd door drie argumenten te geven met de scriptnaam. De volgende uitvoer zal verschijnen na het uitvoeren van het script:.

Opdrachtregelargument ontleden met behulp van de getopt-module

Getopt module wordt gebruikt om opdrachtregelargumenten te ontleden met de opties. getopt() methode van deze module wordt gebruikt voor het lezen van de argumenten. Deze methode heeft drie argumenten:. De eerste twee argumenten zijn verplicht en het laatste argument is optioneel. Het gebruik van deze argumenten wordt hieronder gegeven:.

argumenten: Het bevat het argument uit het opdrachtregelargument.

korte_optie: Het kan elke letter zijn die bij het argument past.

lange_optie: Het wordt gebruikt om lange opties met twee delen te definiëren. Dit zijn de optienaam en optiewaarde.

Syntaxis: getopt.getopt(args, short_option, [long_option])

Voorbeeld 3: Argumentwaarden lezen met korte getopt-opties

getopt module bevat meer functies dan sys module. Het volgende voorbeeld laat zien hoe korte opties kunnen worden gebruikt in: getopt() methode. argv variabele slaat de opdrachtregelargumenten op door de scriptnaam weg te laten. Vervolgens worden twee opties gedefinieerd in de getopt() methode die tijdens runtime met het argument kan worden gebruikt. Als er een fout optreedt, wordt er een foutmelding weergegeven.

# Getopt-module importeren
import getopt
# Systeemmodule importeren
import systeem
# Bewaar argumentvariabele zonder de scriptnaam
argv = sys.argv[1:]
 
proberen:
# Definieer getopt korte opties
opties, args = getopt.getopt(argv, 'x:y:')
# print de opties en argumenten
print(opties)
afdrukken (argumenten)
 
behalve getopt.GetoptFout:
# Druk het foutbericht af als de verkeerde optie is opgegeven
print('De verkeerde optie is opgegeven')
# Beëindig het script
sys.uitgang(2)

Uitgang:

Voer het script uit zonder enig argument, argumenten met de juiste opties en argumenten met de verkeerde optie.

Voorbeeld 4: Argumentwaarden lezen met korte en lange getopt-opties

Dit voorbeeld laat zien hoe zowel korte als lange opties kunnen worden gebruikt met de argumentwaarden. Het zal twee getallen toevoegen wanneer '-een' of '-toevoegen' wordt gebruikt als een optie en trekt twee getallen af ​​als '-s' of '-sub' wordt tijdens runtime als optie gebruikt.

# Getopt-module importeren
import getopt
# Systeemmodule importeren
import systeem
# Bewaar argumentvariabele zonder de scriptnaam
argv = sys.argv[1:]
# Initialiseer resultaatvariabele
resultaat=0
 
proberen:
 
# Definieer getopt korte en lange opties
opties, args = getopt.getopt(sys.argv[1:], 'a:s', ['add=','sub='])
 
# Lees elke optie met de for-lus
voor opt, arg in opties:
# Bereken de som als de optie -a of --add . is
indien aangemeld ('-a', '--add'):
resultaat = int(argv[1]) + int(argv[2])
# Bereken de suntractie als de optie -s of --sub . is
elif opt-in ('-s', '--sub'):
resultaat = int(argv[1]) - int(argv[2])
 
print('Resultaat = ', resultaat)
behalve getopt.GetoptFout:
# Druk het foutbericht af als de verkeerde optie is opgegeven
print('De verkeerde optie is opgegeven')
# Beëindig het script
sys.uitgang(2)

Uitgang:

Voer het script uit zonder argumenten en opties, argumenten met '-a' optie, argumenten met '-s' optie en argumenten met de verkeerde optie.

Opdrachtregelargument ontleden met argparse-module

Argparse-module bevat veel opties om opdrachtregelargumenten te lezen. Standaardargumentwaarden, het argument met het gegevenstype, positionele argumenten, helpbericht, enz. kan worden geleverd door deze module.

Voorbeeld 5: Opdrachtregelargumenten lezen met argparse

Het volgende voorbeeld toont het gebruik van argparse module voor het lezen van opdrachtregelargumenten. Hier zijn twee opties gedefinieerd voor het lezen van opdrachtregelargumenten:. Dit zijn '-n' of '-naam' en '-e' of '-e-mail'. Als de gebruiker een verkeerd argument geeft, wordt er een fout weergegeven met een gebruiksbericht. Als de gebruiker de juiste opties met de argumenten geeft, zal het de argumentwaarden weergeven. als de gebruiker het script uitvoert met de optie '-help', dan zal het de nodige boodschap geven om het script uit te voeren.

# Importeer argparse-module
import argparse
# Systeemmodule importeren
import systeem
# Declareer functie om opdrachtregelargumenten te definiëren
def readOptions(args=sys.argv[1:]):
parser = argparse.ArgumentParser(description = "De lijsten met ontledingsopdrachten.")
parser.add_argument("-n", "--name", help="Typ je naam.")
parser.add_argument("-e", "--email", help="Typ uw e-mailadres.")
opts = parser.parse_args(args)
terugkeer opties
# Roep de functie aan om de argumentwaarden te lezen
opties = readOptions(sys.argv[1:])
print(opties).naam)
print(opties).e-mail)

Uitgang:

Voer het script uit met de verkeerde optie, de juiste optie en de helpoptie.

Conclusie:

Verschillende manieren om opdrachtregelargumenten te lezen worden in deze tutorial uitgelegd met behulp van drie python-modules. Ik hoop dat deze tutorial de codeur zal helpen die gegevens wil lezen met behulp van opdrachtregelargumenten in python.

Bekijk de video van de auteur: hier