Utilisation de la sortie argparse pour appeler des fonctions

Actuellement mon code ressemble à ceci. Cela me permet d'analyser plusieurs paramètres de mon script d'un programme obtient. Est-il une autre manière qui est plus proche de "bonnes pratiques"? Je n'ai pas vu de code fait à l'aide de la sortie de argparseseulement comment le configurer.

def useArguments():
x = 0
while x <= 5:
if x == 0:                      
if args.getweather != None:
getWeather(args.getweather)
if x == 1:
if args.post != None:
post(args.post)
if x == 2:
if args.custompost != None:
custompost(args.custompost)
if x == 3:
if args.list != None:
listAccounts(args.list)
if x == 4:
if args.add != None:
addAccount(args.add[0])
if x == 5:
if args.edit != None:
editAccount(args.edit[0])
x = x + 1    
if __name__ == '__main__':
updateConfig()
parser = argparse.ArgumentParser(description='Post Yahoo weather to Twitter.', epilog="Report any bugs to [email protected]", prog='Program')
parser.add_argument('-a', '--add', nargs=1, help='Add a new account. Use the desired account name as an argument.')
parser.add_argument('-e', '--edit', nargs=1, choices=accountListSTR[:-1], help='Edit an account. Use the desired account name as an argument.')
parser.add_argument('-g', '--getweather', nargs='*', choices=accountListSTR, help='Get weather and post here. Specify account(s) as argument. Use "all" for all accounts. If you specify multiple accounts, separate by a space NOT a comma.')
parser.add_argument('-p', '--post', nargs='*', choices=accountListSTR, help='Post weather to Twitter. Specify account(s) as argument. Use "all" for all accounts. If you specify multiple accounts, separate by a space NOT a comma.')
parser.add_argument('-c', '--custompost', nargs=2, help='Post a custom message. Specify an account then type the message. Make sure you use "" around the message. Use "all" for all accounts.')
parser.add_argument('-l', '--list', action='store_const', const='all', help='List all accounts.')
parser.add_argument('--version', action='version', version='%(prog)s 0.3.3')
args = parser.parse_args()
useArguments()

source d'informationauteur avacariu

  1. 11

    À fournir une coutume action pour un argument, et je cite:

    passage d'un objet qui implémente l'
    L'Action de l'API. La meilleure façon de le faire
    est d'étendre argparse.Action,
    l'approvisionnement approprié __call__
    la méthode. Le __call__ méthode
    accepter de quatre paramètres:

    1. analyseur: Le ArgumentParser objet qui contient cette action.
    2. espace de noms: L'espace de noms de l'objet qui sera retournée par parse_args(). La plupart des actions d'ajouter un attribut à cet objet.
    3. valeurs: La ligne de commande associés args, avec tout type de conversions appliquée.(Type de conversions sont spécifiés avec le type d'argument mot-clé à add_argument().
    4. option_string: La chaîne d'option qui a été utilisée pour exécuter cette action. Le option_string argument est facultatif, et sera absent, si l'action est associée à une position d'argument.
  2. 6

    Voir http://docs.python.org/library/argparse.html#sub-commands:

    Un moyen particulièrement efficace de la manipulation de sous-commandes, c'est de combiner l'utilisation de la add_subparsers() méthode avec des appels à set_defaults() de sorte que chaque subparser connaît la fonction Python il doit s'exécuter.

    En un mot:

    parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers()
weather_parser = subparsers.add_parser('get-weather')
weather_parser.add_argument('--bar')
weather_parser.set_defaults(function=get_weather)  # !
args = parser.parse_args(['get-weather', '--bar', 'quux'])
print args.function(args)

    Ici, nous créons un subparser pour la commande get-weather et affecter la fonction get_weather.

    Noter que la documentation dit que le mot-clé/attribut est nommé func mais il est certainement function de argparse 1.1.

    Le code résultant est un peu trop bavard donc, j'ai publié un petit paquet "argh" qui rend les choses plus simples, par exemple:

    parser = argparse.ArgumentParser()
add_commands(parser, [get_weather])
print dispatch(parser, ['get-weather', '--bar', 'quux'])

    "Argh" peut faire plus mais je vais laisser débordement de pile répondre. 🙂

  3. 4

    À l'exception de --versionce qui est très souvent une option, les actions que vous avez fournies sont mieux traités comme des "sous-commandes".

    Je suis pas au courant de la argparse les détails, que je n'ai pas encore essayer de Python 2.7, mais vous pouvez prendre un coup d'oeil à la svn de commande comme un exemple, voici un pseudo-code de la ligne de commande:

    myprog [--version] <command> [<command opts>...]

    Où <command>:

    add|edit|getweather|post|custompost|list

    Et <command opts> sont des options spécifiques à la commande. À l'aide de optparse (qui est similaire), cela signifie que votre commande serait retourné dans argslors de l'appel de parse_argsvous permettant de faire quelque chose comme ceci:

    opts, args = parser.parse_args()
if opts.version:
...
else:
getattr("do_" + args[0])(*args[1:])

    Je trouve ce modèle particulièrement utile pour le débogage, où j'avais donner accès à des fonctions internes à partir de la ligne de commande, et de passer les différents arguments pour les tests. Ajuster la sélection du gestionnaire de commande en fonction de votre propre projet.