Grundlæggende om analyse af kommandolinjeargumenter i Python

Kommandolinjeapplikationer er en af de ældste og mest anvendte typer apps. Hvis du er en erfaren Linux-bruger, har du muligvis næppe brugt GUI-værktøjer i stedet for kommandolinjeværktøjer til at udføre den samme opgave. For eksempel har Anaconda, pakkehåndteringen til python, kommandolinjeværktøjer med navnet Conda og GUI-værktøj med navnet anaconda-navigator.

Det, der gør Command Line-applikationen populær blandt udviklere, er at de bruger meget få ressourcer i forhold til dets GUI-modstykke og giver bedre ydeevne.

Python er et simpelt og kraftfuldt sprog til opbygning af kommandolinjeapplikationer. Det giver masser af biblioteker, der allerede er skrevet af mange store programmører, hvilket gør vores opgave lettere, da vi ikke behøver at omskrive den samme kode.

I denne vejledning vil jeg præsentere pythons Argparse-bibliotek for dig, som kan analysere argumenter for kommandolinjeapplikationerne. Dette er nyttigt til opbygning af store kommandolinjegrænseflader. For at følge denne vejledning anbefales det at have den nyeste version af python installeret. Vi har også en trinvis vejledning i opdatering af python til den nyeste version i Linux.

Introduktion

Argument Parsing er et vigtigt koncept, vi skal bruge til at opbygge kraftfulde og brugervenlige kommandolinjegrænseflader. Hvis du har brugt kommandolinjeapplikationer tidligere, har du muligvis bemærket, at vi kan tilføje argumenter til kommandolinjeapplikationerne for at konfigurere værktøjets muligheder.

For eksempel, hvis du har brugt ls kommando i Linux, som bruges til at liste de aktuelle arbejdsmapper, kan du have set output noget lignende, som vist i nedenstående billede.

Som du kan se på billedet, viser det elementerne i den aktuelle mappe. Vi kan også bruge ls kommando mere fordelagtigt ved at give det et argument, som jeg gjorde i den følgende kommando.

ls -a

Når du nu skriver denne kommando i terminalen, viser den alle de emner, der er til stede i den aktuelle arbejdsmappe, inklusive de skjulte emner. Som du kan se, ved at give argumenter på kommandoen, kan vi nemt angive indstillinger til kommandoen på en venlig måde. Det er her, argumenter spiller ind. De gør kommandolinjeapplikationerne mere nyttige og venlige.

Du undrer dig måske over, hvornår og hvordan du tilføjer kommandolinjeargumenter i dine applikationer. Forestil dig, at du bygger et program, der har brug for et brugerinput af det filnavn, som applikationen vil behandle.

Vi kan gøre det på to måder:

ved at bede brugeren om at tilføje filnavnet eller
ved at give brugeren at tilføje filnavnet som et argument til kommandoen.

Det første trick er godt, men det andet er mere nyttigt, da brugeren kan give alle mulighederne i en kommando, hvilket gør det mere brugervenligt.

Python inkluderer et stort bibliotek med navnet "argparse", som er nyttigt til oprettelse og parsing af kommandolinjeargumenter og kan oprette kraftige kommandolinjegrænseflader til brugerne meget let. Lad os tage et dybt dyk ind i pythons argparse bibliotek.

Argparse bibliotek

Det argparse bibliotek er en nem og nyttig måde at analysere argumenter på, mens man bygger kommandolinjeapplikationer i python. Selvom der er andre argumenter, der analyserer biblioteker som optparse, getopt, etc., det argparse bibliotek er officielt den anbefalede måde til at analysere kommandolinjeargumenter.

Det er også tilgængeligt i pythons standardbibliotek, så vi har ikke brug for nogen manuel konfiguration. Det argparse biblioteket er bygget ved hjælp af optparse bibliotek af python, men argparse er mere nyttigt og udviklervenligt end optparse bibliotek.

Praktisk demonstration af Argparse

Lad os se en praktisk demo af, hvordan man bruger argparse-biblioteket til oprettelse af en simpel kommandolinjegrænseflade. Dette program accepterer en sti og kontrollerer, om stien eksisterer eller ej, og hvis den findes, så udskriv, om det er en fil eller et bibliotek.

