Ich bringe mir gerade Python bei und habe mich nur gefragt (in Bezug auf mein Beispiel unten), vereinfacht ausgedrückt, was das sys.argv[1]darstellt. Bittet es einfach um eine Eingabe?

#!/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()

Ich möchte darauf hinweisen, dass frühere Antworten viele Annahmen über das Wissen des Benutzers gemacht haben. Diese Antwort versucht, die Frage auf einer Tutorial-Ebene zu beantworten.

Bei jedem Aufruf von Python sys.argvwird automatisch eine Liste von Zeichenfolgen angezeigt, die die Argumente (durch Leerzeichen getrennt) in der Befehlszeile darstellen. Der Name stammt aus der C-Programmierkonvention, in der argv und argc die Befehlszeilenargumente darstellen.

Wenn Sie sich mit Python vertraut machen, möchten Sie mehr über Listen und Zeichenfolgen erfahren. In der Zwischenzeit sollten Sie jedoch einige Dinge beachten.

Sie können einfach ein Skript erstellen, das die dargestellten Argumente druckt. Außerdem wird die Anzahl der Argumente mithilfe der lenFunktion in der Liste gedruckt .

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

Das Skript erfordert Python 2.6 oder höher. Wenn Sie dieses Skript aufrufen print_args.py, können Sie es mit verschiedenen Argumenten aufrufen, um zu sehen, was passiert.

> 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

Wie Sie sehen können, enthalten die Befehlszeilenargumente den Skriptnamen, jedoch nicht den Interpreternamen. In diesem Sinne behandelt Python das Skript als ausführbare Datei. Wenn Sie den Namen der ausführbaren Datei (in diesem Fall Python) kennen müssen, können Sie verwenden sys.executable.

Sie können den Beispielen entnehmen, dass es möglich ist, Argumente zu empfangen, die Leerzeichen enthalten, wenn der Benutzer das Skript mit in Anführungszeichen gekapselten Argumenten aufgerufen hat. Sie erhalten also die Liste der vom Benutzer angegebenen Argumente.

Jetzt können Sie in Ihrem Python-Code diese Liste von Zeichenfolgen als Eingabe für Ihr Programm verwenden. Da Listen durch nullbasierte Ganzzahlen indiziert werden, können Sie die einzelnen Elemente mithilfe der Listensyntax [0] abrufen. So erhalten Sie den Skriptnamen:

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

Obwohl interessant, müssen Sie Ihren Skriptnamen selten kennen. Um das erste Argument nach dem Skript für einen Dateinamen zu erhalten, haben Sie folgende Möglichkeiten:

filename = sys.argv[1]

Dies ist eine sehr häufige Verwendung. Beachten Sie jedoch, dass ein IndexError fehlschlägt, wenn kein Argument angegeben wurde.

Mit Python können Sie auch auf einen Teil einer Liste verweisen. Um eine weitere Liste nur der vom Benutzer angegebenen Argumente abzurufen (jedoch ohne den Skriptnamen), können Sie dies tun

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

Darüber hinaus können Sie mit Python Variablennamen eine Folge von Elementen (einschließlich Listen) zuweisen. Wenn Sie also erwarten, dass der Benutzer immer zwei Argumente angibt, können Sie diese Argumente (als Zeichenfolgen) zwei Variablen zuweisen:

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

Um Ihre spezifische Frage zu beantworten, handelt es sich also sys.argv[1]um das erste Befehlszeilenargument (als a string), das an das betreffende Skript übergeben wird. Es wird nicht zur Eingabe aufgefordert, aber es schlägt mit einem IndexError fehl, wenn in der Befehlszeile nach dem Skriptnamen keine Argumente angegeben werden.

sys.argv [1] enthält das erste Befehlszeile Argument an das Skript übergeben.

Wenn Ihr Skript beispielsweise benannt ist hello.pyund Sie Folgendes ausgeben:

$ python3.1 hello.py foo

oder:

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

Ihr Skript wird gedruckt:

Hallo foo

sys.argv ist eine Liste.

Diese Liste wird von Ihrer Befehlszeile erstellt. Es handelt sich um eine Liste Ihrer Befehlszeilenargumente.

Beispielsweise:

In Ihrer Befehlszeile geben Sie so etwas ein:

python3.2 file.py something

sys.argv wird eine Liste ['file.py', 'etwas']

In diesem Fall sys.argv[1] = 'something'

Fügen Sie einfach Frederics Antwort hinzu, zum Beispiel, wenn Sie Ihr Skript wie folgt aufrufen:

./myscript.py foo bar

sys.argv[0]wäre "./myscript.py" sys.argv[1]wäre "foo" und sys.argv[2]wäre "bar" ... und so weiter.

Wenn Sie in Ihrem Beispielcode das Skript wie folgt aufrufen, lautet ./myscript.py foo die Ausgabe des Skripts "Hallo, foo".

