Sys.argv [1], что означает script

В настоящее время я учу себя 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()

Ответ 1

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

Для каждого вызова 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, если в командной строке после имени сценария не указаны аргументы.

Ответ 2

sys.argv [1] содержит первую командную строку argument передано вашему script.

Например, если ваш script имеет имя hello.py, и вы выдаете:

$ python3.1 hello.py foo

или

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

Ваш script будет печатать:

Hello there foo

Ответ 3

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

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

Например:

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

python3.2 file.py something

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

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

Ответ 4

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

./myscript.py foo bar

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

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

Ответ 5

Добавление еще нескольких замечаний к Джейсону Ответ:

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

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

Синтаксис выглядит так: list [start: end: step]. Если вы опустите начало, по умолчанию будет 0, и если вы опустите конец, по умолчанию будет указан список.

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

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:]

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

user_args = sys.argv[:-2]

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

user_args = sys.argv[::-1]

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

Ответ 6

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

Ответ 7

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

python create_thumbnail.py test1.jpg test2.jpg

здесь, script name - create_thumbnail.py, аргумент 1 - test1.jpg, аргумент 2 - test2.jpg

С помощью create_thumbnail.py script я использую

sys.argv[1:]

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

Ответ 8

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

Просто попробуйте следующее:

import sys
print sys.argv

argv хранит все аргументы, переданные в списке python. Вышеприведенное будет распечатывать все переданные аргументы, будет работать script.

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

python filename.py example example1

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

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

Аналогично, argv 1 - это первый переданный аргумент, в данном случае "пример"

Аналогичный вопрос уже задан здесь. Надеюсь это поможет!

Ответ 9

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

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