Je m'enseigne actuellement Python et je me demandais simplement (en référence à mon exemple ci-dessous) en termes simplifiés ce que cela sys.argv[1]représente. S'agit-il simplement de demander une contribution?

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

Je tiens à noter que les réponses précédentes ont fait de nombreuses hypothèses sur les connaissances de l'utilisateur. Cette réponse tente de répondre à la question à un niveau plus didactique.

Pour chaque invocation de Python, il sys.argvy a automatiquement une liste de chaînes représentant les arguments (séparés par des espaces) sur la ligne de commande. Le nom vient de la convention de programmation C dans laquelle argv et argc représentent les arguments de la ligne de commande.

Vous voudrez en savoir plus sur les listes et les chaînes au fur et à mesure que vous vous familiariserez avec Python, mais en attendant, voici quelques choses à savoir.

Vous pouvez simplement créer un script qui imprime les arguments tels qu'ils sont représentés. Il imprime également le nombre d'arguments, en utilisant la lenfonction de la liste.

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

Le script nécessite Python 2.6 ou version ultérieure. Si vous appelez ce script print_args.py, vous pouvez l'invoquer avec différents arguments pour voir ce qui se passe.

> 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

Comme vous pouvez le voir, les arguments de la ligne de commande incluent le nom du script mais pas le nom de l'interpréteur. En ce sens, Python traite le script comme l'exécutable. Si vous avez besoin de connaître le nom de l'exécutable (python dans ce cas), vous pouvez utilisersys.executable .

Vous pouvez voir à partir des exemples qu'il est possible de recevoir des arguments qui contiennent des espaces si l'utilisateur a appelé le script avec des arguments encapsulés entre guillemets, donc ce que vous obtenez est la liste des arguments fournie par l'utilisateur.

Maintenant, dans votre code Python, vous pouvez utiliser cette liste de chaînes comme entrée de votre programme. Puisque les listes sont indexées par des entiers de base zéro, vous pouvez obtenir les éléments individuels en utilisant la syntaxe list [0]. Par exemple, pour obtenir le nom du script:

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

Bien qu'intéressant, vous avez rarement besoin de connaître le nom de votre script. Pour obtenir le premier argument après le script pour un nom de fichier, vous pouvez effectuer les opérations suivantes:

filename = sys.argv[1]

C'est une utilisation très courante, mais notez qu'elle échouera avec une IndexError si aucun argument n'a été fourni.

De plus, Python vous permet de référencer une tranche d'une liste, donc pour obtenir une autre liste contenant uniquement les arguments fournis par l'utilisateur (mais sans le nom du script), vous pouvez faire

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

De plus, Python vous permet d'attribuer une séquence d'éléments (y compris des listes) aux noms de variables. Donc, si vous vous attendez à ce que l'utilisateur fournisse toujours deux arguments, vous pouvez affecter ces arguments (sous forme de chaînes) à deux variables:

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

Donc, pour répondre à votre question spécifique, sys.argv[1]représente le premier argument de ligne de commande (comme a string) fourni au script en question. Il ne demandera pas d'entrée, mais il échouera avec une IndexError si aucun argument n'est fourni sur la ligne de commande suivant le nom du script.

sys.argv [1] contient le premier argument de ligne de commande passé à votre script.

Par exemple, si votre script est nommé hello.pyet que vous émettez:

$ python3.1 bonjour.py toto

ou:

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

Votre script s'imprimera:

Bonjour tout le monde

sys.argv est une liste.

Cette liste est créée par votre ligne de commande, c'est une liste de vos arguments de ligne de commande.

Par exemple:

dans votre ligne de commande, vous entrez quelque chose comme ça,

python3.2 file.py something

sys.argv deviendra une liste ['file.py', 'quelque chose']

Dans ce cas sys.argv[1] = 'something'

Il suffit d'ajouter à la réponse de Frédéric, par exemple si vous appelez votre script comme suit:

./myscript.py foo bar

sys.argv[0]serait "./myscript.py" sys.argv[1]serait "foo" et sys.argv[2]serait "bar" ... et ainsi de suite.

Dans votre exemple de code, si vous appelez le script comme suit ./myscript.py foo , la sortie du script sera "Hello there foo".

Ajout de quelques points supplémentaires à la réponse de Jason:

Pour prendre tous les arguments fournis par l'utilisateur: user_args = sys.argv[1:]

Considérez le sys.argv comme une liste de chaînes comme (mentionné par Jason). Toutes les manipulations de liste s'appliqueront donc ici. C'est ce qu'on appelle "List Slicing". Pour plus d'informations, visitez ici .

La syntaxe est la suivante: list [début: fin: étape]. Si vous omettez le début, il sera par défaut à 0, et si vous omettez la fin, il sera par défaut à la longueur de la liste.

Supposons que vous ne vouliez prendre tous les arguments qu'après le 3ème argument, alors:

user_args = sys.argv[3:]

Supposons que vous ne vouliez que les deux premiers arguments, alors:

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

Supposons que vous vouliez des arguments 2 à 4:

user_args = sys.argv[2:4]

Supposons que vous vouliez le dernier argument (le dernier argument est toujours -1, donc ce qui se passe ici, c'est que nous commençons le compte à partir de l'arrière. Donc le début est le dernier, pas de fin, pas d'étape):

user_args = sys.argv[-1]

Supposons que vous vouliez l'avant-dernier argument:

user_args = sys.argv[-2]

Supposons que vous vouliez les deux derniers arguments:

user_args = sys.argv[-2:]

Supposons que vous vouliez les deux derniers arguments. Ici, le début est -2, c'est-à-dire l'avant-dernier élément, puis jusqu'à la fin (indiqué par ":"):

user_args = sys.argv[-2:]

Supposons que vous vouliez tout sauf les deux derniers arguments. Ici, le début est 0 (par défaut) et la fin est l'avant-dernier élément:

user_args = sys.argv[:-2]

Supposons que vous vouliez les arguments dans l'ordre inverse:

user_args = sys.argv[::-1]

J'espère que cela t'aides.

sys.argv est une liste contenant le chemin du script et les arguments de la ligne de commande; ie sys.argv [0] est le chemin du script que vous exécutez et tous les membres suivants sont des arguments.

Pour passer des arguments à votre script python lors de l'exécution d'un script via la ligne de commande

python create_thumbnail.py test1.jpg test2.jpg

ici, nom du script - create_thumbnail.py, argument 1 - test1.jpg, argument 2 - test2.jpg

Avec dans le script create_thumbnail.py que j'utilise

sys.argv[1:]

qui me donne la liste des arguments que j'ai passés en ligne de commande comme ['test1.jpg', 'test2.jpg']

sys.argvest un attribut du sysmodule. Il indique les arguments passés dans le fichier dans la ligne de commande. sys.argv[0]attrape le répertoire où se trouve le fichier. sys.argv[1]renvoie le premier argument passé dans la ligne de commande. Pensez comme si nous avions un fichier example.py.

example.py

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

Maintenant, ici dans l'invite de commande lorsque nous faisons cela:

python example.py

Il lancera une erreur d'index à la ligne 2. Parce qu'il n'y a pas encore d'argument passé. Vous pouvez voir la longueur des arguments passés par l'utilisateur à l'aide de if len(sys.argv) >= 1: # Code. Si nous exécutons l'exemple.py en passant un argument

python example.py args

Il imprime:

args

Parce que c'était le premier argument! Disons que nous en avons fait un fichier exécutable à l'aide de PyInstaller. Nous ferions ceci:

example argumentpassed

Il imprime:

argumentpassed

C'est vraiment utile lorsque vous effectuez une commande dans le terminal. Vérifiez d'abord la longueur des arguments. Si aucun argument n'est passé, faites le texte d'aide.

sys .argv affichera les arguments de ligne de commande passés lors de l'exécution d'un script ou vous pouvez dire que sys.argv stockera les arguments de ligne de commande passés en python lors de l'exécution à partir du terminal.

Essayez simplement ceci:

import sys
print sys.argv

argv stocke tous les arguments passés dans une liste python. Ce qui précède affichera tous les arguments passés lors de l'exécution du script.

Maintenant, essayez ceci en exécutant votre filename.py comme ceci:

python filename.py example example1

cela affichera 3 arguments dans une liste.

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

De même, argv 1 est le premier argument passé, dans ce cas 'exemple'

Une question similaire a déjà été posée ici btw. J'espère que cela t'aides!