Atualmente, estou me ensinando Python e estava me perguntando (em referência ao meu exemplo abaixo) em termos simplificados o que isso sys.argv[1]representa. É simplesmente pedir uma entrada?

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

Gostaria de observar que as respostas anteriores fizeram muitas suposições sobre o conhecimento do usuário. Esta resposta tenta responder à pergunta em um nível mais tutorial.

Para cada chamada do Python, sys.argvé automaticamente uma lista de strings representando os argumentos (separados por espaços) na linha de comando. O nome vem da convenção de programação C na qual argv e argc representam os argumentos da linha de comandos.

Você vai querer aprender mais sobre listas e seqüências de caracteres enquanto se familiariza com o Python, mas enquanto isso, aqui estão algumas coisas a saber.

Você pode simplesmente criar um script que imprima os argumentos como eles são representados. Também imprime o número de argumentos, usando a lenfunção na lista.

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

O script requer Python 2.6 ou posterior. Se você chamar esse script print_args.py, poderá invocá-lo com argumentos diferentes para ver o que acontece.

> 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

Como você pode ver, os argumentos da linha de comando incluem o nome do script, mas não o nome do intérprete. Nesse sentido, o Python trata o script como executável. Se você precisar saber o nome do executável (neste caso, python), você pode usar sys.executable.

Você pode ver nos exemplos que é possível receber argumentos que contêm espaços se o usuário invocou o script com argumentos encapsulados entre aspas; portanto, o que você obtém é a lista de argumentos fornecidos pelo usuário.

Agora, no seu código Python, você pode usar esta lista de strings como entrada para o seu programa. Como as listas são indexadas por números inteiros baseados em zero, é possível obter os itens individuais usando a sintaxe da lista [0]. Por exemplo, para obter o nome do script:

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

Embora interessante, você raramente precisa saber o nome do seu script. Para obter o primeiro argumento após o script para um nome de arquivo, você pode fazer o seguinte:

filename = sys.argv[1]

Esse é um uso muito comum, mas observe que ele falhará com um IndexError se nenhum argumento for fornecido.

Além disso, o Python permite fazer referência a uma fatia de uma lista; portanto, para obter outra lista apenas dos argumentos fornecidos pelo usuário (mas sem o nome do script), você pode fazer

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

Além disso, o Python permite atribuir uma sequência de itens (incluindo listas) a nomes de variáveis. Portanto, se você espera que o usuário sempre forneça dois argumentos, pode atribuir esses argumentos (como seqüências de caracteres) a duas variáveis:

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

Portanto, para responder sua pergunta específica, sys.argv[1]representa o primeiro argumento da linha de comando (como a string) fornecido ao script em questão. Ele não solicitará entrada, mas falhará com um IndexError se nenhum argumento for fornecido na linha de comando após o nome do script.

sys.argv [1] contém o primeiro argumento da linha de comando passado para o seu script.

Por exemplo, se seu script for nomeado hello.pye você emitir:

$ python3.1 hello.py foo

ou:

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

Seu script será impresso:

Olá, foo

sys.argv é uma lista.

Esta lista é criada pela sua linha de comando, é uma lista dos seus argumentos de linha de comando.

Por exemplo:

na sua linha de comando, você digita algo assim,

python3.2 file.py something

sys.argv se tornará uma lista ['file.py', 'something']

Nesse caso sys.argv[1] = 'something'

Apenas adicionando à resposta de Frederic, por exemplo, se você chamar seu script da seguinte maneira:

./myscript.py foo bar

sys.argv[0]seria "./myscript.py" sys.argv[1]seria "foo" e sys.argv[2]seria "bar" ... e assim por diante.

No seu código de exemplo, se você chamar o script da seguinte maneira ./myscript.py foo , a saída do script será "Hello there foo".

Adicionando mais alguns pontos à resposta de Jason:

Para obter todos os argumentos fornecidos pelo usuário: user_args = sys.argv[1:]

