Parsing är en process för att analysera en serie texter för att ta reda på vad programmet ska göra med de angivna kommandona. Texten är uppdelad i små bitar, så kallade tokens för att bygga den datastruktur som är känd för kompilatorn eller tolken. Utförandet resulterar i det avsedda resultatet i slutet. Python används ofta som ett språk för att enkelt analysera kommandorader. Den här guiden använder den här speciella modulen som levereras med Python, och den är känd som argparse. Det speciella med argparse är att det är ganska enkelt att använda, användarvänligt, tillgängligt med Python, och hjälper till att skapa kommandoradsgränssnitt med lätthet.

Följande guide visar hur man använder argparse i Ubuntu, med Python3, och se till att båda är lätt tillgängliga innan du går vidare. Om Python3 inte är tillgängligt kan det installeras med följande två kommandorader:

sudo apt-get-uppdatering
sudo apt-get install python3.6

Essential Syntax

Syftet med den här guiden är att beskriva kärnfunktionerna i argparse och hur man använder några av dess alternativ. Argparse kräver Python och ett anteckningsblock för att skriva dess kommandon. Ubuntu har en egen anteckningsbok som kallas "Textredigerare", som kan nås via Ubuntu-streck. Kommandona utförs via terminal.

1. Starta textredigeraren via Ubuntu Dash.
2. Skriv följande två rader som väsentliga koder. Första raden importerar argparse-modulen till kodavsnittet, medan den andra skapar ett argument-parser-objekt, som innehåller all information som krävs för att analysera kommandon till Python-datatyper. importera argparse
   parser = argparse.ArgumentParser ()
3. Använd följande kommando för att konvertera argumentsträngar till objekt. Vanligtvis instanseras objektet och tilldelas en variabel, men det är inte nödvändigt. parser.parse_args ()
4. Programmet kan köras i Linux-terminal via python3 med följande kommando. python3-skript.py

Visar appbeskrivningen

Appbeskrivningsparametern är att ange vad applikationen är avsedd för. När hjälpkommandot används med python-skriptet visas appbeskrivningen tillsammans med tillgängliga flaggor som ska användas i programmet.  Följande rad måste användas för att ange appbeskrivningen.

parser = argparse.ArgumentParser (beskrivning = 'appbeskrivning')

Visa beskrivningen i slutet (epilog)

Som beskrivning kan epilogen visas i slutet med epilog-parametern. Liksom beskrivningen måste den också specificeras inom argumentParser-funktionen.

Hur man använder argument

Argument definieras med add_argument () fungera. Den specificerar vilka positionella argument / argument som ska användas med python-skriptet. Som standard accepterar programmet -help-flaggan som positionsargument, men mer kan läggas till med den ovan nämnda funktionen. Det finns många sätt att lägga till argument i applikationen.

Single Positional Argument

Det enda positionella argumentet ser till att programmet bara accepterar ett argument. I följande exempel anger det bld som argumentet; därför kan endast bld användas som ett positionellt argument när programmet körs. Om argumentet saknas kommer programmet att kasta ett fel med ett varningsmeddelande ”för få argument”. Det speciella med positionellt argument är att det inte behöver anges i terminalen när man ger argument till programmet.

parser.add_argument ("bld")

Positionsargument i en särskild typ

add_argument () tar inte bara ett argument utan också flera argument som framgår av följande exempel. Om flera argument tillhandahålls måste de formateras enligt följande. Det första argumentet definierar positionsargumentets namn, det andra är dess typ, vilket betyder att värdetypen accepteras som argumentet för programmet, det sista är för beskrivningen som bara visas när du använder hjälpflaggan.

I följande skärmdump visar det hur programmet vägrar att acceptera något icke-integrerat värde som positionsargument. Endast ett heltal kan skickas in här nu.

parser.add_argument ('bld', typ = int,
help = "ett heltal krävs")

Valfritt positionellt argument i en särskild typ

