De beste manier om opdrachtregelinterfaces te maken in Python

Hoe eenvoudig te gebruiken, intuïtieve Python-programma's te schrijven

Opdrachtregelinterface (CLI):

Een opdrachtregelinterface of een interpreter van de opdrachttaal, ook bekend als een opdrachtregelinterface, een console-gebruikersinterface en een karaktergebruikersinterface, is een manier om te communiceren met een computerprogramma waarbij de gebruiker een opdracht aan het programma geeft in de vorm van opeenvolgende tekstregels.

U kunt uw programma krachtig en interactief maken door een opdrachtregelinterface (CLI) te maken. Met een CLI kunt u opdrachtregelargumenten opnemen (informatie die volgt op de naam van het programma op de opdrachtregel van het besturingssysteem) om extra functies aan uw programma toe te voegen, waardoor uw code zowel gebruiksvriendelijk als flexibel is. Afhankelijk van het programma kunnen deze argumenten worden gebruikt om extra functies toe te voegen, zoals het weergeven van helpdocumentatie, het specificeren van een uitvoerbestand of het inschakelen van testfuncties die voor normaal gebruik mogelijk fouten bevatten.

Toen ik voor het eerst begon te programmeren in Python, verzamelde ik bijna uitsluitend gebruikersinvoer interactief op deze manier:

def main ():
    first = input ("Voer uw voornaam in:")
    last = input ("Voer uw achternaam in:")
    print (eerste + '' + laatste)

Hoewel deze code prima is voor eenvoudige scripts, is deze om een ​​paar redenen problematisch. Om te beginnen is deze code niet flexibel. Wanneer een gebruiker dit programma uitvoert, zijn deze beperkt tot slechts één set gedefinieerde regels. Wat als ik bijvoorbeeld in plaats van naar de console af te drukken, uitvoer naar een tekstbestand wil loggen? Hoe kom ik als nieuwe gebruiker erachter hoe het programma werkt? Als ontwikkelaar kunt u een opdrachtregelinterface maken om een ​​oplossing voor deze problemen te bieden.

Belangrijke overwegingen

Bij het maken van een CLI is het belangrijk om rekening te houden met het volgende:

  1. Vereiste argumenten: welke argumenten zijn absoluut noodzakelijk om het programma te kunnen uitvoeren? Als ik bijvoorbeeld een programma schrijf om een ​​webpagina te schrapen, kan een verplicht argument het domein van de pagina zijn.
  2. Documentatie: Het is belangrijk om de functie van elke optie en elk argument op te schrijven, zodat een nieuwe gebruiker kan achterhalen hoe uw programma werkt.
  3. Handel foutgevallen af: laat de gebruiker precies weten wat er fout is gegaan en waar
  4. Runtimestatus: als de taak niet onmiddellijk wordt voltooid, moet u de huidige voortgang afdrukken

Argumenten lezen met behulp van argparse

Argparse is een Python-standaardbibliotheekmodule voor het parseren van opdrachtregelargumenten. Jij als programmeur kunt de argumenten definiëren die moeten worden gebruikt en argparator zal uitzoeken hoe deze uit sys.argv kunnen worden ontleed (een lijst in Python, die de opdrachtregelargumenten bevat die aan het script zijn doorgegeven, lees hier meer). Argparse genereert ook automatisch help- en gebruiksmeldingen en geeft fouten weer wanneer gebruikers het programma ongeldige argumenten geven. Het is heel eenvoudig te gebruiken en maakt het heel gemakkelijk om intuïtieve CLI's te schrijven.

Maak om te beginnen een nieuw bestand met de naam test_cli.py en importeer de module en initialiseer een nieuwe parser:

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

Voer nu de code uit met de - help-optie:

python3 test_cli.py --help

Je zou een leuk standaard help-bericht als dit moeten ontvangen:

gebruik: test_cli.py [-h]
optionele argumenten:
    -h, - help dit helpbericht weergeven en afsluiten

Gefeliciteerd, je hebt zojuist je eerste opdrachtregelinterface gemaakt!

Laten we nu een welkomstbericht toevoegen om uw gebruiker in het kort te laten weten wat het programma doet:

welcome = "Oefenen met het creëren van interactieve opdrachtregelinterfaces"
parser = argparse.ArgumentParser (description = welcome)
parser.parse_args ()

Voer het programma nu uit met de vlag -h. Je zou je mooie welkomstbericht moeten kunnen zien.

Laten we nu iets nuttigers doen.

Argumenten toevoegen

Stel dat we een programma schrijven om een ​​webpagina te schrapen. Enkele argumenten die we nodig kunnen hebben, zijn het domein van de webpagina --domain of -d, de optie om de output naar een out-bestand te loggen --ofile of -o, en misschien de optie om een ​​specifiek aantal outputregels naar de console af te drukken --lijnen of -l. Voor dit voorbeeld maken we het domeinargument vereist, terwijl de ofile- en line-argumenten optioneel zijn.

We kunnen eenvoudig aanvullende argumenten toevoegen aan een CLI voor argumenten door .add_argument te gebruiken waarmee we gebruiksdetails kunnen definiëren. We kunnen het vereiste argument --domein als zodanig toevoegen:

parser.add_argument ('- domain', '-d', vereist = True, help = 'domeinnaam van de website die u wilt schrapen. d.w.z. "https://ahadsheriff.com"')

Voer nu het programma uit met het argument -h om de documentatie te bekijken die u hebt geschreven!

Aangezien --domain een verplicht argument is, probeer het programma zonder vlaggen uit te voeren en u wordt getrakteerd op het volgende bericht:

gebruik: test_cli.py [-h] --domein DOMAIN
test_cli.py: error: de volgende argumenten zijn vereist: --domain / -d

Het werkt!

Tijd om onze aanvullende argumenten toe te voegen met argparse. Als u niet opgeeft welke argumenten vereist zijn, gaat Argparse ervan uit dat deze optioneel zijn. Je kunt ook het type argument instellen, voor --lines nemen we een geheel getal. Er zijn andere nuttige opties die u kunt instellen voor .add_argument, zoals action =, waarover u hier meer kunt lezen in de officiële argparerdocumentatie.

parser.add_argument ('- ofile', '-o', help = 'definieer uitvoerbestand om resultaten van stdout op te slaan, d.w.z. "output.txt"')
parser.add_argument ('- lines', '-l', help = 'aantal uitvoerregels om af te drukken naar de console "', type = int)

Test nu uw code om te controleren of alles goed werkt. Een eenvoudige manier om dit te doen is door de waarden van de argumenten op te slaan als variabelen en deze waarden vervolgens af te drukken.

args = parser.parse_args ()
domein = args.domain
ofile = args.ofile
lines = args.lines
print ("domain:", domein)
print ("output file:", ofile)
print ("lines:", lines)

Opmerking: optionele argumenten worden standaard opgeslagen als Geen wanneer ze niet worden gebruikt.

Hier is al mijn code:

Ten slotte

Hoewel dit geen uitgebreide handleiding is, zou het voldoende moeten zijn om u aan het denken te zetten over opdrachtregelinterfaces en de gebruikerservaring van uw scripts te verbeteren. Wat is tenslotte het punt van code als niemand het kan gebruiken. Als u aanvullende aanbevelingen, tips of bronnen heeft, deel dit dan in de reacties!

Bedankt voor het lezen! Als je het leuk vond, sla dan die volgknop kapot :) Kijk ook eens op mijn website, Twitter, LinkedIn en Github.