python - with - Comment lire/traiter les arguments de la ligne de commande?




no handles with labels found to put in legend. (12)

S'il vous plaît noter que optparse était obsolète dans la version 2.7 de Python:

http://docs.python.org/2/library/optparse.html . argparse est le remplaçant: http://docs.python.org/2/library/argparse.html#module-argparse

Il y a les modules suivants dans la bibliothèque standard:

  • Le module getopt est similaire à GNU getopt.
  • Le module optparse offre une analyse par options de ligne de commande orientée objet.

Voici un exemple qui utilise ce dernier des docs:

from optparse import OptionParser

parser = OptionParser()
parser.add_option("-f", "--file", dest="filename",
                  help="write report to FILE", metavar="FILE")
parser.add_option("-q", "--quiet",
                  action="store_false", dest="verbose", default=True,
                  help="don't print status messages to stdout")

(options, args) = parser.parse_args()

optparse soutient (entre autres choses):

  • Plusieurs options dans n'importe quel ordre.
  • Options courtes et longues.
  • Les valeurs par défaut.
  • Génération d'un message d'aide à l'utilisation.

Comme vous pouvez le voir optparse "Le module optparse est obsolète et ne sera plus développé, le développement continuera avec le module argparse ."


J'aime getopt de stdlib, par exemple:

try:
    opts, args = getopt.getopt(sys.argv[1:], 'h', ['help'])
except getopt.GetoptError, err: 
    usage(err)

for opt, arg in opts:
    if opt in ('-h', '--help'): 
        usage()

if len(args) != 1:
    usage("specify thing...")

Dernièrement, j'ai enveloppé quelque chose de similaire à ceci pour rendre les choses moins verbeuses (par exemple, rendre "-h" implicite).


J'utilise optparse moi-même, mais j'aime vraiment la direction que prend Simon Willison avec sa bibliothèque optfunc récemment introduite. Cela fonctionne par:

"introspecter une définition de fonction (y compris ses arguments et leurs valeurs par défaut) et l'utiliser pour construire un analyseur d'argument de ligne de commande."

Ainsi, par exemple, cette définition de fonction:

def geocode(s, api_key='', geocoder='google', list_geocoders=False):

est transformé en ce texte d'aide optparse:

    Options:
      -h, --help            show this help message and exit
      -l, --list-geocoders
      -a API_KEY, --api-key=API_KEY
      -g GEOCODER, --geocoder=GEOCODER

Juste aller évangéliser pour argparse qui est mieux pour these raisons .. essentiellement:

(copié du lien)

  • Le module argparse peut gérer les arguments positionnels et optionnels, tandis que optparse ne peut gérer que des arguments optionnels

  • argparse n'est pas dogmatique sur ce à quoi devrait ressembler votre interface de ligne de commande - des options comme -file ou / sont supportées, comme le sont les options requises. Optparse refuse de soutenir ces caractéristiques, préférant la pureté à la praticité

  • argparse produit des messages d'utilisation plus informatifs, y compris l'utilisation de la ligne de commande déterminée à partir de vos arguments, et des messages d'aide pour les arguments positionnels et optionnels. Le module optparse vous oblige à écrire votre propre chaîne d'utilisation, et n'a aucun moyen d'afficher l'aide pour les arguments positionnels.

  • argparse supporte une action qui consomme un nombre variable d'arguments en ligne de commande, tandis que optparse requiert que le nombre exact d'arguments (par exemple 1, 2 ou 3) soit connu à l'avance

  • argparse prend en charge les analyseurs qui distribuent les sous-commandes, tandis que optparse requiert la définition de allow_interspersed_args et l'envoi manuel de l'analyseur

Et mon préféré:

  • argparse permet de spécifier les paramètres type et action à add_argument() avec des callables simples, tandis que optparse nécessite de pirater des attributs de classe comme STORE_ACTIONS ou CHECK_METHODS pour obtenir une vérification correcte des arguments

La bibliothèque de docopt est vraiment lisse. Il construit un argument dict à partir de la chaîne d'utilisation de votre application.

Par exemple, du fichier readme docopt:

"""Naval Fate.

Usage:
  naval_fate.py ship new <name>...
  naval_fate.py ship <name> move <x> <y> [--speed=<kn>]
  naval_fate.py ship shoot <x> <y>
  naval_fate.py mine (set|remove) <x> <y> [--moored | --drifting]
  naval_fate.py (-h | --help)
  naval_fate.py --version

Options:
  -h --help     Show this screen.
  --version     Show version.
  --speed=<kn>  Speed in knots [default: 10].
  --moored      Moored (anchored) mine.
  --drifting    Drifting mine.

"""
from docopt import docopt


if __name__ == '__main__':
    arguments = docopt(__doc__, version='Naval Fate 2.0')
    print(arguments)

Ma solution est entrypoint2 . Exemple:

from entrypoint2 import entrypoint
@entrypoint
def add(file, quiet=True): 
    ''' This function writes report.

    :param file: write report to FILE
    :param quiet: don't print status messages to stdout
    '''
    print file,quiet

Texte d'aide:

usage: report.py [-h] [-q] [--debug] file

This function writes report.

positional arguments:
  file         write report to FILE

optional arguments:
  -h, --help   show this help message and exit
  -q, --quiet  don't print status messages to stdout
  --debug      set logging level to DEBUG

Si vous avez besoin de quelque chose rapidement et pas très flexible

main.py:

import sys

first_name = sys.argv[1]
last_name = sys.argv[2]
print("Hello " + first_name + " " + last_name)

Ensuite, lancez python main.py James Smith

pour produire la sortie suivante:

Bonjour James Smith


Une façon de le faire est d'utiliser sys.argv . Cela imprimera le nom du script comme premier argument et tous les autres paramètres que vous lui passerez.

import sys

for arg in sys.argv:
    print arg

Vous pouvez être intéressé par un petit module Python que j'ai écrit pour rendre la manipulation des arguments de la ligne de commande encore plus facile (open source et libre d'utiliser) - Commando


import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('integers', metavar='N', type=int, nargs='+',
                   help='an integer for the accumulator')
parser.add_argument('--sum', dest='accumulate', action='store_const',
                   const=sum, default=max,
                   help='sum the integers (default: find the max)')

args = parser.parse_args()
print(args.accumulate(args.integers))

Assuming the Python code above is saved into a file called prog.py
$ python prog.py -h

Ref-link: https://docs.python.org/3.3/library/argparse.html

import sys

print "\n".join(sys.argv)

sys.argv est une liste qui contient tous les arguments passés au script sur la ligne de commande.

Fondamentalement,

import sys
print sys.argv[1:]




command-line-arguments