Grunderna för att analysera kommandoradsargument i Python

Kommandoradsapplikationer är en av de äldsta och mest använda apparna. Om du är en erfaren Linux-användare kan du knappast ha använt GUI-verktyg istället för kommandoradsverktyg för att göra samma uppgift. Anaconda, pakethanteraren för python, har till exempel kommandoradsverktyg med namnet Conda och GUI-verktyg som heter anaconda-navigator.

Det som gör kommandoradsapplikationen populär bland utvecklare är att de förbrukar mycket få resurser jämfört med dess GUI-motsvarighet och ger bättre prestanda.

Python är ett enkelt och kraftfullt språk för att bygga kommandoradsapplikationer. Det ger massor av bibliotek som redan har skrivits av många bra programmerare, vilket gör vår uppgift enklare eftersom vi inte behöver skriva om samma kod.

I den här självstudien kommer jag att presentera pythons Argparse-bibliotek för dig, som kan analysera argument för kommandoradsapplikationerna. Detta är användbart för att bygga bra kommandoradsgränssnitt. För att följa denna handledning rekommenderas att den senaste versionen av python installeras. Vi har också en steg-för-steg-handledning för att uppdatera python till den senaste versionen i Linux.

Introduktion

Argument Parsing är ett viktigt koncept som vi måste använda för att bygga kraftfulla och användarvänliga kommandoradsgränssnitt. Om du har använt kommandoradsapplikationer tidigare kanske du har märkt att vi kan lägga till argument i kommandoradsapplikationerna för att konfigurera verktygets alternativ.

Till exempel om du har använt ls kommando i Linux, som används för att lista aktuella arbetskatalogobjekt, kanske du har sett ut något liknande, som visas i bilden nedan.

Som du kan se på bilden listas objekten i den aktuella katalogen. Vi kan också använda ls kommandot mer fördelaktigt genom att ge det ett argument som jag gjorde i följande kommando.

ls -a

Nu när du skriver detta kommando i terminalen kommer det att lista alla objekt som finns i den aktuella arbetskatalogen, inklusive de dolda objekten. Som du kan se kan vi enkelt ange alternativ till kommandot på ett vänligt sätt genom att tillhandahålla argument på kommandot. Det är här argumenten spelar in. De gör kommandoradsapplikationerna mer användbara och vänliga.

Du kanske undrar när och hur du lägger till kommandoradsargument i dina applikationer. Tänk dig att du bygger ett program som behöver en användarinmatning av filnamnet som applikationen kommer att behandla.

Vi kan göra det på två sätt:

• genom att uppmana användaren att lägga till filnamnet eller
• genom att ge användaren att lägga till filnamnet som ett argument i kommandot.

Det första tricket är bra, men det andra är mer användbart eftersom användaren kan ge alla alternativ i ett kommando, vilket gör det mer användarvänligt.

Python innehåller ett fantastiskt bibliotek med namnet "argparse", vilket är användbart för att skapa och analysera kommandoradsargument och kan bygga kraftfulla kommandoradsgränssnitt för användarna mycket enkelt. Låt oss ta ett djupt dyk in i pythons argparse-bibliotek.

Argparse bibliotek

De argparse bibliotek är ett enkelt och användbart sätt att analysera argument medan man bygger kommandoradsapplikationer i python. Även om det finns andra argument som analyserar bibliotek som optparse, getopt, etc., de argparse biblioteket är officiellt det rekommenderade sättet att analysera kommandoradsargument.

Det finns också i pythons standardbibliotek, så vi behöver ingen manuell konfiguration. De argparse biblioteket har byggts med hjälp av optparse bibliotek av python, men argparse är mer användbart och utvecklarvänligt än optparse bibliotek.

Praktisk demonstration av Argparse

Låt oss se en praktisk demo av hur man använder argparse-biblioteket för att skapa ett enkelt kommandoradsgränssnitt. Detta program accepterar en sökväg och kontrollerar om sökvägen existerar eller inte, och om den existerar, skriv sedan ut om det är en fil eller en katalog.

