Argomenti della riga di comando di Python

Python è un linguaggio di alto livello progettato per fare codici generali e non per alcun problema specifico. Possiamo utilizzarlo per scopi generali come la creazione di siti Web utilizzando Python o l'analisi dei dati utilizzando questo linguaggio Python. La programmazione "Python" fornisce anche gli argomenti Command_line. Gli argomenti della riga di comando sono quegli argomenti che abbiamo fornito sulla console o sul terminale di qualsiasi sistema operativo dopo aver menzionato il nome del file di codice insieme all'estensione del file. Possiamo anche definirlo come, in qualsiasi programma, il valore che viene passato attraverso il prompt dei comandi che si dice sia argomenti della riga di comando. In questa guida, discuteremo dell'argomento della riga di comando nella programmazione "Python".

Metodi per gli argomenti della riga di comando in Python

• Utilizzando “sys.argv "
• Utilizzando il modulo "Argparse"
• Utilizzando il modulo "getopt"

Spiegheremo tutti i metodi in dettaglio in questa guida e mostreremo anche la dimostrazione pratica di tutti questi metodi.

Esempio # 01: di Sys.Metodo Argv

Stiamo facendo questi codici Python nell'app "Spyder". Possiamo accedere alle variabili e alle funzioni della riga di comando importando il sistema. Quindi, importiamo "sys" e quindi dichiariamo e inizializziamo la variabile "num" con "len (sys.argv) ". "Argv" sarà l'elenco dei valori delle stringhe che sono gli argomenti che la nostra riga di comando diventerà. "Len" rappresenta la lunghezza degli argomenti che vengono passati. Quindi, nella variabile "num" il numero dei valori passati nel terminale quando viene memorizzata la riga di comando.

Mostriamo anche quei numeri di argomenti che vengono passati utilizzando la "stampa". Sotto questo, mettiamo il "sistema.argv [0] "nell'istruzione di stampa. "Argv" contiene sempre il nome del programma o il nome del file di codice. Quindi, il nome del file che abbiamo creato verrà reso sul terminale. Dopo questo, stampiamo quegli argomenti che vengono passati sul terminale. Stamperà tutti i numeri che abbiamo superato come argomenti della riga di comando sulla schermata della console.

Al di sotto di questo, abbiamo definito un ciclo per loop e abbiamo dichiarato una variabile "a" lì il cui intervallo è tra "1" alla lunghezza dell'argv che è memorizzato in "num". Stampa tutti gli argomenti sulla console. "Argv [a]" contiene tutti gli argomenti di Command_line. Li mostra anche sulla console. Ora stiamo inizializzando la "somma" perché vogliamo calcolare la somma di tutti i valori che passeremo al momento dell'esecuzione sul terminale.

Utilizziamo di nuovo il ciclo "per" e passiamo la gamma. Ma questa volta, stiamo calcolando la somma di tutti quei valori che abbiamo passato sul terminale. Questa somma verrà archiviata nella variabile "somma". Quindi, stampiamo anche la somma di tutti i valori che passeremo al momento dell'esecuzione sul terminale.

Import sys
num = len (sys.argv)
Print ("Argomenti totali passati qui:", Num)
print ("\ nname del file Python:", Sys.argv [0])
print ("\ narguments che abbiamo superato:", end = "")
per un intervallo (1, num):
Stampa (sys.argv [a], end = "")
Somma = 0
per i in gamma (1, num):
Sum += int (sys.argv [i])
print ("\ n \ n la somma degli argomenti passati:", somma)

Sul terminale, abbiamo prima inserito la parola chiave "esegui". Quindi, posizionare il nome del file insieme all'estensione corretta e passare gli argomenti della riga di comando qui. Quindi, visualizza tutte le righe come abbiamo definito nel codice sopra. Prima rende la lunghezza degli argomenti della riga di comando, quindi il nome del file. Dopo questo, rende tutti gli argomenti della riga di comando e rende anche la somma di tutti loro.

Esempio # 02: con il metodo ArgParse

