sys.argv[1] sens dans le script

Je suis actuellement enseignante moi-même Python et me demandais juste (En référence à mon exemple ci-dessous) en termes simples ce que le sys.argv[1] représente. Est-il tout simplement demander un input?

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

Ce n'est pas une partie de la question, et il est très vieux, mais le module argparse, c'est probablement mieux pour ce que vous êtes en train de faire, selon ceci

InformationsquelleAutor Switchkick | 2010-11-07

python

307

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

Pour chaque invocation de Python, sys.argv est automatiquement une liste de chaînes de caractères représentant les arguments (comme séparés par des espaces) sur la ligne de commande. Le nom vient de la La programmation en C de la convention de dans lequel argv et argc représentent les arguments de ligne de commande.

Vous aurez envie d'en apprendre plus sur les listes et les chaînes que vous êtes familiarisé avec Python, mais en attendant, voici quelques petites choses à savoir.

Vous suffit de créer un script qui imprime les arguments qu'ils sont représentés. Il imprime aussi le nombre d'arguments, à l'aide de la len fonction sur 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'appeler avec des arguments différents 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 ligne de commande comprennent le nom du script, mais pas le nom de l'interprète. 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 utiliser sys.executable.

Vous pouvez le voir dans les exemples qu'il est possible de recevoir des arguments qui contiennent des espaces, si l'utilisateur a invoqué le script avec des arguments entourées d'apostrophes, de sorte que ce que vous obtenez est la liste des arguments fournis par l'utilisateur.

Maintenant dans votre code Python, vous pouvez utiliser cette liste de chaînes de caractères en entrée de votre programme. Comme les listes sont indexés par des entiers de base zéro, vous pouvez obtenir les éléments individuels à l'aide de la liste[0] syntaxe. Par exemple, pour obtenir le nom du script:
```
script_name = sys.argv[0] # this will always work.
```
Bien qu'intéressantes, vous aurez rarement besoin de connaître votre nom de 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 un très commun, mais notez qu'il échouera avec une IndexError si aucun argument n'a été fourni.