Hinzufügen einiger weiterer Punkte zu Jasons Antwort:

Für alle vom Benutzer angegebenen Argumente: user_args = sys.argv[1:]

Betrachten Sie die Datei sys.argv als eine Liste von Zeichenfolgen wie (von Jason erwähnt). Daher gelten hier alle Listenmanipulationen. Dies wird als "List Slicing" bezeichnet. Weitere Informationen finden Sie hier .

Die Syntax lautet wie folgt: list [start: end: step]. Wenn Sie den Start weglassen, wird standardmäßig 0 verwendet, und wenn Sie das Ende weglassen, wird standardmäßig die Länge der Liste verwendet.

Angenommen, Sie möchten erst alle Argumente nach dem dritten Argument übernehmen, dann:

user_args = sys.argv[3:]

Angenommen, Sie möchten nur die ersten beiden Argumente, dann:

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

Angenommen, Sie möchten die Argumente 2 bis 4:

user_args = sys.argv[2:4]

Angenommen, Sie möchten das letzte Argument (das letzte Argument ist immer -1. Was also hier passiert, ist, dass wir die Zählung von hinten beginnen. Der Start ist also das letzte, kein Ende, kein Schritt):

user_args = sys.argv[-1]

Angenommen, Sie möchten das vorletzte Argument:

user_args = sys.argv[-2]

Angenommen, Sie möchten die letzten beiden Argumente:

user_args = sys.argv[-2:]

Angenommen, Sie möchten die letzten beiden Argumente. Hier ist Start -2, das ist der vorletzte Punkt und dann bis zum Ende (bezeichnet mit ":"):

user_args = sys.argv[-2:]

Angenommen, Sie möchten alles außer den letzten beiden Argumenten. Hier ist Start (standardmäßig) 0 und Ende das vorletzte Element:

user_args = sys.argv[:-2]

Angenommen, Sie möchten die Argumente in umgekehrter Reihenfolge:

user_args = sys.argv[::-1]

Hoffe das hilft.

sys.argv ist eine Liste mit dem Skriptpfad und den Befehlszeilenargumenten. dh sys.argv [0] ist der Pfad des Skripts, das Sie ausführen, und alle folgenden Mitglieder sind Argumente.

So übergeben Sie Argumente an Ihr Python-Skript, während Sie ein Skript über die Befehlszeile ausführen

python create_thumbnail.py test1.jpg test2.jpg

hier Skriptname - create_thumbnail.py, Argument 1 - test1.jpg, Argument 2 - test2.jpg

Mit im Skript create_thumbnail.py verwende ich

sys.argv[1:]

die mir die Liste der Argumente geben, die ich in der Befehlszeile als ['test1.jpg', 'test2.jpg'] übergeben habe

sys.argvist ein Attribut des sysModuls. Es heißt, die Argumente, die in der Datei in der Befehlszeile übergeben wurden. sys.argv[0]fängt das Verzeichnis ab, in dem sich die Datei befindet. sys.argv[1]Gibt das erste in der Befehlszeile übergebene Argument zurück. Denken Sie, wir haben eine example.py-Datei.

example.py

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

Jetzt hier in der Eingabeaufforderung, wenn wir dies tun:

python example.py

In Zeile 2 wird ein Indexfehler ausgegeben. Es wurde noch kein Argument übergeben. Sie können die Länge der vom Benutzer übergebenen Argumente anzeigen if len(sys.argv) >= 1: # Code. Wenn wir die example.py mit der Übergabe eines Arguments ausführen

python example.py args

Es druckt:

args

Weil es das erste Argument war! Nehmen wir an, wir haben es mit PyInstaller zu einer ausführbaren Datei gemacht. Wir würden das tun:

example argumentpassed

Es druckt:

argumentpassed

Es ist sehr hilfreich, wenn Sie im Terminal einen Befehl eingeben. Überprüfen Sie zuerst die Länge der Argumente. Wenn keine Argumente übergeben wurden, führen Sie den Hilfetext aus.

sys .argv zeigt die Befehlszeilenargumente an, die beim Ausführen eines Skripts übergeben wurden, oder Sie können sagen, dass sys.argv die Befehlszeilenargumente speichert, die in Python übergeben werden, während sie vom Terminal ausgeführt werden.

Versuchen Sie einfach Folgendes:

import sys
print sys.argv

argv speichert alle übergebenen Argumente in einer Python-Liste. Das obige druckt alle übergebenen Argumente, um das Skript auszuführen.

Versuchen Sie nun, Ihren Dateinamen.py folgendermaßen auszuführen:

python filename.py example example1

Dadurch werden 3 Argumente in einer Liste gedruckt.

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

In ähnlicher Weise ist argv 1 das erste übergebene Argument, in diesem Fall 'Beispiel'.

Eine ähnliche Frage wurde übrigens schon hier gestellt. Hoffe das hilft!