Ora stiamo utilizzando il metodo "Argparse" in questo esempio. Per prima cosa importa "Argparse". Quindi, accederemo alle variabili e alla funzione di questo. Inizializziamo una variabile "dati" e archiviamo una riga che utilizzeremo nel nostro codice. Dopo questo, stiamo inizializzando un "parser" e in "descrizione" passiamo la variabile "dati" in cui abbiamo archiviato il messaggio che vogliamo visualizzare e mettiamo tutti questi nella variabile "my_parser". Abbiamo anche messo il "analisi.args () "alla fine.

importare argparse
data = "Stiamo utilizzando il metodo ArgParse qui"
my_parser = argparse.ArgumentParser (Descrizione = dati)
my_parser.parse_args ()

Guarda il risultato qui sotto. Quando passiamo "-h" come argomento della riga di comando, rende prima il messaggio che abbiamo archiviato nella variabile "dati" e mostra anche l '"argomento opzionale" in quanto questa "h" mostra il messaggio di aiuto. Quando mettiamo "-o" come argomento della riga di comando, rende un messaggio di errore che si tratta di un argomento non riconosciuto.

Esempio # 03: con il metodo Getopt

Ecco l'ultimo metodo che stiamo utilizzando in questo codice. Stiamo importando "sys" e "getopt" in questo codice. Questo "getopt" è il parser che abbiamo utilizzato per gli argomenti della riga di comando. Quindi, nella variabile "argomentazioni", abbiamo superato i "sys.argv [1:] "per rimuovere il primo argomento che stiamo passando nella riga di comando. Inizializziamo il "my_option" con "HMO:".

Dopo questo, stiamo inizializzando la variabile "my_long_option". Utilizziamo il "tentativo" qui che controllerà l'errore. Dopo questo, stiamo analizzando gli argomenti. "Getopt" offre opzioni sia brevi che lunghe, insieme all'opzione per designare un valore. Dopo questo, stiamo controllando tutti gli argomenti che passeremo come argomenti della riga di comando. Se l'argomento della riga di comando è "-h" o "-help", stamperà il messaggio che è riportato al di sotto di questo. Se l'argomento della riga di comando è "-m" o "-my_file", visualizzerà il messaggio che viene scritto dopo questo.

Inoltre, se l'argomento della riga di comando è "-o" o "-output", visualizza anche il messaggio che abbiamo scritto qui dopo questo. Se l'argomento della riga di comando non proviene da tutto quanto sopra, visualizzerà il messaggio di errore in quanto abbiamo inserito "getopt. Errore "nel codice.

Importa Getopt, sys
argomentalist = sys.argv [1:]
my_options = "hmo:"
new_long_options = ["help", "my_file", "output ="
Tentativo:
argomenti, valori = getopt.getopt (argomentallist, my_options, new_long_options)
Per my_argument, my_value in argomenti:
Se my_argument in ("-h", "--elp"):
Stampa ("Visualizzazione dell'aiuto")
elif my_argument in ("-m", "-my_file"):
print ("Visualizzazione di file_name:", sys.argv [0])
elif my_argument in ("-o", "--output")
Stampa (("Abilitazione della modalità di output speciale ( % s)") % (my_value))
Tranne Getopt.Errore come err:
Stampa (STR (ERR))

Qui vedi che quando mettiamo "-h" come riga di comando visualizza lo stesso messaggio che abbiamo scritto nel codice. Quando mettiamo due argomenti di comando come "-help" e anche "-m", visualizza due messaggi di seguito. Nell'argomento della riga di comando "-o", abbiamo anche superato la stringa che viene visualizzata anche nel messaggio.

Conclusione

Abbiamo fornito questa guida per aiutarti ad apprendere il concetto di "Argomenti della riga di comando" in "Python". Abbiamo esplorato "Argomento della riga di comando" e abbiamo anche spiegato tre metodi qui. Abbiamo spiegato l'argomento della riga di comando secondo cui il processo di passaggio dei valori al programma insieme al nome del programma entro il momento dell'esecuzione tramite il prompt dei comandi.