Aussi, Python vous permet de référencer une tranche de une liste, de sorte à obtenir une autre liste de juste fournies par l'utilisateur arguments (mais sans le nom du script), vous pouvez le faire
```
user_args = sys.argv[1:] # get everything after the script name
```
En outre, Python permet d'assigner une séquence d'éléments (y compris des listes de noms de variables. Donc, si vous vous attendez à l'utilisateur de toujours fournir deux arguments, vous pouvez affecter ces arguments (comme des chaînes de caractères) de 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 (en tant que string) fourni pour le script en question. Il ne vous 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.
- Lorsque vous affichez la liste de chaînes de caractères sys.argv, je me demande ce que la ligne from __future__ import print_function n'. Est-il quelque chose que je dois ajouter, si je suis PAS en cours d'exécution sur Python 3, mais Python 2? @Jason R. Combes
- vous n'avez pas besoin de l'ajouter si vous êtes sur Python 3. J'ai ajouté qu'il est complet. Essayer sans sur Python 2 et vous obtiendrez des résultats différents de ce que j'ai décrit. Lui donner un essai.
- Je suis confondre avec celui-ci: sys.argv **is** automatically a list of strings. Voulez-vous dire "donne" ou "retour"?
- C'est une subtile différence sémantique, mais en Python, des noms tels que sys.argv contenir des références à des objets. Donc, techniquement, le argv attribut de la sys module est une référence à un objet de la liste contenant les chaînes de caractères des arguments. Pour utiliser gives ou returns suggère un appel de fonction ou d'un générateur ou d'une autre construction. references ou represents peut-être des termes plus précis, mais is est assez proche.
- qu'advient-il si je appeler directement main par l'importation du module (permet de dire que le nom du module est moduleA.py) et appeler la fonction comme dans import moduleA; moduleA.main(). Dans ce cas, il n'y a pas d'arguments de ligne de commande.. donc est sys.argv[0] toujours censé représenter le filename ie. il devrait imprimer moduleA.py?
- eh bien.. quelques tests simples pour révéler qu'il ne semble pas être une réponse standard pour sys.argv[0]. Même à l'intérieur d'un virtualenv, appelant ipython ou env\bin\ipython, python, puis en exécutant quelque chose comme import moduleA; moduleA.main() conduire à de complètement différent affichage des trésors... Si je ne suis pas candidat python filenameA.py, comment est sys.argv[0], toujours pas sûr de savoir comment sys.argv[0] est déterminée..
InformationsquelleAutor Jason R. Coombs
32

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

Par exemple, si votre script est nommé hello.py et vous question:
```
$ python3.1 hello.py foo
```
ou:
```
$ chmod +x hello.py  # make script executable
$ ./hello.py foo
```
Votre script d'impression:
```
Bonjour toto
```
InformationsquelleAutor Frédéric Hamidi
23

sys.argv est une liste de.

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 saisissez quelque chose comme cela,
```
python3.2 file.py something
```
sys.argv deviendra une liste ['file.py', 'quelque chose']

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

InformationsquelleAutor user2205939
12

Juste en ajoutant à Frédéric de réponse, 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 code d'exemple, si vous appelez le script comme suit ./myscript.py foo , le script de sortie sera "Bonjour toto".

InformationsquelleAutor CodeWombat
9

L'ajout d'un peu plus de points de Jason Réponse :

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

Considérer le sys.argv comme une liste de chaînes de caractères comme des (mentionné par Jason). Donc, toute la liste des manipulations va s'appliquer ici. Cette opération est appelée "Liste de Découpage". Pour plus d'informations, visitez ici.

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

Supposons que vous voulez seulement de prendre en compte tous les arguments après le 3e argument, alors :
```
user_args = sys.argv[3:]
```
Supposons que vous voulez seulement les deux premiers arguments, alors :
```
user_args = sys.argv[0:2]  or  user_args = sys.argv[:2]
```
Supposons que vous voulez des arguments de 2 à 4 :
```
user_args = sys.argv[2:4]
```
Supposons que vous voulez le dernier argument (le dernier argument est toujours -1, de sorte que ce qui se passe ici, c'est nous commencer le compte à partir de l'arrière. Donc, commencer à se dernière, pas de fin, pas d'étape) :
```
user_args = sys.argv[-1]
```
Supposons que vous voulez que le deuxième dernier argument :
```
user_args = sys.argv[-2]
```
Supposons que vous voulez que les deux derniers arguments :
```
user_args = sys.argv[-2:]
```
Supposons que vous voulez que les deux derniers arguments. Ici, commencer est de -2, qui est avant-dernier élément, puis à la fin (indiqué par ":") :
```
user_args = sys.argv[-2:]
```
Supposons que vous voulez le tout, sauf les deux derniers arguments. Ici, de départ est 0 (par défaut), et la fin est deuxième du dernier élément :
```
user_args = sys.argv[:-2]
```
Supposons que vous voulez les arguments dans l'ordre inverse :
```
user_args = sys.argv[::-1]
```
Espère que cette aide.

InformationsquelleAutor Rahul
4

sys.argv est une liste contenant le chemin du script et les arguments de ligne de commande; c'est à dire sys.argv[0] est le chemin d'accès du script que vous êtes en cours d'exécution et tous les membres suivants sont des arguments.

InformationsquelleAutor TartanLlama
3

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

Dans le create_thumbnail.py script que j'utilise
```
sys.argv[1:]
```
qui me donne la liste des arguments passés en ligne de commande
['test1.jpg', 'test2.jpg']

InformationsquelleAutor JBJ
1

sys.argv est un attribut de la sys module. Il affirme que 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] retourne le premier argument passé dans la ligne de commande. Pensez comme nous avons un example.py fichier.

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
```
Qu'il va jeter un indice d'erreur à la ligne 2. Cause il n'est pas un argument encore passé. Vous pouvez voir la longueur de la arguments qui lui sont transmises par l'utilisateur à l'aide de if len(sys.argv) >= 1: # Code.
Si nous jouons à l'example.py avec le passage d'un argument
```
python example.py args
```
Il imprime:
```
args
```
Parce que c'était la première arguement! Disons que nous avons fait un fichier exécutable à l'aide PyInstaller. On pourrait faire ceci:
```
example argumentpassed
```
Il imprime:
```
argumentpassed
```
Il est vraiment utile lorsque vous faites une commande dans le terminal. Vérifiez d'abord la longueur des arguments. Si aucun argument n'passé, faire le texte d'aide.

InformationsquelleAutor Jaidee
0

sys .argv affiche la ligne de commande arguments passés lors de l'exécution d'un script ou vous pouvez dire sys.argv va stocker les arguments de ligne de commande passé en python lors de l'exécution à partir de la borne.

Essaie juste de faire ceci:
```
import sys
print sys.argv
```
argv contient tous les arguments passés à une liste python. Le ci-dessus permettra d'imprimer tous les arguments passés exécutez le script.

Maintenant, essayez cette exécution de votre filename.py comme ceci:
```
python filename.py example example1
```
cela permettra d'imprimer 3 arguments dans une liste.
```
sys.argv[0] #is the first argument passed, which is basically the filename. 
```
De même, argvUn est le premier argument passé, dans ce cas, 'exemple'

Une question similaire a été posée déjà ici btw. Espérons que cette aide!

InformationsquelleAutor geekidharsh

Vous devez vous connecter pour publier un commentaire.

example.py