В настоящее время я учу себя Python, и мне просто интересно (в отношении моего примера ниже) в упрощенном виде, что sys.argv[1]представляет собой. Это просто просит ввода?

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

Я хотел бы отметить, что предыдущие ответы сделали много предположений о знаниях пользователя. Этот ответ пытается ответить на вопрос на более обучающем уровне.

Для каждого вызова Python sys.argvавтоматически создается список строк, представляющих аргументы (разделенные пробелами) в командной строке. Название происходит от соглашения по программированию на C, в котором argv и argc представляют аргументы командной строки.

Вы захотите узнать больше о списках и строках, когда будете знакомиться с Python, но пока вот несколько вещей, которые необходимо знать.

Вы можете просто создать скрипт, который печатает аргументы в том виде, в котором они представлены. Он также печатает количество аргументов, используя lenфункцию из списка.

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

Сценарий требует Python 2.6 или более поздней версии. Если вы вызываете этот скрипт print_args.py, вы можете вызвать его с другими аргументами, чтобы увидеть, что происходит.

> 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

Как видите, аргументы командной строки включают имя сценария, но не имя интерпретатора. В этом смысле Python рассматривает скрипт как исполняемый файл. Если вам нужно знать имя исполняемого файла (в данном случае python), вы можете использовать sys.executable.

Из примеров видно, что можно получить аргументы, содержащие пробелы, если пользователь вызвал скрипт с аргументами, заключенными в кавычки, так что вы получите список аргументов, предоставленный пользователем.

Теперь в вашем коде Python вы можете использовать этот список строк в качестве входных данных для вашей программы. Поскольку списки индексируются целыми числами, начинающимися с нуля, вы можете получить отдельные элементы, используя синтаксис list [0]. Например, чтобы получить имя скрипта:

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

Хотя это интересно, вам редко нужно знать имя вашего скрипта. Чтобы получить первый аргумент после скрипта для имени файла, вы можете сделать следующее:

filename = sys.argv[1]

Это очень распространенное использование, но обратите внимание, что оно завершится с ошибкой IndexError, если аргумент не был предоставлен.

Кроме того, Python позволяет ссылаться на фрагмент списка, поэтому, чтобы получить другой список только предоставленных пользователем аргументов (но без имени скрипта), вы можете сделать

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

Кроме того, Python позволяет назначать последовательность элементов (включая списки) именам переменных. Поэтому, если вы ожидаете, что пользователь всегда предоставит два аргумента, вы можете назначить эти аргументы (в виде строк) двум переменным:

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

Итак, чтобы ответить на ваш конкретный вопрос, sys.argv[1]представляет первый аргумент командной строки (как string), предоставленный для рассматриваемого сценария. Он не будет запрашивать ввод, но завершится с ошибкой IndexError, если в командной строке после имени сценария не указаны аргументы.

sys.argv [1] содержит первый аргумент командной строки, переданный вашему сценарию.

Например, если ваш сценарий назван hello.pyи вы выполняете:

$ python3.1 hello.py foo

или:

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

Ваш скрипт напечатает:

Привет там фу

sys.argv это список.

Этот список создается вашей командной строкой, это список аргументов вашей командной строки.

Например:

в командной строке вы вводите что-то вроде этого,

python3.2 file.py something

sys.argv станет списком ['file.py', 'что-то']

В таком случае sys.argv[1] = 'something'

Просто добавьте к ответу Фредерика, например, если вы называете свой сценарий следующим образом:

./myscript.py foo bar

sys.argv[0]будет "./myscript.py" sys.argv[1]будет "foo" и sys.argv[2]будет "bar" ... и так далее.

В вашем примере кода, если вы вызовете скрипт следующим образом ./myscript.py foo , вывод скрипта будет «Hello there foo».

Добавив еще несколько пунктов к ответу Джейсона:

Для получения всех пользовательских аргументов: user_args = sys.argv[1:]

Рассмотрим sys.argv как список строк как (упомянуто Джейсоном). Таким образом, все манипуляции со списком будут применяться здесь. Это называется «Список нарезки». Для получения дополнительной информации посетите здесь .

Синтаксис такой: список [начало: конец: шаг]. Если вы опустите start, по умолчанию он будет равен 0, а если вы опустите end, он по умолчанию будет иметь длину списка.

Предположим, что вы хотите получить все аргументы только после третьего аргумента:

user_args = sys.argv[3:]

Предположим, вам нужны только первые два аргумента, а затем:

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

Предположим, вы хотите аргументы от 2 до 4:

user_args = sys.argv[2:4]

Предположим, вам нужен последний аргумент (последний аргумент всегда равен -1, поэтому здесь мы начинаем отсчет с начала. Итак, начало - последний, без конца, без шага):

user_args = sys.argv[-1]

Предположим, вы хотите второй последний аргумент:

user_args = sys.argv[-2]

Предположим, вам нужны два последних аргумента:

user_args = sys.argv[-2:]

Предположим, вы хотите два последних аргумента. Здесь начало равно -2, то есть второй последний элемент, а затем до конца (обозначается ":"):

user_args = sys.argv[-2:]

Предположим, вы хотите все, кроме двух последних аргументов. Здесь начало равно 0 (по умолчанию), а конец - второй последний элемент:

user_args = sys.argv[:-2]

Предположим, вы хотите аргументы в обратном порядке:

user_args = sys.argv[::-1]

Надеюсь это поможет.

sys.argv - список, содержащий путь к сценарию и аргументы командной строки; т.е. sys.argv [0] - это путь к скрипту, который вы запускаете, и все последующие члены являются аргументами.

Чтобы передать аргументы вашему скрипту Python при запуске скрипта через командную строку

python create_thumbnail.py test1.jpg test2.jpg

здесь имя скрипта - create_thumbnail.py, аргумент 1 - test1.jpg, аргумент 2 - test2.jpg

С помощью скрипта create_thumbnail.py я использую

sys.argv[1:]

который дает мне список аргументов, которые я передал в командной строке как ['test1.jpg', 'test2.jpg']

sys.argvявляется атрибутом sysмодуля. Он говорит, что аргументы передаются в файл в командной строке. sys.argv[0]ловит каталог, в котором находится файл. sys.argv[1]возвращает первый аргумент, переданный в командной строке. Подумайте, у нас есть файл example.py.

example.py

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

Теперь здесь, в командной строке, когда мы делаем это:

python example.py

Он выдаст ошибку индекса в строке 2. Потому что аргумент еще не передан. Вы можете увидеть длину аргументов, переданных пользователем с помощью if len(sys.argv) >= 1: # Code. Если мы запустим example.py с передачей аргумента

python example.py args

Это печатает:

args

Потому что это был первый аргумент! Допустим, мы сделали его исполняемым файлом, используя PyInstaller. Мы бы сделали это:

example argumentpassed

Это печатает:

argumentpassed

Это действительно полезно, когда вы делаете команду в терминале. Сначала проверьте длину аргументов. Если аргументы не переданы, сделайте текст справки.

sys .argv отобразит аргументы командной строки, переданные при запуске скрипта, или вы можете сказать, что sys.argv будет хранить аргументы командной строки, переданные в python, при запуске из терминала.

Просто попробуйте это:

import sys
print sys.argv

argv хранит все аргументы, переданные в списке Python. Выше будут напечатаны все аргументы, переданные при запуске скрипта.

Теперь попробуйте запустить файл filename.py следующим образом:

python filename.py example example1

это напечатает 3 аргумента в списке.

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

Точно так же argv 1 - первый переданный аргумент, в данном случае 'example'

Подобный вопрос уже задавался здесь, кстати. Надеюсь это поможет!