Följande kommandorad är densamma som ovan, förutom att det gör positionsargumentet valfritt med nargs-parametern; därmed kan användaren utelämna det när programmet körs. Om argumentet tillhandahölls måste det dock vara i rätt datatyp, annars fortsätter det inte att analyseras som vanligt.

parser.add_argument ('bld', type = int, nargs = '?'',
help = 'Detta fält är för valfritt heltal värde')

Valfritt argument i en särskild typ

Skillnaden mellan argument och positionsargument är positionellt argument behöver inte nämnas, medan argumentet måste nämnas som en flagga tillsammans med dess värde när programmet körs. Följande kommandorad innehåller exakt samma texter, förutom de ledande dubbla raderna (bindestreck). De betyder att argumentet är ett argument / en flagga som måste nämnas tillsammans med ett värde i den givna typen när programmet körs. Att göra användningen av argument obligatorisk krävs = Sant parametern kan användas i add_argument () -funktionen som ett av de andra argumenten. Som sagt ovan kommer ett fel att inte följa formatet.

Användning av korta argument

Korta argument fungerar på samma sätt som dess längre motsvarigheter. Den enda skillnaden är att det hjälper till att spara utrymme när man använder en stor mängd kommandorader eller när utvecklaren vill hålla kommandona städade och organiserade så mycket som möjligt. I följande exempel visar det hur programmet svarar på båda argumenten på samma sätt. När du använder de korta argumenten, se till att bara använda ett bindestreck eftersom det är standard i branschen.

Villkorliga argument

Villkorliga argument är mycket enkla att använda som argument i tidigare exempel. Den enda skillnaden i detta segment är att ange åtgärdsparametern. Det accepterar två värden, store_true, och store_false. Om åtgärdsparameter specificeras som store_true, tilldelas den varje gång flaggargumentet används i programmet med sant booleskt värde; det kan därför användas som ett villkorligt argument. Tillämpningarna av villkorliga argument är att skapa ett logiskt flöde av körningen baserat på användarens ingångar. Så användaren bestämmer vilken väg de vill gå och hur programmet flyter. De analyserade kommandona finns inuti namnet på utrymmet, det är därför det returnerar namnet på utrymmet () efter att programmet kördes.

parser.add_argument ('- bld', action = 'store_true',
hjälp = 'villkorligt argument')

Ange programmets namn

Framför allt anger inte programmets namn. I stället anges bara skriptfilens namn tillsammans med listan över accepterade argument. Fördelen med att använda programnamnet är att det gör programmet mer användarvänligt och oberoende av skriptets namn. Detta är ganska användbart om flera skriptfiler är involverade i körningen. Så det kommer inte att förvirra användaren med tvetydiga namn.

Följande två kommandorader måste användas för att få det att hända. På den första raden specificeras programmets namn med prog-parameter, medan den här specifika parametern kan användas som en variabel där programnamnet används, och när programmet körs ersätts prog-parametern med det värde som anges i argumentParser ( ) fungerar tillsammans med prog-parametern, vilket betyder "Nucuta App" i detta exempel. Dessutom är det viktigt att använda kommandot som % (prog) s i annat fall kommer tolkningen inte att lyckas.

parser = argparse.ArgumentParser (prog = 'Nucuta App')
parser.add_argument ('- bld', help = 'This% (prog) s it')

Hur man kontrollerar förhållandena och får körningen att flöda

Körningsflödet definieras med IF ELSE-klausuler. Dessa klausuler styr flödet av körning beroende på tillståndet och dess natur. I följande exempel tilldelas det angivna helvärdet till en variabel, bld, som är i arg-objekt. Sedan kontrolleras det mot ett fördefinierat värde för att kontrollera dess tillstånd. I det här exemplet, om det inmatade värdet är större än 10, körs det första uttalandet, om det inmatade värdet är lika med 10, körs det andra påståendet, om det inmatade värdet är mindre än 10, körs det senaste uttalandet. På samma sätt kan körningsflödet styras med lätthet. Som exemplet visar kan argumenten nås via objekt som returneras av funktionen parse_args () - args.

KONKLUSION

Med den här guiden är du redo att börja analysera alla kommandorader i python.  Lycka till