Attualmente sto insegnando a me stesso Python e mi stavo solo chiedendo (in riferimento al mio esempio di seguito) in termini semplificati cosa sys.argv[1]rappresenta. Sta semplicemente chiedendo un input?

#!/usr/bin/python3.1

# import modules used here -- sys is a very standard one
import sys

# Gather our code in a main() function
def main():
  print ('Hello there', sys.argv[1])
  # Command line args are in sys.argv[1], sys.argv[2] ..
  # sys.argv[0] is the script name itself and can be ignored

# Standard boilerplate to call the main() function to begin
# the program.
if __name__ == '__main__':
  main()

Vorrei sottolineare che le risposte precedenti hanno formulato molte ipotesi sulla conoscenza dell'utente. Questa risposta tenta di rispondere alla domanda a un livello più tutorial.

Per ogni invocazione di Python, sys.argvè automaticamente un elenco di stringhe che rappresentano gli argomenti (come separati da spazi) sulla riga di comando. Il nome deriva dalla convenzione di programmazione C in cui argv e argc rappresentano gli argomenti della riga di comando.

Avrai voglia di saperne di più su liste e stringhe mentre ti familiarizzi con Python, ma nel frattempo, ecco alcune cose da sapere.

Puoi semplicemente creare uno script che stampa gli argomenti mentre vengono rappresentati. Stampa anche il numero di argomenti, usando illen funzione nell'elenco.

from __future__ import print_function
import sys
print(sys.argv, len(sys.argv))

Lo script richiede Python 2.6 o successivo. Se chiami questo script print_args.py, puoi invocarlo con diversi argomenti per vedere cosa succede.

> python print_args.py
['print_args.py'] 1

> python print_args.py foo and bar
['print_args.py', 'foo', 'and', 'bar'] 4

> python print_args.py "foo and bar"
['print_args.py', 'foo and bar'] 2

> python print_args.py "foo and bar" and baz
['print_args.py', 'foo and bar', 'and', 'baz'] 4

Come puoi vedere, gli argomenti della riga di comando includono il nome dello script ma non il nome dell'interprete. In questo senso, Python considera lo script come eseguibile. Se hai bisogno di conoscere il nome dell'eseguibile (python in questo caso), puoi usare sys.executable.

Si può vedere dagli esempi che è possibile ricevere argomenti che contengono spazi se l'utente ha invocato lo script con argomenti incapsulati tra virgolette, quindi quello che si ottiene è l'elenco di argomenti fornito dall'utente.

Ora nel tuo codice Python, puoi usare questo elenco di stringhe come input per il tuo programma. Poiché gli elenchi sono indicizzati da numeri interi in base zero, è possibile ottenere i singoli elementi utilizzando la sintassi dell'elenco [0]. Ad esempio, per ottenere il nome dello script:

script_name = sys.argv[0] # this will always work.

Sebbene interessante, raramente è necessario conoscere il nome dello script. Per ottenere il primo argomento dopo lo script per un nome file, è possibile effettuare le seguenti operazioni:

filename = sys.argv[1]

Questo è un utilizzo molto comune, ma nota che fallirà con IndexError se non viene fornito alcun argomento.

Inoltre, Python ti consente di fare riferimento a una porzione di un elenco, quindi per ottenere un altro elenco solo degli argomenti forniti dall'utente (ma senza il nome dello script), puoi fare

user_args = sys.argv[1:] # get everything after the script name

Inoltre, Python consente di assegnare una sequenza di elementi (compresi gli elenchi) ai nomi delle variabili. Quindi, se ti aspetti che l'utente fornisca sempre due argomenti, puoi assegnare quegli argomenti (come stringhe) a due variabili:

user_args = sys.argv[1:]
fun, games = user_args # len(user_args) had better be 2

Quindi, per rispondere alla tua domanda specifica, sys.argv[1]rappresenta il primo argomento della riga di comando (come a string) fornito allo script in questione. Non richiederà input, ma non riuscirà con IndexError se non viene fornito alcun argomento sulla riga di comando che segue il nome dello script.

sys.argv [1] contiene il primo argomento della riga di comando passato allo script.

Ad esempio, se lo script è denominato hello.pye si emette:

$ python3.1 hello.py foo

o:

$ chmod +x hello.py  # make script executable
$ ./hello.py foo

Il tuo script stamperà:

Ciao a tutti

sys.argv è un elenco.

Questo elenco viene creato dalla tua riga di comando, è un elenco dei tuoi argomenti della riga di comando.

Per esempio:

nella tua riga di comando inserisci qualcosa del genere,

python3.2 file.py something

sys.argv diventerà un elenco ['file.py', 'qualcosa']

In questo caso sys.argv[1] = 'something'

Aggiungo semplicemente la risposta di Frederic, ad esempio se chiami lo script come segue:

./myscript.py foo bar