import os import argparse parser = argparse.ArgumentParser ('description = "Path Existence Checker") parser.add_argument ("- sti", hjælp = "indtast en sti for at kontrollere, om den findes") args = parser.parse_args () input_path = args.sti hvis os.sti.isdir (input_path): print ("Stien eksisterer, og det er en mappe") elif os.sti.isfile (input_path): print ("Stien eksisterer, og det er en fil") andet: print ("Stien findes ikke")

Når vi kører ovenstående program, kan vi kontrollere, om stien findes eller ej.

demo af parsing af argumenter med argparse

Du kan også bruge -h argument med programmet, som er standardargumentet for visning af hjælpemeddelelser.

Lad mig forklare dig, hvordan ovenstående program fungerer. I de første to linjer importerede vi de moduler, som vi skal bruge i programmet. Det os modulet er importeret for at kontrollere, om stien findes eller ej, og er det en fil eller en mappe. Hvis du vil lære mere om os modul, kan du se vores guide til arbejde med os i python.I den næste linje importerede vi det argparse-bibliotek, der kræves for at oprette og parsere argumenter. I tredje linje opretter vi et parserobjekt ved hjælp af ArgumentParser-klassen i argparse-biblioteket. Denne klasse accepterer også en valgfri parameterbeskrivelse, som vises i hjælpemeddelelsen.I den næste linje har vi oprettet et argument med navnet sti ved hjælp af add_argument () -metoden til parserobjektet og giver detaljerne i hjælpeparameteren, der vises i hjælpemeddelelsen, som vi har set i output tidligere.Derefter analyserer vi argumenterne ved hjælp af parse_args () -metoden til parserobjektet og får adgang til brugerinputstien som et argument. Vi fik den sti, som brugeren indtastede i argumentet, og brugte den derefter med os-modulet til at kontrollere, om det er en fil eller mappe. Hvis det ikke er blandt de to, udskrives det, at stien ikke findes.

Tilpasning

Lad os se nogle af de tilpasninger, som vi kan gøre til vores kommandolinjegrænseflade ved hjælp af argparse bibliotek.

Hjælp til brugerdefineret brug

Når vi kører det demo-program, som vi oprettede tidligere med -h parameter, får vi programmets hjælp som det output, som argparse-biblioteket genererede. Hvis du bemærker hjælpemeddelelsen, er der en brugshjælp i den øverste linje, der viser os, hvordan vi bruger den.I vores demo-program har vi fået standardbrugerhjælpen. Vi kan stadig let tilpasse det ved hjælp af brugsparameteren, mens vi opretter parser-objektet ved hjælp af klassen ArgumentParser (). Se på nedenstående kode, som skal ændres i vores demo-program.

parser = argparse.ArgumentParser (beskrivelse = "Path Existence Checker", brug = "cla.py sti ")

Her er output:

hjælp til brugerdefineret brug i argparse

Som vi kan se i output er brugshjælpen blevet ændret til den, vi angiver i ArgumentParser () klassens brugsparameter.

Tilpasning af argumenter

Vi kan også bruge Argparse-biblioteket til at tilpasse argumenterne, ligesom hvis argumenterne kræves eller ej, hvilket giver et argument en standardværdi.

Tilføjelse af standardværdi

Vi kan give argumenterne en standardværdi ved hjælp af standardparameteren til tilføjelsesargument () metode. Se f.eks. Nedenstående kode.

import os import argparse parser = argparse.ArgumentParser (beskrivelse = "Path Existence Checker", brug = "cla.py sti ") parser.add_argument ("- sti", hjælp = "indtast en sti for at kontrollere, om den findes", standard = "filnavn.txt ") args = parser.parse_args () input_path = args.sti hvis input_path == Ingen: exit () elif os.sti.isdir (input_path): print ("Stien eksisterer, og det er en mappe") elif os.sti.isfile (input_path): print ("Stien eksisterer, og det er en fil") ellers: print ("Stien findes ikke")

Når vi kører ovenstående program uden noget argument, får vi nedenstående output. Som vist i output kontrollerer programmet stien filnavn.txt, som vi indstiller i standardparameteren.

Indstilling af krav til argumenter

Vi kan også bruge Argparse-biblioteket til at indstille argumentets krav, dvs.e., om argumenterne vil være nødvendige eller ej. For at gøre det skal vi bruge den krævede parameter som vist i nedenstående kode.

import os import argparse parser = argparse.ArgumentParser (beskrivelse = "Path Existence Checker", brug = "cla.py sti ") parser.add_argument ("- sti", hjælp = "indtast en sti for at kontrollere, om den findes", standard = "filnavn.txt ", krævet = Sand) args = parser.parse_args () input_path = args.sti hvis input_path == Ingen: exit () elif os.sti.isdir (input_path): print ("Stien eksisterer, og det er en mappe") elif os.sti.isfile (input_path): print ("Stien eksisterer, og det er en fil") andet: print ("Stien findes ikke")

Når du kører ovenstående kode uden argumenter, får du en fejl, der siger, at følgende argumenter er påkrævet.

Argumenttype

Vi kan også indstille den datatype, der bruges i argumentet. For eksempel, hvis vi har brug for stien, skal vi give en streng datatype. Hvis en bruger indtaster en datatype, der ikke er en streng, ændrer Argparser den til en streng. For at indstille standardtypen for et argument skal du køre nedenstående kode.

import os import argparse parser = argparse.ArgumentParser (beskrivelse = "Path Existence Checker", brug = "cla.py sti ") parser.add_argument ("- sti", hjælp = "indtast en sti for at kontrollere, om den findes", type = str) args = parser.parse_args () input_path = args.sti hvis input_path == Ingen: exit () elif os.sti.isdir (input_path): print ("Stien eksisterer, og det er en mappe") elif os.sti.isfile (input_path): print ("Stien eksisterer, og det er en fil") ellers: print ("Stien findes ikke")

Produktion:

specificering af datatypen af argumenter

Konklusion

Dette er kun det grundlæggende ved parsing af argumenter ved hjælp af Argparse-biblioteket. Efter at have gennemgået denne vejledning anbefales det at læse den officielle dokumentation for at udforske flere tricks til at bruge dette bibliotek. Det kan også være en god idé at se indlægget om brug af logning på python, hvilket er meget nyttigt til skrivning af store applikationer og let fejlretning.