Vil du kjøre Python-skript med kommandolinjeargumenter? Lær hvordan du analyserer kommandolinjeargumenter ved å bruke sys-, getopt- og argparse-moduler i Python.
I Python, når du vil lese inn brukerinndata, bruker du input()-funksjonen. Men for noen applikasjoner vil du kanskje sende inn visse argumenter mens du kjører skriptet på kommandolinjen.
I denne opplæringen lærer vi hvordan du kjører et Python-skript med alternativer og argumenter på kommandolinjen. Vi vil da lære hvordan du bruker Pythons innebygde moduler for å analysere slike alternativer og argumenter.
La oss begynne!
Innholdsfortegnelse
Forstå sys.argv i Python
Hvis du har programmert i C, vet du at en av de enkleste måtene å sende inn argumenter til programmet på er via kommandolinjen. For å gjøre det kan du strukturere hovedfunksjonen slik:
#include<stdio.h>
int main(int argc, char **argv){
//argc: argument count
//argv: argument vector
//do something on the args
return 0;
}
Her står argc for argumentantall og argv står for argumentvektor.
Kjøre Python-skript med kommandolinjeargumenter
I Python kan du kjøre Python-skriptet på kommandolinjen ved å bruke python3 filename.py. Når du gjør det, kan du også sende inn et vilkårlig antall kommandolinjeargumenter:
$ python3 filename.py arg1 arg2 ... argn
Sys-modulen gir ut-av-boksen støtte for å få tilgang til og behandle disse kommandolinjeargumentene. sys.argv er listen over alle kommandolinjeargumentene som vi sender inn når vi kjører Python-skriptet.
Her er et eksempel hvor vi kjører main.py med kommandolinjeargumenter:
$ python3 main.py hello world python script
Vi kan gå gjennom argumentvektoren ved å bruke en enkel for loop og enumerate-funksjon:
# 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
Vi ser at det første argumentet (ved indeks 0) er navnet på Python-filen. Og påfølgende argumenter starter ved indeks 1.
Dette er et minimalt arbeidsprogram som godtar og behandler kommandolinjeargumenter. Vi ser imidlertid noen problemer:
- Hvordan vet brukere av programmet hvilke argumenter de skal sende inn?
- Og hva står disse argumentene for?
Dette er ikke veldig tydelig. For å løse dette kan du bruke enten getopt- eller argparse-modulene. Og det lærer vi i de neste avsnittene.✅
Parsing av kommandolinjeargument ved hjelp av Pythons getopt
La oss lære hvordan du analyserer kommandolinjeargumenter ved å bruke den innebygde getopt-modulen.
Etter å ha importert getopt fra getopt-modulen, kan du spesifisere argumentene som skal analyseres og de korte alternativene og lange alternativene for å kjøre skriptet med. Vi må analysere alle argumenter som starter ved indeks 1 i sys.argv. Så stykket som skal analyseres er sys.argv[1:].
Her trenger vi en meldingsstreng og filnavn. La oss bruke m og f som korte alternativer og melding og fil som lange alternativer.
Men hvordan sikrer vi at et spesifikt alternativ krever en argumentasjon?
- I korte alternativer kan du få et alternativ til å kreve et argument ved å legge til et kolon (:) etter det korte alternativnavnet.
- På samme måte, i lange alternativer, kan du legge til et =-tegn etter det lange alternativet. Vi kan fange opp disse alternativene og deres respektive argumenter.
Hvis du legger til disse, får vi følgende kode i main.py:
# main.py import sys from getopt import getopt opts, args = getopt(sys.argv[1:],'m:f:',['message=","file="]) print(opts) print(args)
Her inneholder variabelen opts alternativene og argumentene som en liste over tupler. Ethvert annet posisjonsargument som vi sender inn vil bli samlet i args-variabelen.
Vi kan sende inn meldingen og filnavnet for å kjøre skriptet, og vi kan bruke enten de korte alternativene eller de lange alternativene.
Når vi kjører main.py med de lange alternativene, har vi:
$ python3 main.py --message hello --file somefile.txt
Vi har alternativene og argumentene som tupler i opts-variabelen. Siden vi ikke har bestått i noe posisjonsargument, er args en tom liste.
# Output
[("--message', 'hello'), ('--file', 'somefile.txt')]
[]
Tilsvarende kan vi også bruke de korte alternativene som vist:
$ python3 main.py -m hello -f somefile.txt
# Output
[('-m', 'hello'), ('-f', 'somefile.txt')]
[]
⚠️ Det korte alternativet -m i dette eksemplet må ikke forveksles med kommandolinjeflagget -m som brukes til å kjøre en modul som hovedmodul når du kjører et Python-skript.
For eksempel vil du bruke python3 -m unittest main.py for å kjøre unittest som hovedmodul når du kjører main.py.
Vi nevnte at alle andre posisjonsargumenter som vi sender inn vil bli samlet i args-variabelen. Her er et eksempel:
$ python3 main.py -m hello -f somefile.txt another_argument
Argumentlisten inneholder posisjonsargumentet another_argument.
# Output
[('-m', 'hello'), ('-f', 'somefile.txt')]
['another_argument']
Her er opts en liste over tupler. Så vi kan gå gjennom den, pakke ut tuppelen og trekke ut argumentene som tilsvarer de spesifikke alternativene.
Men hva gjør vi med filnavnet og meldingen etter at vi har behandlet disse argumentene? Vi åpner filen i skrivemodus og skriver meldingsstrengen konvertert til store bokstaver til filen.
# 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())
La oss kjøre main.py med de korte alternativene og kommandolinjeargumentene.
$ python main.py -m hello -f thisfile.txt
[('-m', 'hello'), ('-f', 'thisfile.txt')]
[]
Etter å ha kjørt main.py, kan vi se «thisfile.txt» i arbeidskatalogen vår. Den inneholder strengen «hello» konvertert til store bokstaver («HELLO»).
$ ls main.py thisfile.txt
$ cat thisfile.txt HELLO
Hvordan analysere kommandolinjeargumenter med Argparse
Argparse-modulen, også innebygd i Python-standardbiblioteket, gir funksjonalitet for å analysere kommandolinjeargumenter og også bygge kommandolinjegrensesnitt.
For å analysere kommandolinjeargumenter, la oss importere ArgumentParser-klassen fra argparse-modulen. Her har vi instansiert arg_parser, et ArgumentParser-objekt:
from argparse import ArgumentParser arg_parser = ArgumentParser()
Deretter vil vi legge til to kommandolinjeargumenter:
- melding: meldingsstrengen, og
- fil: navnet på filen vi ønsker å jobbe med.
Nå kaller vi add_argument()-metoden på arg_parser for å legge til begge disse argumentene. I metodekallet add_argument() kan du sette hjelp til en streng (en beskrivelse av argumentet).
arg_parser.add_argument('message',help='message string')
arg_parser.add_argument('file',help='filename')
Så langt har vi instansiert arg_parser og lagt til kommandolinjeargumentene. Når programmet kjøres på kommandolinjen, kan du bruke parse_args()-metoden på arg_parser for å få verdiene til argumentene.
Her fanger vi argumentnavnet i variabelen args. Så du kan bruke args.argument_name for å få verdiene til argumentene.
Etter å ha fått verdiene til argumentene, skriver vi meldingsstrengen med kasusbytte (ved bruk av swapcase()-strengmetoden) til filen.
args = arg_parser.parse_args()
message = args.message
file = args.file
with open(file,'w') as f:
f.write(message.swapcase())
Setter alt sammen, her er main.py-filen vår:
# 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())
Forstå bruk av kommandolinjeargumenter
For å forstå bruken av argumentene når du kjører main.py, kan du bruke alternativet –help long som vist:
$ 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
Det er ingen valgfrie argumenter, og både melding og fil er obligatoriske posisjonsargumenter. Alternativt kan du også bruke det korte alternativet -h:
$ 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
Som sett er begge argumentene posisjonsargumenter som standard. Så hvis du ikke sender inn ett eller flere av disse argumentene, vil du støte på feil.
Her har vi sendt inn et posisjonsargument (Hei) for meldingsstrengen, men vi har ikke oppgitt noen verdi for filargumentet.
Og vi får en feilmelding om at filargumentet er nødvendig.
$ python3 main.py Hello usage: main.py [-h] message file main.py: error: the following arguments are required: file
Når vi kjører main.py med begge posisjonsargumentene, ser vi at navneområdet args inneholder verdiene til argumentene.
$ python3 main.py Hello file1.txt
# Output Namespace(file="file1.txt", message="Hello")
Hvis vi nå undersøker innholdet i den nåværende arbeidskatalogen, ser vi at skriptet lager filen «file1.txt»:
$ ls file1.txt main.py
Den opprinnelige meldingsstrengen er «Hei»; etter å ha byttet saken er meldingsstrengen i filen «fil1.txt» «HELLO».
$ cat file1.txt hELLO
Hvordan gjøre kommandolinjeargumenter valgfrie
For å gjøre disse kommandolinjeargumentene valgfrie, kan du prefiksere argumentnavnet med –.
La oss endre main.py for å gjøre både meldings- og filargumentene valgfrie.
# main.py
from argparse import ArgumentParser
arg_parser = ArgumentParser()
arg_parser.add_argument('--message',help='message string')
arg_parser.add_argument('--file',help='filename')
Siden kommandolinjeargumentene begge er valgfrie, kan vi angi standardverdier for disse argumentene.
if args.message and args.file:
message = args.message
file = args.file
else:
message="Python3"
file="myfile.txt"
På dette tidspunktet inneholder main.py-filen følgende kode:
# 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())
Hvis vi sjekker bruken, ser vi at både melding og fil er valgfrie argumenter. Det betyr at du nå kan kjøre main.py uten begge disse argumentene.
$ 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
I argumentnavneområdet er både fil og melding Ingen.
# Output Namespace(file=None, message=None)
Vi ser at standard filnavn og melding «myfile.txt» og «Python3» brukes. Filen «myfile.txt» er nå i arbeidskatalogen:
$ ls file1.txt main.py myfile.txt
Og den inneholder strengen «Python3» med store og små bokstaver byttet:
$ cat myfile.txt pYTHON3
Du kan også bruke både –melding og –fil-argumentene for å gjøre kommandoen mer lesbar.
$ python3 main.py --message Coding --file file2.txt
# Output Namespace(file="file2.txt", message="Coding")
Vi ser «file2.txt» i arbeidskatalogen:
$ ls file1.txt file2.txt main.py myfile.txt
Og den inneholder strengen «coDING» som forventet.
$ cat file2.txt cODING
Konklusjon
Her er et sammendrag av det vi har lært i denne opplæringen:
- I likhet med C-programmeringsspråket, i Python, kan du få tilgang til kommandolinjeargumentene ved å gå gjennom argumentvektoren sys.argv. sys.argv[0] er navnet på Python-skriptet. Så vi er interessert i å analysere argumentene sys.argv[1:].
- Men for å forbedre lesbarheten og for å kunne legge til alternativer, kan du bruke til å getopt og argparse moduler.
- Du kan bruke getopt-modulen til å analysere listen over kommandolinjeargumenter fra indeks 1 til slutten av listen. Du kan spesifisere både korte og lange alternativer.
- Når et alternativ tar et argument, kan du spesifisere et kolon (:) og = etter henholdsvis det korte alternativet og det lange alternativet.
- Med Pythons argparse-modul kan du instansiere et ArgumentParser-objekt og bruke add_argument()-metoden for å legge til et nødvendig posisjonsargument. Bruk — før argumentnavnet for å gjøre det valgfritt.
- For å hente verdiene til kommandolinjeargumentene, kall opp parse_args()-metoden på ArgumentParser-objektet.
Deretter lærer du hvordan du utfører sikker hashing i Python.