Python Command Line Tutorial

L'analisi per gli argomenti della riga di comando era precedentemente incluso nella biblioteca di Python predefinita "Argparse". Abilitando i valori di input dell'utente di essere in qualche modo analizzati e quindi utilizzati, "Argparse". Offre flessibilità e riutilizza il codice al posto dell'impostazione manuale delle variabili come parte del codice.

Esempio 1

Implementeremo il codice successivo per mostrare la struttura e l'uso di una biblioteca Argparse.

importare argparse
Parser = ArgParse.ArgomentoParser ()
parser.add_argument ('-name', type = str, richiesto = true)
args = parser.parse_args ()
Stampa ('Hi', Args.nome)

La libreria "Argparse" verrebbe importata all'inizio del codice. Il parser è inizializzato da argomentoParser (), quindi saremo in grado di iniziare ad aggiungere parametri personalizzati. Usa il parser.funzione add_argument () per aggiungere argomenti desiderati. Il "nome", "tipo" e "richiesto" saranno dati come argomenti di questo metodo. L'attributo "richiesto" è un booleano che indica se viene eseguito il seguente campo della riga di comando e l'argomento "tipo" mostra il tipo di variabile specificato come input. Impostiamo il valore dell'argomento "tipo" come "str" ​​e "richiesto" come "vero". La funzione parse_args () verrà chiamata. Gli "Args.L'attributo nome "sembra essere il nome di tale argomento identificato con la funzione add_argument ().

Il codice precedente produce questo tipo di risultato come mostrato:

Come possiamo vedere, questo aumenterà un errore poiché è necessario l'argomento "nome" ma manca. Quando aggiungiamo -Name, otteniamo il seguente output:

Esempio 2

Ci sono alcune situazioni in cui non vogliamo discutere riguardo al nome che potrebbe essere usato per la bandiera. Si può utilizzare un parametro posizionale per evitare di dover fornire il flag -nome prima di inserire il valore effettivo.

Qui moltiplicheremo gli argomenti di posizione specificando i parametri.

importare argparse
Parser = ArgParse.ArgomentoParser ()
parser.add_argument ('-i', type = int, richiesto = true)
parser.add_argument ('-j', type = int, richiesto = true)
args = parser.parse_args ()
Product = Args.I * args.J
Stampa ('Prodotto:', Prodotto)

Il parser è stato generato per la prima volta dopo aver importato il modulo "Argparse". Le variabili "i" e "j", due argomenti di tipo intero che devono essere vere, sono state quindi aggiunte. Successivamente, le formule del prodotto verranno applicate dopo aver analizzato i parametri. Utilizziamo la funzione print () per visualizzare il prodotto.

Esempio 3

In questo caso, facciamo moltiplicazione senza specificare i parametri posizionali.

importare argparse
Parser = ArgParse.ArgomentoParser ()
parser.add_argument ('k', type = int)
parser.add_argument ('l', type = int)
args = parser.parse_args ()
Product = Args.k * args.l
Stampa ('Prodotto:', Prodotto)

Innanzitutto, integrando il pacchetto "ArgParse", il parser è stato inizialmente costruito usando il metodo argomerParser (). La "K" e "L" sono i due argomenti specificati con il tipo di intero. Sebbene gli argomenti posizionali mantengano una riga di comando più chiara, non forniamo l'attributo "richiesto" qui. Successivamente, i parametri indicati sono stati analizzati con l'aiuto del metodo Parse_args (). Definiremo una funzione del prodotto utilizzando le variabili "K" e "L". Per mostrare il risultato, utilizzeremo l'istruzione di stampa.

Esempio 4

Gli argomenti opzionali potrebbero essere utili ogni volta che vogliamo fornire a un utente una certa scelta di utilizzare la funzionalità. Specifichiamo semplicemente il parametro opzionale utilizzando la funzione add_argument () per aggiungere un argomento opzionale.

