Exécuter un script python avec une partie de l'argument qui sont en option

Je suis passé par le sys documentation, toutefois il y a quelque chose qui n'est pas encore clair pour moi. J'ai cherché une question similaire sur stackoverflow, mais je n'ai pas trouver quelque chose d'utile (clairement toute référence est appréciée!).

Je veux créer un script - dire foo.py - dans laquelle je veux passer de 3 à 6 arguments:

$ python foo.py arg1 arg2 arg3

Les 3 premiers arguments doit être donnée dans tous les cas; les 3 derniers arguments sont utilisés dans une fonction qui ont valeur par défaut des arguments si rien ne s'est passé.

La question est de savoir comment dois-je faire? Jusqu'à présent, je pensais à écrire quelque chose comme ce qui suit foo.py (ceci est un simple exemple, uniquement dans le but d'avoir quelque chose de concret à l'appui de ma question):

import sys

def example(credit_mom, credit_dad, debt_mom, debt_dad = 1000,
            salary = 2000, bonus = 0):
    total_gain = salary + credit_dad + credit_mom + bonus
    total_loss = debt_dad + debt_mom

    return total_gain - total_loss

if __name__ == '__main__':
    if len(sys.argv) < 4:
        sys.exit('Need at least 3 arguments. The order is as follows:\n\
            1.credit_mom;\n\
            2.credit_dad;\n\
            3.debt_mom;\n\
            4.others')
    else:
        sys.exit(example(sys.argv[1],
                         sys.argv[2],
                         sys.argv[3],
                         sys.argv[4],
                         sys.argv[5],
                         sys.argv[6]))

Si j'exécute ce script, j'ai clairement obtenir un IndexError exception:

$ python foo.py 110 110 220
Traceback (most recent call last):
  File "foo.py", line 19, in <module>
    sys.argv[4],
IndexError: list index out of range

Je vous suggère d'utiliser argparse (et voici le tutoriel ). Vous évite d'avoir à vérifier manuellement l'existence de paramètres.
merci! J'ai commencer à passer par le tutoriel immédiatement

OriginalL'auteur rafforaffo | 2015-02-12

15

À L'Aide De Argparse

Je vous suggère d'utiliser argparse (et voici le tutoriel ). Vous évite d'avoir à vérifier manuellement l'existence de paramètres. En outre argparse vous donne la --help argument comme un cadeau, qui va lire le help="" chaîne définie pour chaque argument, s'il est fourni.

Exemple De Programme

Dans votre cas, vous avez trois obligatoires (de position argument) et trois en option. Un échantillon argparse code devrait ressembler à ceci:
```
#!/usr/bin/python
# coding: utf-8
import argparse
def parseArguments():
# Create argument parser
parser = argparse.ArgumentParser()
# Positional mandatory arguments
parser.add_argument("creditMom", help="Credit mom.", type=float)
parser.add_argument("creditDad", help="Credit dad.", type=float)
parser.add_argument("debtMom", help="Debt mom.", type=float)
# Optional arguments
parser.add_argument("-dD", "--debtDad", help="Debt dad.", type=float, default=1000.)
parser.add_argument("-s", "--salary", help="Debt dad.", type=float, default=2000.)
parser.add_argument("-b", "--bonus", help="Debt dad.", type=float, default=0.)
# Print version
parser.add_argument("--version", action="version", version='%(prog)s - Version 1.0')
# Parse arguments
args = parser.parse_args()
return args
def example(credit_mom, credit_dad, debt_mom, debt_dad = 1000, salary = 2000, bonus = 0):
total_gain = salary + credit_dad + credit_mom + bonus
total_loss = debt_dad + debt_mom
return total_gain - total_loss
if __name__ == '__main__':
# Parse the arguments
args = parseArguments()
# Raw print arguments
print("You are running the script with arguments: ")
for a in args.__dict__:
print(str(a) + ": " + str(args.__dict__[a]))
# Run function
print(example(args.creditMom, args.creditDad, args.debtMom, args.debtDad, args.salary, args.bonus))
```
Utilisation appropriée de argparse merveilleusement simule terminal de comportement, alors je vous recommandons également d'utiliser le construit en argparse.
Juste pour clarifier, 1. ce morceau de code doit être après __name__==... 2. l'ordre de parser.add_argument doit correspondre à l'ordre, je suis de passage des arguments dans la ligne de commande. 3. Dans le cas où l'une de l'argument est une chaîne que je vais le faire: parser.add_argument("creditMom" help="Credit mom.", type=string) et le correspondant de l'argument de ligne de commande sera 'something' (pas something). Ces considérations de droit?
Aussi, la fonction dans ce cas, doit être défini comme def example(*args). Et la dans if __name__==, après avoir lignes de code, je vais simplement faire example(args). Droit?
analyseur.parse_args() renvoie une Namespace() objet nommé args, qui ne devrait pas être "unpackable" avec *args. Cependant, vous pouvez vous référer à l'individu analysé les arguments en faisant args.creditMom et args.bonus, par exemple. Enfin oui les arguments de position, comme le nom le sens commun veut, elle doit être définie avec parser.add_argument() dans l'ordre où ils sont passés au script python. Les arguments optionnels doivent cependant pas. Voir ma réponse mis à jour. 😉
merci pour l'edit, et merci pour l'explication claire

OriginalL'auteur JoErNanO
3

Autres que d'utiliser argparse (que je recommande), cela peut être résolu par tranchage et de l'expansion:
```
    sys.exit(example(*sys.argv[1:7]))
```
La tranche contient uniquement les éléments qui existent réellement, même si il n'y en a pas assez pour satisfaire la taille de la tranche demandée.

Ainsi, par exemple, sys.argv[4] sera None?
Pas de. Il n'existe pas, donc sys.argv[1:7] serait [110, 110, 220].

OriginalL'auteur Ignacio Vazquez-Abrams
3

Alors que je cautionne le argparse approche, voici une approche rapide et sale:
```
arg1, arg2, arg3 = [None, False, []]
if sys.argv[1:]:   # test if there are atleast 1 argument (beyond [0])
arg1 = sys.argv[1]
if sys.argv[2:]:
arg2 = sys.argv[2]  # careful 'True' is a string, not a boolean
arg3 = sys.argv[3:]  # rest
```
J'utilise quand je commence à ajouter de l'argument de l'analyse d'un script, et mes choix d'arguments n'a pas mûri. Il est plus adapté à 'positionals' que 'options' (pour utiliser argparse de la terminologie).

OriginalL'auteur hpaulj
1

Votre fonction "exemple" est tout simplement parfait. Le problème, c'est que vous êtes en train de lire sysargs qui ne sont pas là. Essayez de vérifier si elles sont vides (dans le bloc else).

Ce n'est pas qu'ils "ne sont pas là, c'est que les positions dans sys.argv n'existe pas.
Oui, par exemple sys.argv[4] n'existe pas/n'est pas là.
en effet, la question vise à comprendre comment faire quand la plupart du temps les 3 derniers arguments n'existent pas.

OriginalL'auteur Mackie

Vous devez vous connecter pour publier un commentaire.

À L'Aide De Argparse

Exemple De Programme