Comment intégrer des options argparse dans la classe python?

Question

Je suis assez nouveau à Python OOP, donc j'ai eu une certaine confusion.

Actuellement, j'ai:

parser = argparse.ArgumentParser(description='script 1.0') 
parser.add_argument('-a', '--foo', help='specify foo') 
parser.add_argument('-b', '--bar', type=int, help='specify bar') 
parser.add_argument('-c', '--baz', help='specify baz') 
parser.add_argument('-d', '--bar2', help='bar2') 

args = parser.parse_args() 

foo = args.foo 
bar = args.bar 
baz = args.baz 
bar2 = args.bar2 

qui fonctionne assez bien, mais je blême de créer une classe pour l'ensemble de mon script et faire argparse comme méthode d'une classe (est-il possible?).

donc j'ai essayé:

 import argparse 
     .... 

     Class Program: 
      def __init__(self, foo, bar, baz, bar2): 
       self.foo = foo 
       self.bar = bar 
       ...(so on for each arg) 
      def main(): 
       parser = argparse.ArgumentParser(description='script 1.0') 
       parser.add_argument('-a', '--foo', help='specify foo') 
       parser.add_argument('-b', '--bar', type=int, help='specify bar') 
       parser.add_argument('-c', '--baz', help='specify baz') 
       parser.add_argument('-d', '--bar2', help='bar2') 

       args = parser.parse_args() 

       foo = self.foo 
       bar = self.bar 
       baz = self.baz 
       bar2 = self.bar2 

Je ne pense pas que je suis en train de faire, cependant. Je n'ai pas trouvé trop d'informations à ce sujet mais un post sur SO qui n'a pas clarifié la situation pour moi, donc je veux avoir des opinions pour mon cas spécifique

Answer 1

argparse est déjà fait usage des classes. argparse.ArgumentParser(...) crée un objet analyseur. parser.add_argument(...) crée un objet Action et le place dans une liste parser. Il renvoie également à votre code, qui peut être utile dans certains cas. parse_args() renvoie un objet argparse.Namespace.

Vous pouvez sous-classer les classes argparse pour personnaliser leurs performances.

Mais généralement, vous n'avez pas besoin de créer votre propre classe parser - sauf si vous avez besoin d'un comportement particulier.

Voici ce que je considère être une utilisation propre de argparse:

import argparse 

# your code 
def main(args): 
    foo = args.foo 
    # other uses of args 

def other(foo, bar): 
    # code using values 

def make_parser(): 
    parser = argparse.ArgumentParser(description='script 1.0') 
    parser.add_argument('-a', '--foo', help='specify foo') 
    parser.add_argument('-b', '--bar', type=int, help='specify bar') 
    parser.add_argument('-c', '--baz', help='specify baz') 
    parser.add_argument('-d', '--bar2', help='bar2') 
    return parser 

if __name__ == '__main__': 
    parser = make_parser() 
    args = parser.parse_args() 

Emballage la définition de l'analyseur en fonction est une bonne idée. Dans des cas plus complexes, cela pourrait être une classe. Mais normalement, vous n'avez besoin que d'un analyseur par script, donc une fonction suffit. Cette fonction peut être dans le corps principal du script, mais l'utilisation réelle doit être dans un bloc if __name__, de sorte que le script peut être importé sans utiliser l'analyseur.

Ceci place l'espace de noms args dans l'environnement global, où est accessible tout votre code. Il peut être transmis à vos fonctions ou valeurs sélectionnées peuvent être transmises:

main(args) 
other(args.foo, args.bar) 
foo = args.foo 
do_things3(foo) 
d = vars(args) # args in dictionary form 

Il est une bonne idée d'écrire votre code afin qu'il fonctionne en tant que classes importées et/ou fonctions, et lorsqu'il est exécuté comme un script. La partie argparse définit les valeurs lorsqu'elle est exécutée en tant que script. Une fois importé, le script d'importation définit les valeurs de contrôle nécessaires, éventuellement avec le sien parser.