Considere o sys.argv como uma lista de strings como (mencionado por Jason). Portanto, todas as manipulações da lista serão aplicadas aqui. Isso é chamado de "Fatiamento de lista". Para mais informações visite aqui .

A sintaxe é assim: list [start: end: step]. Se você omitir o início, o padrão será 0 e, se você omitir o final, o tamanho da lista será o padrão.

Suponha que você queira apenas receber todos os argumentos após o terceiro argumento, então:

user_args = sys.argv[3:]

Suponha que você queira apenas os dois primeiros argumentos, então:

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

Suponha que você queira os argumentos 2 a 4:

user_args = sys.argv[2:4]

Suponha que você queira o último argumento (o último argumento é sempre -1, então o que está acontecendo aqui é que começamos a contagem de volta. Portanto, o começo é o último, sem fim, sem etapa):

user_args = sys.argv[-1]

Suponha que você queira o segundo último argumento:

user_args = sys.argv[-2]

Suponha que você queira os dois últimos argumentos:

user_args = sys.argv[-2:]

Suponha que você queira os dois últimos argumentos. Aqui, start é -2, que é o segundo último item e, em seguida, até o fim (indicado por ":"):

user_args = sys.argv[-2:]

Suponha que você queira tudo, exceto os dois últimos argumentos. Aqui, o início é 0 (por padrão) e o final é o segundo último item:

user_args = sys.argv[:-2]

Suponha que você queira os argumentos na ordem inversa:

user_args = sys.argv[::-1]

Espero que isto ajude.

sys.argv é uma lista que contém o caminho do script e os argumentos da linha de comando; sys.argv [0] é o caminho do script que você está executando e todos os membros a seguir são argumentos.

Para passar argumentos para o script python enquanto executa um script via linha de comando

python create_thumbnail.py test1.jpg test2.jpg

aqui, nome do script - create_thumbnail.py, argumento 1 - test1.jpg, argumento 2 - test2.jpg

Com o script create_thumbnail.py eu uso

sys.argv[1:]

que me fornece a lista de argumentos que eu passei na linha de comando como ['test1.jpg', 'test2.jpg']

sys.argvé um atributo do sysmódulo. Ele diz que os argumentos foram passados ​​para o arquivo na linha de comando. sys.argv[0]pega o diretório em que o arquivo está localizado. sys.argv[1]retorna o primeiro argumento passado na linha de comando. Pense como se tivéssemos um arquivo example.py.

example.py

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

Agora, aqui no prompt de comando, quando fazemos isso:

python example.py

Ele lançará um erro de índice na linha 2. Porque ainda não há nenhum argumento passado. Você pode ver o tamanho dos argumentos transmitidos pelo usuário usando if len(sys.argv) >= 1: # Code. Se executarmos o example.py passando um argumento

python example.py args

Imprime:

args

Porque foi o primeiro argumento! Digamos que o tornamos um arquivo executável usando o PyInstaller. Nós faríamos isso:

example argumentpassed

Imprime:

argumentpassed

É realmente útil quando você está fazendo um comando no terminal. Primeiro verifique o comprimento dos argumentos. Se nenhum argumento for aprovado, faça o texto de ajuda.

sys .argv exibirá os argumentos da linha de comando passados ​​ao executar um script ou você pode dizer que o sys.argv armazenará os argumentos da linha de comando passados ​​em python durante a execução no terminal.

Apenas tente o seguinte:

import sys
print sys.argv

argv armazena todos os argumentos passados ​​em uma lista python. O texto acima imprimirá todos os argumentos passados, executando o script.

Agora tente executar o seu filename.py assim:

python filename.py example example1

isso imprimirá 3 argumentos em uma lista.

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

Da mesma forma, argv 1 é o primeiro argumento passado, neste caso 'exemplo'

Uma pergunta semelhante já foi feita aqui . Espero que isto ajude!