sys.argv[0]sarebbe "./myscript.py" sys.argv[1]sarebbe "pippo" e sys.argv[2]sarebbe "bar" ... e così via.

Nel tuo codice di esempio, se chiami lo script come segue ./myscript.py foo , l'output dello script sarà "Hello there foo".

Aggiungendo alcuni altri punti alla risposta di Jason:

Per accettare tutti gli argomenti forniti dall'utente: user_args = sys.argv[1:]

Considera sys.argv come un elenco di stringhe come (menzionato da Jason). Quindi tutte le manipolazioni dell'elenco verranno applicate qui. Questo si chiama "List Slicing". Per maggiori informazioni visita qui .

La sintassi è così: list [start: end: step]. Se si omette start, verrà impostato automaticamente su 0 e se si omette end, verrà impostato automaticamente sulla lunghezza dell'elenco.

Supponiamo di voler prendere tutti gli argomenti solo dopo il 3 ° argomento, quindi:

user_args = sys.argv[3:]

Supponiamo di voler solo i primi due argomenti, quindi:

user_args = sys.argv[0:2]  or  user_args = sys.argv[:2]

Supponiamo di voler argomenti da 2 a 4:

user_args = sys.argv[2:4]

Supponiamo che tu voglia l'ultimo argomento (l'ultimo argomento è sempre -1, quindi quello che sta succedendo qui è che iniziamo il conteggio da dietro. Quindi l'inizio è l'ultimo, nessuna fine, nessun passo):

user_args = sys.argv[-1]

Supponiamo che tu voglia il secondo ultimo argomento:

user_args = sys.argv[-2]

Supponiamo che tu voglia gli ultimi due argomenti:

user_args = sys.argv[-2:]

Supponiamo che tu voglia gli ultimi due argomenti. Qui, start è -2, ovvero il penultimo elemento e poi fino alla fine (indicato da ":"):

user_args = sys.argv[-2:]

Supponiamo che tu voglia tutto tranne gli ultimi due argomenti. Qui, start è 0 (per impostazione predefinita) e end è il secondo ultimo elemento:

user_args = sys.argv[:-2]

Supponiamo che tu voglia gli argomenti in ordine inverso:

user_args = sys.argv[::-1]

Spero che questo ti aiuti.

sys.argv è un elenco contenente il percorso dello script e gli argomenti della riga di comando; ie sys.argv [0] è il percorso dello script che stai eseguendo e tutti i membri seguenti sono argomenti.

Per passare argomenti al tuo script Python durante l'esecuzione di uno script dalla riga di comando

python create_thumbnail.py test1.jpg test2.jpg

qui, nome dello script - create_thumbnail.py, argomento 1 - test1.jpg, argomento 2 - test2.jpg

Con lo script create_thumbnail.py che uso

sys.argv[1:]

che mi dà l'elenco degli argomenti che ho passato nella riga di comando come ['test1.jpg', 'test2.jpg']

sys.argvè un attributo del sysmodulo. Dice che gli argomenti passati nel file nella riga di comando. sys.argv[0]cattura la directory in cui si trova il file.sys.argv[1]restituisce il primo argomento passato nella riga di comando. Pensa come se avessimo un file example.py.

example.py

import sys # Importing the main sys module to catch the arguments
print(sys.argv[1]) # Printing the first argument

Ora qui nel prompt dei comandi quando lo facciamo:

python example.py

Verrà generato un errore di indice alla riga 2. Causa non è stato ancora inviato alcun argomento. Puoi vedere la lunghezza degli argomenti passati dall'utente usando if len(sys.argv) >= 1: # Code. Se eseguiamo l'esempio.py con il passaggio di un argomento

python example.py args

Stampa:

args

Perché è stato il primo argomento! Supponiamo di averlo reso un file eseguibile utilizzando PyInstaller. Faremmo questo:

example argumentpassed

Stampa:

argumentpassed

È davvero utile quando si effettua un comando nel terminale. Prima controlla la lunghezza degli argomenti. Se non vengono passati argomenti, fare il testo di aiuto.

sys .argv visualizzerà gli argomenti della riga di comando passati quando si esegue uno script oppure si può dire che sys.argv memorizzerà gli argomenti della riga di comando passati in Python durante l'esecuzione dal terminale.

Prova questo:

import sys
print sys.argv

argv memorizza tutti gli argomenti passati in un elenco Python. Quanto sopra stamperà tutti gli argomenti passati eseguendo lo script.

Ora prova questo eseguendo il tuo nome file.py in questo modo:

python filename.py example example1

questo stamperà 3 argomenti in un elenco.

sys.argv[0] #is the first argument passed, which is basically the filename. 

Allo stesso modo, argv 1 è il primo argomento passato, in questo caso 'esempio'

Una domanda simile è già stata posta qui tra il. Spero che questo ti aiuti!