Käsurea argumendid Pythonis

Ülevaade

Kuna Python on väga populaarne programmeerimiskeel ning toetab enamikku operatsioonisüsteeme ja paljusid teeke, mis muudavad käsurea argumentide töötlemise lihtsaks, on seda laialdaselt kasutatud käsureatööriistade loomiseks mitmel otstarbel. Need tööriistad võivad ulatuda lihtsatest CLI-rakendustest kuni keerukamateni, nagu AWS. awscli vahend.

Selliseid keerulisi tööriistu juhib tavaliselt kasutaja käsurea argumendid, mis võimaldab kasutajal kasutada konkreetseid käske, seada suvandeid ja palju muud. Näiteks võivad need suvandid käskida tööriistal väljastada lisateavet, lugeda andmeid määratud allikast või saata väljund teatud asukohta.

Üldiselt edastatakse argumendid CLI tööriistadele sõltuvalt teie operatsioonisüsteemist erinevalt.

• Unixi sarnane: - millele järgneb kiri, nagu -hvõi -- millele järgneb sõna nagu --help
• Windows: / millele järgneb kas täht või sõna, nagu /help

Need erinevad lähenemisviisid eksisteerivad ajaloolistel põhjustel. Paljud Unixi-sarnaste süsteemide programmid toetavad nii ühe- kui ka kahekriipsu tähistust. Ühe kriipsuga tähistust kasutatakse enamasti ühetäheliste valikute puhul, samas kui topeltkriipsud kujutavad endast loetavamat valikute loendit, mis on eriti kasulik keeruliste valikute puhul, mis peavad olema selgesõnalisemad.

Pidage meeles, et nii argumendi nimi kui ka tähendus on programmile omased – puudub üldine määratlus, välja arvatud mõned tavalised kokkulepped, nagu --help lisateabe saamiseks tööriista kasutamise kohta. Pythoni skripti arendajana otsustate teie, millised argumendid helistajale esitada ja mida nad teevad. See nõuab korralikku hindamist.

Kui teie saadaolevate argumentide loend kasvab, muutub teie kood nende täpseks sõelumiseks keerukamaks. Õnneks on Pythonis saadaval mitmeid teeke, mis aitavad teid selles. Käsitleme mõnda kõige levinumat lahendust, mis ulatuvad isetegemisest sys.argv, "teie heaks tehtud" lähenemisviisile argparse.

Käsurea argumentide käsitlemine Pythoniga

Python 3+ ja ümbritsev ökosüsteem toetavad käsurea argumentide käsitlemiseks mitmeid erinevaid viise. Seal on palju teegid, mis paeluvad käsurea argumentide sõelumist.

Sisseehitatud viis on kasutada sys moodul. Nimede ja selle kasutamise osas on see otseselt seotud C-teegiga (libc).

Teine viis on getopt moodul, mis käsitleb nii lühikesi kui pikki valikuid, sealhulgas parameetrite väärtuste hindamist.

. argparse moodul, mis on tuletatud optparse moodul (saadaval kuni Python 2.7).

. docopt moodul, mis on saadaval GitHubil, võimaldab ka sama funktsionaalsust.

Hiljuti absl ka raamatukogu kui vahend asendamiseks on kogunud tuure optparse ja getopt().

Kõigil neil viisidel on oma plussid ja miinused, seega tasub iga meetodit hinnata, et näha, milline neist teie vajadustele kõige paremini sobib.

Süsteemi moodul

See on põhimoodul, mida on Pythoniga juba algusaegadest saati tarnitud. See läheneb väga sarnasele C-teegi kasutamisele argc/argv argumentidele juurde pääseda. The sys moodul rakendab käsurea argumendid lihtsas loendistruktuuris nimega sys.argv.

Iga loendi element esindab ühte argumenti. Esimene üksus loendis, sys.argv[0], on Pythoni skripti nimi. Ülejäänud loendi elemendid, sys.argv[1] et sys.argv[n], on käsurea argumendid 2 kuni n.

