Comment lire/processus d'arguments de ligne de commande?

La solution canonique dans la bibliothèque standard est argparse (docs):

Voici un exemple:

from argparse import ArgumentParser

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

args = parser.parse_args()

argparse prend en charge (entre autres choses):

• Plusieurs options dans n'importe quel ordre.
• À court et à long options.
• Valeurs par défaut.
• Génération de l'utilisation dans le message d'aide.

Juste d'aller autour de l'évangélisation pour argparse ce qui est mieux pour ces raisons.. essentiellement:

(copié à partir du lien)

• argparse module peut gérer de position
  et les arguments optionnels, tandis que
  optparse peut gérer uniquement en option
  les arguments

• argparse n'est pas dogmatique sur
  ce que votre interface de ligne de commande
  devrait ressembler - comme les options de fichier
  ou /fichier sont pris en charge, comme le sont
  les options requises. Optparse refuse de
  prendre en charge ces fonctionnalités, préférant
  la pureté de plus de praticité

• argparse produit plus
  un usage informatif messages, y compris les
  de ligne de commande utilisation déterminée à partir de
  vos arguments, et les messages d'aide pour
  à la fois la position et facultatif
  les arguments. Le module optparse
  vous oblige à écrire votre propre utilisation
  chaîne, et n'a pas de moyen d'afficher
  de l'aide pour les arguments de position.

• argparse soutient les actions qui
  consommer un nombre variable de
  en ligne de commande args, tandis que optparse
  exige que le nombre exact de
  des arguments (par exemple 1, 2, ou 3) être connu
  à l'avance

• argparse prend en charge analyseurs qui
  envoi de sous-commandes, tandis que
  optparse nécessite la mise en
  allow_interspersed_args et de faire le
  analyseur d'expédition manuellement

Et mon préféré:

• argparse permet le type et la
  les paramètres d'action pour add_argument()
  pour être spécifiée avec de simples
  callables, tandis que optparse exige
  le piratage des attributs de classe comme
  STORE_ACTIONS ou CHECK_METHODS pour obtenir
  bon argument de la vérification

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

import sys

for arg in sys.argv:
    print arg

Si vous avez besoin quelque chose de rapide et pas très souple

main.py:

import sys

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

Puis exécutez python main.py James Smith

pour produire le résultat suivant:

Bonjour James Smith

- Je utiliser optparse moi-même, mais vraiment comme la direction de Simon Willison prend avec son récemment introduit optfunc de la bibliothèque. Il fonctionne par:

"l'introspection d'une fonction
définition (y compris ses arguments
et leurs valeurs par défaut) et à l'aide de
que pour construire une ligne de commande
l'argument de l'analyseur."

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

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

est transformé en ce optparse texte d'aide:

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

Comme vous pouvez le voir optparse "Le module optparse est obsolète avec et ne sera pas développé plus loin; le développement se poursuivra avec la argparse module".

Vous pouvez être intéressé par un petit module Python que j'ai écrit pour rendre le traitement des arguments de ligne de commande encore plus facile (open source et libre d'utilisation) - 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

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