importare argparse
Parser = ArgParse.ArgomentoParser ()
parser.add_argument ('-name', type = str, richiesto = true)
parser.add_argument ('-class', type = int)
args = parser.parse_args ()
Se args.Classe:
Stampa (args.nome, "in", args.Classe ", classe.')
altro:
stampa ("hey", Args.nome + '!')

Iniziamo il programma incorporando la libreria "Argparse". Abbiamo stabilito per la prima volta un parser usando il metodo ArgumentParser () per eseguire due argomenti del parser. Ora chiameremo la funzione add_argument () per aggiungere parametri diversi. Questi argomenti includono due variabili, nome e classe, in cui l'argomento "nome" è del tipo "stringa" e deve essere vero. Il parametro "class" ha il tipo "intero".

Inoltre, dopo aver analizzato i parametri, utilizziamo la condizione "if-else". All'interno di questo, abbiamo applicato due volte la funzione print (), una volta dall'istruzione "if" e di nuovo dalla dichiarazione "else", per rappresentare l'output. Gli argomenti nei metodi Print () variano in entrambi i casi. Gli argomenti indicati nella funzione First Print () includono il nome e la classe. Allo stesso tempo, gli argomenti presentati nel metodo Second Print () includono Args.nome.

Dopo aver eseguito il codice, otteniamo i due output come indicato di seguito. Otteniamo il primo output dopo aver utilizzato gli argomenti opzionali e il secondo senza argomenti opzionali.

Dalle due precedenti output diversi, possiamo osservare che esiste una differenza tra le due uscite a causa dell'uso degli argomenti opzionali in uno e non nell'altro.

Esempio 5

Immaginiamo che invece di chiedere all'utente di fornire input "x" e "y", vogliamo che l'utente inserisca un intervallo di numeri e lo script, che restituirebbe il totale di tutti quei numeri. Dato che non possiamo prevedere quanti valori entrerà in un utente, non è necessario creare un nuovo argomento per ogni nuovo valore. Il numero (o gli input) l'argomento può accettare può essere specificato usando l'opzione "NARGS" nella funzione add_argument ().

Forniremo più argomenti di input e stamperemo il risultato in questo caso.

importare argparse
Parser = ArgParse.ArgomentoParser ()
parser.add_argument ('-valori', type = int, nargs = 5)
args = parser.parse_args ()
somma = somma (args.valori)
print ('somma:', somma)

Avriamo importando la libreria "ArgParse", necessaria per l'esecuzione del codice precedente. Creeremo un parser chiamando l'argomentoParser (). Questa funzione non contiene alcun argomento. Successivamente, verrà invocato il metodo add_argument (). Questo metodo ha tre parametri. Nel caso di più argomenti di input, abbiamo utilizzato l'attributo "NARGS" all'interno del metodo add_argument (). Ora chiameremo la funzione Parse_args () per l'analisi. Applichiamo il metodo Sum () per trovare la somma dei valori. Per descrivere l'output, abbiamo utilizzato l'istruzione di stampa.

Esempio 6

E se vogliamo la somma di più input di cinque valori? Possiamo fare in modo che l'argomento accetti un numero qualsiasi di valori impostando NARGS = "+".

importare argparse
Parser = ArgParse.ArgomentoParser ()
parser.add_argument ('-valori', type = int, nargs = '+')
args = parser.parse_args ()
somma = somma (args.valori)
print ('somma:', somma)

Potremmo eseguire lo script con quasi qualsiasi numero di valori di input. Qui, utilizziamo lo stesso codice di prima, ma, in questo codice, cambieremo "NARGS" = 5 in "NARGS" = '+'.

Conclusione

Questo articolo ha riguardato una varietà di tecniche di analisi della linea di comando di Python, come argomenti semplici, argomenti di posizione, argomenti opzionali e argomenti di input multipli. Ha anche fornito esempi per vedere come l'output cambia a seconda che venga utilizzato un argomento. Possiamo utilizzare esempi per esaminare e comprendere se un argomento è appropriato in una determinata circostanza.