¿Cómo leer / procesar argumentos de línea de comando?

Originalmente soy un programador C. He visto numerosos trucos y "hacks" para leer muchos argumentos diferentes.

¿Cuáles son algunas de las formas en que los programadores de Python pueden hacer esto?

Relacionado

• ¿Cuál es la mejor manera de agarrar / analizar argumentos de línea de comandos pasados ​​a un script Python?
• ¿Implementando una interfaz de línea de comandos de estilo “[comando] [acción] [parámetro]”?
• ¿Cómo puedo procesar argumentos de línea de comandos en Python?
• ¿Cómo formateo la ayuda del argumento posicional usando el optparse de Python?

La solución canónica en la biblioteca estándar es argparse( docs ):

Aquí hay un ejemplo:

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 soportes (entre otras cosas):

• Múltiples opciones en cualquier orden.
• Opciones cortas y largas.
• Valores predeterminados.
• Generación de un mensaje de ayuda de uso.

import sys

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

sys.argv es una lista que contiene todos los argumentos pasados ​​al script en la línea de comando.

Básicamente,

import sys
print(sys.argv[1:])

Simplemente dando vueltas evangelizando por argparse, lo cual es mejor por estas razones ... esencialmente:

(copiado del enlace)

• El módulo argparse puede manejar argumentos posicionales y opcionales, mientras que optparse solo puede manejar argumentos opcionales

• argparse no es dogmático sobre el aspecto que debería tener su interfaz de línea de comandos: se admiten opciones como -file o / file, al igual que las opciones requeridas. Optparse se niega a admitir estas características, prefiriendo la pureza sobre la practicidad

• argparse produce mensajes de uso más informativos, incluido el uso de línea de comandos determinado a partir de sus argumentos, y mensajes de ayuda para argumentos posicionales y opcionales. El módulo optparse requiere que escriba su propia cadena de uso, y no tiene forma de mostrar ayuda para argumentos posicionales.

• argparse admite acciones que consumen un número variable de argumentos de línea de comandos, mientras que optparse requiere que se conozca de antemano el número exacto de argumentos (por ejemplo, 1, 2 o 3)

• argparse admite analizadores que se envían a subcomandos, mientras que optparse requiere configurar allow_interspersed_argsy realizar el envío de analizador manualmente

Y mi favorito personal:

• argparse permite que los parámetros de tipo y acción add_argument() se especifiquen con cálculos simples, mientras que optparse requiere la piratería de atributos de clase como STORE_ACTIONSo CHECK_METHODSpara obtener una verificación de argumento adecuada

También hay argparseun módulo stdlib (una "mejora" en el optparsemódulo stdlib ). Ejemplo de la introducción a 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))

Uso:

$ script.py 1 2 3 4
4

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

Una forma de hacerlo es usando sys.argv. Esto imprimirá el nombre del script como primer argumento y todos los demás parámetros que le pase.

import sys

for arg in sys.argv:
    print arg

La biblioteca docopt es realmente elegante. Construye un argumento dict a partir de la cadena de uso para su aplicación.

Por ejemplo, del archivo Léame de 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)

Si necesitas algo rápido y no muy flexible

main.py:

import sys

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

Entonces corre python main.py James Smith

para producir el siguiente resultado:

Hola james smith

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

Yo mismo uso optparse, pero me gusta mucho la dirección que está tomando Simon Willison con su biblioteca optfunc recientemente presentada . Funciona por:

"introspección de una definición de función (incluidos sus argumentos y sus valores predeterminados) y usarla para construir un analizador de argumentos de línea de comando".

Entonces, por ejemplo, esta definición de función:

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

se convierte en este texto de ayuda de optparse:

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

Me gusta getopt de stdlib, por ejemplo:

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

Últimamente he estado envolviendo algo similar a esto para hacer las cosas menos detalladas (por ejemplo, hacer "-h" implícito).

El clic de Pocoo es más intuitivo, requiere menos repetitivo y es al menos tan poderoso como argparse.

La única debilidad que he encontrado hasta ahora es que no se puede hacer mucha personalización para ayudar a las páginas, pero eso generalmente no es un requisito y docopt parece ser la opción clara cuando lo es.

Como puede ver optparse "El módulo optparse está en desuso y no se desarrollará más; el desarrollo continuará con el módulo argparse ".

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

Puede que le interese un pequeño módulo de Python que escribí para facilitar aún más el manejo de los argumentos de la línea de comandos (código abierto y uso gratuito) - Comando

Recomiendo mirar docopt como una alternativa simple a estos otros.

docopt es un nuevo proyecto que funciona analizando su mensaje de ayuda en lugar de requerir que implemente todo usted mismo. Solo tiene que poner su mensaje de uso en el formato POSIX.

Otra opción más es argh . Se basa en argparse y te permite escribir cosas como:

import argh

# declaring:

def echo(text):
    "Returns given word as is."
    return text

def greet(name, greeting='Hello'):
    "Greets the user with given name. The greeting is customizable."
    return greeting + ', ' + name

# assembling:

parser = argh.ArghParser()
parser.add_commands([echo, greet])

# dispatching:

if __name__ == '__main__':
    parser.dispatch()

Generará automáticamente ayuda, etc., y puede usar decoradores para proporcionar orientación adicional sobre cómo debería funcionar el análisis de argumentos.

Mi solución es entrypoint2 . Ejemplo:

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

texto de ayuda:

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