Argumentide eraldusmärgina kasutatakse tühikut. Argumendi väärtused, mis sisaldavad tühikut, peavad olema ümbritsetud jutumärkidega, et neid õigesti sõeluda sys.

Samaväärne argc on vaid loendis olevate elementide arv. Selle väärtuse saamiseks kasutage Pythonit len() operaator. Näitame seda hiljem koodinäites.

Esimese CLI argumendi trükkimine

Selles esimeses näites määrab meie skript selle kutsumise viisi. Seda teavet hoitakse esimeses käsureaargumendis, indekseeritud 0-ga. Allolev kood näitab, kuidas saate oma Pythoni skripti nime.

import sys

print("The script has the name %s" % (sys.argv[0])

Salvestage see kood faili nimega arguments-program-name.pyja seejärel helistage sellele, nagu allpool näidatud. Väljund on järgmine ja sisaldab failinime, sealhulgas selle täielikku teed:

$ python arguments-program-name.py
The script has the name arguments-program-name.py
$ python /home/user/arguments-program-name.py
The script has the name /home/user/arguments-program-name.py

Nagu näete ülaltoodud teisest kõnest, ei saa me mitte ainult Pythoni faili nime, vaid ka kogu selle kutsumiseks kasutatava tee.

Argumentide arvu loendamine

Selles teises näites loendame lihtsalt sisseehitatud käsurea argumentide arvu len() meetod. sys.argv on nimekiri, mida peame uurima. Allolevas koodis saame argumentide arvu ja lahutame seejärel 1, kuna üks neist argumentidest (st esimene) on alati määratud faili nimeks, mis pole meile alati kasulik. Seega on kasutaja poolt edastatud argumentide tegelik arv len(sys.argv) - 1:

import sys


arguments = len(sys.argv) - 1
print ("The script is called with %i arguments" % (arguments))

Salvestage see fail ja nimetage see arguments-count.py. Mõned näited selle skripti kutsumise kohta on toodud allpool. See hõlmab kolme erinevat stsenaariumi:

• Kõne ilma täiendavate käsureaargumentideta
• Kõne kahe argumendiga
• Kahe argumendiga kõne, kus teine ​​on tühikut sisaldav tsiteeritud string

$ python arguments-count.py
The script is called with 0 arguments
$ python arguments-count.py --help me
The script is called with 2 arguments
$ python arguments-count.py --option "long string"
The script is called with 2 arguments

Itereerimine argumentide kaudu

Meie kolmas näide väljastab kõik Pythoni skriptile saadetud argumendid, välja arvatud programmi nimi. Seetõttu vaatame läbi käsurea argumendid, alustades tähega teine loendi element. Tuletage meelde, et see on indeks 1, kuna loendid põhinevad Pythonis nullil:

import sys


arguments = len(sys.argv) - 1


position = 1
while (arguments >= position):
    print ("Parameter %i: %s" % (position, sys.argv[position]))
    position = position + 1

Allpool kutsume oma koodi, mis salvestati faili arguments-output.py. Nagu meie eelmise näite puhul, illustreerib väljund kolme erinevat kõnet:

• Kõne ilma argumentideta
• Kõne kahe argumendiga
• Kahe argumendiga kõne, kus teine ​​argument on tühikut sisaldav tsiteeritud string

$ python arguments-output.py
$ python arguments-output.py --help me
Parameter 1: --help
Parameter 2: me
$ python arguments-output.py --option "long string"
Parameter 1: --option
Parameter 2: long string

Pidage meeles, et tsiteeritud stringi näite näitamise mõte on see, et parameetrid on tavaliselt eraldatud tühikuga, kui need on ümbritsetud jutumärkidega.

Abseili lipud (absl)

Abseili lippude teek on mõeldud käsurea argumentide toomiseks tootmisse koos hajutatud käsureaargumentidega. Kui moodul kasutab käsurea lippe ja imporditakse teise moodulisse – teise moodulisse impordib ka lippeja saab neid töödelda, edastades need imporditud moodulisse.

See muudab moodulite vahel jagatud keerukad käsureaargumendid lihtsamaks ja vähem sõnasõnaliseks.

Lisaks võimaldab teek määratleda argumentide vaikeväärtused, kirjeldused ja andmetüübid, nii et täiendavad kontrollid ja teisendused pole vajalikud.

from absl import flags
import sys


flags.DEFINE_string('name', 'User', 'The name of the user.')


FLAGS = flags.FLAGS
FLAGS(sys.argv)

print(f"Hello {FLAGS.name}!")

Toetatud andmetüübid on järgmised:

• DEFINE_integer()
• DEFINE_string()
• DEFINE_bool()
• DEFINE_enum()
• DEFINE_list()
• DEFINE_float()

Sama hästi kui DEFINE_multi_integer(), DEFINE_multi_string() ja DEFINE_multi_enum() mitme argumendiga sisendiks. Lisaks jooksmine --help, --helpfulljne printida olemasolevad lipud ja nende kirjeldused, erinevates formaatides.

Teek võimaldab teil määratleda ka valideerimisi – nii vahemiku osas, nagu näiteks täisarvupõhised väärtused, millel on upper_bound or lower_bound see on vastuvõetav ja kasutab väärtuste kontrollimiseks suvalisi meetodeid:

def validate_name(value):
    return len(value) > 15

flags.register_validator('name',
                         validate_name,
                         message='Name is over 15 characters long.',
                         flag_values=FLAGS)

Nende kogumine konkreetseks näiteks:

from absl import flags
import sys

flags.DEFINE_string('name', 'User', 'The name of the user.')
flags.DEFINE_integer('tasks', 0, 'The number of tasks a user has.', lower_bound=0)

FLAGS = flags.FLAGS
FLAGS(sys.argv)

print(f"{FLAGS.name} has {FLAGS.tasks} tasks to work on.")

$ python flags.py --name=John --tasks=5
John has 5 tasks to work on.

$ python flags.py --name=John --tasks=-1

Traceback (most recent call last):
  File "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/absl/flags/_flag.py", line 180, in _parse
    return self.parser.parse(argument)
  File "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/absl/flags/_argument_parser.py", line 168, in parse
    raise ValueError('%s is not %s' % (val, self.syntactic_help))
ValueError: -1 is not a non-negative integer
...

Argparse moodul

. argparse moodul on saadaval alates Python 3.2 versioonist ja selle täiustus optparse moodul, mis eksisteerib kuni Python 2.7. Pythoni dokumentatsioon sisaldab API kirjeldust ja õpetust, mis hõlmab kõiki meetodeid üksikasjalikult.

Moodul pakub standardiseeritud väljundiga käsurea liidest, samas kui kaks eelmist lahendust jätavad suure osa tööst teie kätesse. argparse võimaldab kontrollida fikseeritud ja valikulisi argumente koos nime kontrollimisega kas lühikese või pika stiilina. Vaikimisi valikulise argumendina sisaldab see -h, koos selle pika versiooniga --help. Selle argumendiga kaasneb vaikimisi abiteade, mis kirjeldab aktsepteeritud argumente.

Allolev kood näitab parseri lähtestamist ja allolev väljund, mis näitab põhikõnet, millele järgneb abisõnum. Erinevalt eelmistes näidetes kasutatud Pythoni kutsetest pidage meeles Python 3 kasutamist järgmiste näidetega:

import argparse


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

$ python3 arguments-argparse-basic.py 
$ python3 arguments-argparse-basic.py -h
usage: arguments-argparse-basic.py [-h]

optional arguments:
  -h, --help  show this help message and exit
$ python3 arguments-argparse-basic.py --verbose
usage: arguments-argparse-basic.py [-h]
arguments-argparse-basic.py: error: unrecognized arguments: --verbose

Järgmises etapis lisame oma kasutajatele mõeldud abisõnumile kohandatud kirjelduse. Sel viisil parseri initsialiseerimine võimaldab lisateksti. Allolev kood salvestab kirjelduse text muutuja, mis on selgesõnaliselt antud argparse klass kui description parameeter. Kui helistate sellele allpool olevale koodile, näete, kuidas väljund välja näeb:

import argparse


text = 'This is a test program. It demonstrates how to use the argparse module with a program description.'


parser = argparse.ArgumentParser(description=text)
parser.parse_args()

$ python3 arguments-argparse-description.py --help
usage: arguments-argparse-description.py [-h]

This is a test program. It demonstrates how to use the argparse module with a
program description.

optional arguments:
  -h, --help  show this help message and exit

Viimase sammuna lisame valikulise argumendi nimega -V, millel on vastav pika stiili argument --version. Selleks kasutame meetodit add_argument() mida kutsume kolme parameetriga (kuvatakse --version, ainult):

• Parameetri nimi: --version
• Parameetri abitekst: help="show program version"
• Toiming (ilma lisaväärtuseta): action="store_true"

Selle lähtekood kuvatakse allpool. Argumentide lugemine kutsutavasse muutujasse args tehakse kaudu parse_args() meetodist parser objektiks. Pange tähele, et esitate nii lühikese kui ka pika versiooni ühe kõnega. Lõpuks kontrollite, kas atribuudid args.V or args.version on seatud ja väljastavad versiooniteate:

import argparse


parser = argparse.ArgumentParser()
parser.add_argument("-V", "--version", help="show program version", action="store_true")


args = parser.parse_args()


if args.version:
    print("This is myprogram version 0.1")

$ python3 arguments-argparse-optional.py -V
This is myprogram version 0.1
$ python3 arguments-argparse-optional.py --version
This is myprogram version 0.1

. --version argument ei nõua käsureal väärtuse andmist. Seetõttu määrasime tegevuse argumendiks "store_true". Muudel juhtudel võite vajada täiendavat määratud väärtust, näiteks kui määrate teatud helitugevuse, kõrguse või laiuse. Seda on näidatud järgmises näites. Vaikimisi pidage meeles, et kõiki argumente tõlgendatakse stringidena:

import argparse


parser = argparse.ArgumentParser()


parser.add_argument("--width", "-w", help="set output width")


args = parser.parse_args()


if args.width:
    print("Set output width to %s" % args.width)

Siin näitame, mis juhtub erinevate argumentide väärtuste esitamisel. See hõlmab nii lühikest kui ka pikka versiooni ning abisõnumit:

$ python3 arguments-argparse-optional2.py -w 10
Set output width to 10
$ python3 arguments-argparse-optional2.py --width 10
Set output width to 10
$ python3 arguments-argparse-optional2.py -h
usage: arguments-argparse-optional2.py [-h] [--width WIDTH]

optional arguments:
  -h, --help            show this help message and exit
  --width WIDTH, -w WIDTH
                        set output width

Getopti moodul

Nagu olete võib-olla varem märganud, sys moodul jagab käsurea stringi ainult üksikuteks tahkudeks. Python getopt moodul läheb natuke kaugemale ja laiendab sisendstringi eraldamist parameetrite valideerimisega. Põhinedes getopt C-funktsioon võimaldab nii lühikesi kui pikki valikuid, sealhulgas väärtuse määramist.

Praktikas nõuab see sys moodul sisendandmete korrektseks töötlemiseks. Selleks peavad mõlemad sys moodul ja getopt moodul tuleb eelnevalt laadida. Järgmisena eemaldame sisendparameetrite loendist loendi esimese elemendi (vt allolevat koodi) ja salvestame ülejäänud käsurea argumentide loendi muutujas nimega argument_list:

import getopt, sys


full_cmd_arguments = sys.argv


argument_list = full_cmd_arguments[1:]

print argument_list

Argumendid sees argument_list saab nüüd sõeluda kasutades getopts() meetod. Kuid enne seda peame ütlema getopts() millised parameetrid kehtivad. Need on määratletud järgmiselt:

short_options = "ho:v"
long_options = ["help", "output=", "verbose"]

See tähendab, et meie arvates on need argumendid kehtivad koos lisateabega:

------------------------------------------
long argument   short argument  with value
------------------------------------------
--help           -h              no
--output         -o              yes
--verbose        -v              no
------------------------------------------

Võib-olla olete märganud, et o lühikest varianti jätkas koolon, :. See ütleb getopt et sellele valikule tuleks määrata väärtus.

See võimaldab meil nüüd argumentide loendit töödelda. The getopt() meetod nõuab kolme parameetri seadistamist – tegelike argumentide loendit argv, samuti kehtivad lühikesed ja pikad valikud (näidatud eelmises koodilõigul).

Meetodikutset ennast hoitakse try-catch-lauses, et katta hindamise ajal esinenud vigu. Erand tehakse juhul, kui avastatakse argument, mis ei kuulu eelnevalt määratletud loendisse. Pythoni skript prindib veateate ekraanile ja väljub veakoodiga 2:

try:
    arguments, values = getopt.getopt(argument_list, short_options, long_options)
except getopt.error as err:
    
    print (str(err))
    sys.exit(2)

Lõpuks salvestatakse vastavate väärtustega argumendid kahes nimetatud muutujas arguments ja values. Nüüd saate neid muutujaid oma koodis hõlpsasti hinnata. Saame kasutada a for-silmus, et korrata tunnustatud argumentide loendit, üks kirje järgmise järel.

for current_argument, current_value in arguments:
    if current_argument in ("-v", "--verbose"):
        print ("Enabling verbose mode")
    elif current_argument in ("-h", "--help"):
        print ("Displaying help")
    elif current_argument in ("-o", "--output"):
        print (("Enabling special output mode (%s)") % (current_value))

Allpool näete selle koodi täitmise väljundit. Näitame, kuidas programm reageerib nii kehtivate kui ka kehtetute programmiargumentidega:

$ python arguments-getopt.py -h
Displaying help
$ python arguments-getopt.py --help
Displaying help
$ python arguments-getopt.py --output=green --help -v
Enabling special output mode (green)
Displaying help
Enabling verbose mode
$ python arguments-getopt.py -verbose
option -e not recognized

Viimane kõne meie programmile võib alguses tunduda segane. Selle mõistmiseks peate teadma, et kiirkirjasuvandeid (mida mõnikord nimetatakse ka lippudeks) saab kasutada koos ühe kriipsuga. See võimaldab teie tööriistal paljusid valikuid hõlpsamini aktsepteerida. Näiteks helistades python arguments-getopt.py -vh on sama mis helistamine python arguments-getopt.py -v -h. Nii et viimases ülaltoodud kõnes getopt moodul arvas, et kasutaja üritas läbida -e valikuna, mis on kehtetu.

Järeldus

Selles artiklis näitasime Pythonis käsurea argumentide toomiseks palju erinevaid meetodeid, sealhulgas kasutamist sys, getoptja argparse. Nende moodulite funktsionaalsus on erinev, mõned pakuvad palju rohkem kui teised. sys on täielikult paindlik, samas kui mõlemad getoptja argparse nõuavad mingit struktuuri. Seevastu need hõlmavad enamikku keerulisest tööst, mida sys jätab teie otsustada. Pärast esitatud näidete läbitöötamist peaksite suutma kindlaks teha, milline moodul sobib teie projektiga kõige paremini.

Selles artiklis me ei rääkinud muudest lahendustest, nagu docopts moodul, me just mainisime seda. See moodul järgib täiesti teistsugust lähenemist ja seda selgitatakse üksikasjalikult ühes järgmistest artiklitest.

viited