import os import argparse parser = argparse.ArgumentParser ('description = "Path Existence Checker") analysator.add_argument ("- path", help = "mata in en sökväg för att kontrollera om den finns") args = parser.parse_args () input_path = args.väg om os.väg.isdir (input_path): print ("The Path Exists and it is a directory") elif os.väg.isfile (input_path): print ("The path Exists and it is a file") annat: print ("The path existerar inte")

När vi kör programmet ovan kan vi kontrollera om sökvägen finns eller inte.

Du kan också använda -h argument med programmet, vilket är standardargumentet för att visa hjälpmeddelanden.

Låt mig förklara för dig hur programmet ovan fungerar. Under de första två raderna importerade vi de moduler som vi kommer att behöva i programmet. De os modulen har importerats för att kontrollera om sökvägen finns eller inte, och är det en fil eller en katalog. Om du vill lära dig mer om os modul, kan du hänvisa till vår guide om att arbeta med os i python.I nästa rad importerade vi det argparse-biblioteket som krävs för att skapa och analysera argument. På den tredje raden skapar vi ett parserobjekt med hjälp av ArgumentParser-klassen i argparse-biblioteket. Denna klass accepterar också en valfri parameterbeskrivning som kommer att visas i hjälpmeddelandet.I nästa rad har vi skapat ett argument med namnet sökväg med metoden add_argument () för parserobjektet och ger detaljerna i hjälpparametern som kommer att visas i hjälpmeddelandet som vi har sett i utdata tidigare.Därefter analyserar vi argumenten med parse_args () -metoden för parserobjektet och får tillgång till användarens inmatningsväg som ett argument. Vi fick den sökväg som användaren matade in i argumentet och använde den sedan med os-modulen för att kontrollera om det är en fil eller mapp. Om det inte är bland de två kommer det att skrivas ut att sökvägen inte finns.

Anpassning

Låt oss se några av de anpassningar som vi kan göra för vårt kommandoradsgränssnitt med hjälp av argparse-biblioteket.

Hjälp för anpassad användning

När vi kör demoprogrammet som vi skapade tidigare med -h parameter, får vi programmets hjälp som den output som argparse-biblioteket genererade. Om du märker hjälpmeddelandet finns det en användningshjälp i den översta raden som visar hur vi använder det.I vårt demoprogram har vi fått standardanvändningshjälpen. Vi kan fortfarande enkelt anpassa det genom att använda användarparametern medan vi skapar parserobjektet med ArgumentParser () -klassen. Titta på koden nedan, som ska modifieras i vårt demoprogram.

parser = argparse.ArgumentParser (beskrivning = "Path Existence Checker", användning = "cla.py path ")

Här är resultatet:

Som vi kan se i utdata har användningshjälpen ändrats till den som vi specificerar i ArgumentParser () klassanvändningsparameter.

Anpassa argument

Vi kan också använda Argparse-biblioteket för att anpassa argumenten som om argumenten krävs eller inte, vilket ger ett argument ett standardvärde.

Lägger till standardvärde

Vi kan ge argumenten ett standardvärde med hjälp av standardparametern till add_argument () metod. Se till exempel nedanstående kod.

import os import argparse parser = argparse.ArgumentParser (beskrivning = "Path Existence Checker", användning = "cla.py path ") parser.add_argument ("- path", help = "mata in en sökväg för att kontrollera om den finns", standard = "filnamn.txt ") args = parser.parse_args () input_path = args.sökväg om input_path == None: exit () elif os.väg.isdir (input_path): print ("The Path Exists and it is a directory") elif os.väg.isfile (input_path): print ("The path Exists and it is a file") annat: print ("The path existerar inte")

När vi kör programmet ovan utan något argument får vi utmatningen nedan. Som visas i utdata kontrollerar programmet sökvägen filnamn.Text, som vi ställer in i standardparametern.

Ställa krav på argument

Vi kan också använda Argparse-biblioteket för att ställa in argumentets krav, dvs.e., om argumenten kommer att vara nödvändiga eller inte. För att göra det måste vi använda den önskade parametern, som visas i nedanstående kod.

import os import argparse parser = argparse.ArgumentParser (beskrivning = "Path Existence Checker", användning = "cla.py path ") parser.add_argument ("- path", help = "mata in en sökväg för att kontrollera om den finns", standard = "filnamn.txt ", krävs = True) args = parser.parse_args () input_path = args.sökväg om input_path == None: exit () elif os.väg.isdir (input_path): print ("The Path Exists and it is a directory") elif os.väg.isfile (input_path): print ("The path Exists and it is a file") annat: print ("The path existerar inte")

När du kör ovanstående kod utan några argument får du ett felmeddelande om att följande argument krävs.

Typ av argument

Vi kan också ställa in den datatyp som används i argumentet. Om vi ​​till exempel behöver sökvägen ska vi ge en strängdatatyp. Om en användare anger en datatyp som inte är en sträng kommer Argparser att ändra den till en sträng. För att ställa in standardtypen för ett argument, kör koden nedan.

import os import argparse parser = argparse.ArgumentParser (beskrivning = "Path Existence Checker", användning = "cla.py path ") parser.add_argument ("- path", help = "mata in en sökväg för att kontrollera om den finns", typ = str) args = parser.parse_args () input_path = args.sökväg om input_path == None: exit () elif os.väg.isdir (input_path): print ("The Path Exists and it is a directory") elif os.väg.isfile (input_path): print ("The path Exists and it is a file") annat: print ("The path existerar inte")

Produktion:

Slutsats

Detta är bara grunderna för att analysera argument med Argparse-biblioteket. Efter att ha gått igenom denna handledning rekommenderas att du läser den officiella dokumentationen för att utforska fler knep för att använda detta bibliotek. Du kanske också vill se inlägget om att använda inloggning i python, vilket är mycket användbart för att skriva stora applikationer och enkel felsökning.