Obecnie uczę się Pythona i po prostu zastanawiałem się (w odniesieniu do mojego przykładu poniżej) w uproszczonych terminach, co sys.argv[1]reprezentuje. Czy po prostu prosi o wkład?

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

Pragnę zauważyć, że poprzednie odpowiedzi zawierały wiele założeń dotyczących wiedzy użytkownika. Ta odpowiedź jest próbą odpowiedzi na pytanie na wyższym poziomie samouczka.

Dla każdego wywołania Pythona sys.argvjest automatycznie lista łańcuchów reprezentujących argumenty (oddzielone spacjami) w linii poleceń. Nazwa pochodzi z konwencji programowania C, w której argv i argc reprezentują argumenty wiersza poleceń.

Będziesz chciał dowiedzieć się więcej o listach i ciągach znaków, gdy będziesz zaznajamiać się z Pythonem, ale w międzyczasie, oto kilka rzeczy, które warto wiedzieć.

Możesz po prostu utworzyć skrypt, który wypisze argumenty tak, jak są one reprezentowane. Wyświetla również liczbę argumentów, używając lenfunkcji z listy.

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

Skrypt wymaga Pythona 2.6 lub nowszego. Jeśli wywołasz ten skrypt print_args.py, możesz wywołać go z różnymi argumentami, aby zobaczyć, co się stanie.

> 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

Jak widać, argumenty wiersza poleceń zawierają nazwę skryptu, ale nie nazwę interpretera. W tym sensie Python traktuje skrypt jako plik wykonywalny. Jeśli chcesz znać nazwę pliku wykonywalnego (w tym przypadku python), możesz użyć sys.executable.

Z przykładów widać, że możliwe jest otrzymanie argumentów, które zawierają spacje, jeśli użytkownik wywołał skrypt z argumentami ujętymi w cudzysłowy, więc otrzymujemy listę argumentów podaną przez użytkownika.

Teraz w swoim kodzie Pythona możesz użyć tej listy ciągów jako danych wejściowych do swojego programu. Ponieważ listy są indeksowane za pomocą liczb całkowitych zaczynających się od zera, można uzyskać poszczególne elementy za pomocą składni list [0]. Na przykład, aby uzyskać nazwę skryptu:

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

Chociaż jest to interesujące, rzadko musisz znać nazwę swojego skryptu. Aby uzyskać pierwszy argument po skrypcie dla nazwy pliku, możesz wykonać następujące czynności:

filename = sys.argv[1]

Jest to bardzo powszechne użycie, ale pamiętaj, że zakończy się niepowodzeniem z błędem IndexError, jeśli nie podano argumentu.

Ponadto Python umożliwia odwoływanie się do wycinka listy, więc aby uzyskać kolejną listę tylko argumentów dostarczonych przez użytkownika (ale bez nazwy skryptu), możesz zrobić

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

Dodatkowo Python umożliwia przypisanie sekwencji elementów (w tym list) do nazw zmiennych. Więc jeśli oczekujesz, że użytkownik zawsze będzie podawał dwa argumenty, możesz przypisać te argumenty (jako łańcuchy) do dwóch zmiennych:

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

Tak więc, odpowiadając na twoje konkretne pytanie, sys.argv[1]reprezentuje pierwszy argument wiersza poleceń (jako a string) dostarczony do danego skryptu. Nie będzie monitować o wprowadzenie danych, ale zakończy się niepowodzeniem z błędem IndexError, jeśli w wierszu poleceń po nazwie skryptu nie zostaną podane żadne argumenty.

sys.argv [1] zawiera pierwszy argument wiersza poleceń przekazany do twojego skryptu.

Na przykład, jeśli twój skrypt ma nazwę hello.pyi wydajesz:

$ python3.1 hello.py foo

lub:

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

Twój skrypt wydrukuje:

Cześć foo

sys.argv to lista.

Ta lista jest tworzona przez linię poleceń, jest to lista argumentów linii poleceń.

Na przykład:

w linii poleceń wpisujesz coś takiego,

python3.2 file.py something

sys.argv stanie się listą [„plik.py”, „coś”]

W tym przypadku sys.argv[1] = 'something'

Wystarczy dodać do odpowiedzi Frederica, na przykład jeśli wywołasz swój skrypt w następujący sposób:

./myscript.py foo bar

sys.argv[0]byłoby „./myscript.py” sys.argv[1]byłoby „foo” i sys.argv[2]byłoby „bar” ... i tak dalej.

W Twoim przykładowym kodzie, jeśli wywołasz skrypt w następujący sposób ./myscript.py foo , wyjście skryptu będzie brzmiało „Witaj foo”.

Dodanie kilku dodatkowych punktów do odpowiedzi Jasona:

Aby wziąć wszystkie argumenty podane przez użytkownika: user_args = sys.argv[1:]

Rozważ plik sys.argv jako listę ciągów, jak (wspomniane przez Jasona). Więc wszystkie manipulacje listami będą miały tutaj zastosowanie. Nazywa się to „podziałem na segmenty”. Więcej informacji znajdziesz tutaj .

Składnia jest następująca: list [początek: koniec: krok]. Jeśli pominiesz początek, domyślnie będzie to 0, a jeśli pominiesz koniec, domyślnie będzie to długość listy.

Załóżmy, że chcesz wziąć wszystkie argumenty po trzecim argumencie, a następnie:

user_args = sys.argv[3:]

Załóżmy, że chcesz tylko dwa pierwsze argumenty, a następnie:

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

Załóżmy, że chcesz argumenty od 2 do 4:

user_args = sys.argv[2:4]

Załóżmy, że chcesz ostatni argument (ostatni argument ma zawsze wartość -1, więc to, co się tutaj dzieje, to zaczynamy liczenie od tyłu. Więc początek jest ostatnim, nie ma końca, nie ma kroku):

user_args = sys.argv[-1]

Załóżmy, że chcesz przedostatni argument:

user_args = sys.argv[-2]

Załóżmy, że potrzebujesz dwóch ostatnich argumentów:

user_args = sys.argv[-2:]

Załóżmy, że potrzebujesz dwóch ostatnich argumentów. Tutaj początek to -2, czyli przedostatnia pozycja, a następnie do końca (oznaczonego „:”):

user_args = sys.argv[-2:]

Załóżmy, że chcesz mieć wszystko oprócz ostatnich dwóch argumentów. Tutaj początek to 0 (domyślnie), a koniec to przedostatnia pozycja:

user_args = sys.argv[:-2]

Załóżmy, że chcesz, aby argumenty były w odwrotnej kolejności:

user_args = sys.argv[::-1]

Mam nadzieję że to pomoże.

sys.argv to lista zawierająca ścieżkę skryptu i argumenty wiersza poleceń; tj. sys.argv [0] jest ścieżką do uruchomionego skryptu, a wszyscy następujący członkowie są argumentami.

Przekazywanie argumentów do skryptu w języku Python podczas uruchamiania skryptu za pośrednictwem wiersza poleceń

python create_thumbnail.py test1.jpg test2.jpg

tutaj nazwa skryptu - create_thumbnail.py, argument 1 - test1.jpg, argument 2 - test2.jpg

W skrypcie create_thumbnail.py używam

sys.argv[1:]

co daje mi listę argumentów, które przekazałem w wierszu poleceń jako ['test1.jpg', 'test2.jpg']

sys.argvjest atrybutem sysmodułu. Mówi, że argumenty są przekazywane do pliku w linii poleceń. sys.argv[0]przechwytuje katalog, w którym znajduje się plik. sys.argv[1]zwraca pierwszy argument przekazany w linii poleceń. Pomyśl, jakbyśmy mieli plik example.py.

example.py

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

Teraz w wierszu polecenia, kiedy to robimy:

python example.py

Zwróci błąd indeksu w linii 2. Ponieważ nie przekazano jeszcze argumentu. Możesz zobaczyć długość argumentów przekazanych przez użytkownika za pomocą if len(sys.argv) >= 1: # Code. Jeśli uruchomimy example.py z przekazaniem argumentu

python example.py args

Drukuje:

args

Ponieważ to był pierwszy argument! Powiedzmy, że utworzyliśmy plik wykonywalny przy użyciu PyInstaller. Zrobilibyśmy to:

example argumentpassed

Drukuje:

argumentpassed

Jest to bardzo pomocne, gdy wydajesz polecenie w terminalu. Najpierw sprawdź długość argumentów. Jeśli nie przekazano żadnych argumentów, zrób tekst pomocy.

sys .argv wyświetli argumenty wiersza poleceń przekazane podczas uruchamiania skryptu lub możesz powiedzieć, że sys.argv będzie przechowywać argumenty wiersza poleceń przekazane w Pythonie podczas uruchamiania z terminala.

Po prostu spróbuj tego:

import sys
print sys.argv

argv przechowuje wszystkie przekazane argumenty na liście Pythona. Powyższe wypisze wszystkie przekazane argumenty i uruchomi skrypt.

Teraz spróbuj uruchomić plik filename.py w ten sposób:

python filename.py example example1

to wypisze 3 argumenty na liście.

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

Podobnie, argv 1 jest pierwszym przekazanym argumentem, w tym przypadku „przykład”

Przy okazji, podobne pytanie padło już tutaj . Mam nadzieję że to pomoże!