Question Comment lire / traiter les arguments de ligne de commande?


Je suis à l'origine un programmeur C. J'ai vu de nombreuses astuces et "hacks" pour lire de nombreux arguments différents.

Comment les programmeurs Python peuvent-ils faire cela?

en relation


455
2018-06-17 22:38


origine


Réponses:


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 supports (entre autres):

  • 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.

285
2018-06-17 22:39



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:])

428
2018-06-17 22:42



Juste aller évangéliser pour argparse ce qui est mieux pour celles-ci raisons .. essentiellement:

(copié du lien)

  • le module argparse peut gérer la position et arguments optionnels, tout en optparse peut gérer seulement optionnel arguments

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

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

  • argparse soutient l'action consommer un nombre variable de arguments de ligne de commande, tandis que optparse exige que le nombre exact de arguments (par exemple 1, 2 ou 3) en avance

  • argparse prend en charge les analyseurs envoyer aux sous-commandes, tandis que optparse nécessite la mise en place allow_interspersed_args et faire le Parser dispatch manuellement

Et mon préféré:

  • argparse permet le type et paramètres d'action à add_argument() à préciser avec simple callables, alors que optparse nécessite attributs de classe de piratage comme STORE_ACTIONS ou CHECK_METHODS obtenir vérification correcte des arguments

122
2018-06-26 18:15



Il y a aussi argparse module stdlib (un "impovement" sur stdlib's optparse module). Exemple de l'introduction à argparse:

# script.py
import argparse

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'integers', metavar='int', type=int, choices=range(10),
         nargs='+', help='an integer in the range 0..9')
    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))

Usage:

$ script.py 1 2 3 4
4

$ script.py --sum 1 2 3 4
10

61
2018-06-18 03:12



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

45
2018-06-17 22:43



le docopt la bibliothèque est vraiment chic. 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)

38
2018-02-09 16:52



#set default args as -h , if no args:
if len(sys.argv) == 1: sys.argv[1:] = ["-h"]

22
2018-05-11 03:53



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, courez python main.py James Smith

pour produire la sortie suivante:

Bonjour James Smith


22
2017-10-25 11:40



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

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

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

17
2018-06-18 04:07



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).


7
2018-06-18 01:30