Rufen Sie Optionen in Python sowohl aus JSON-Dateien als auch aus Befehlszeilenargumenten ab

Dies ist die Python-Version eines anderen Artikels, "Abrufen von Optionen in Ruby aus JSON-Dateien und Befehlszeilenargumenten" (https://qiita.com/aikige/items/014139c0b1ae70139477). Da die Verwendung von Python heutzutage zunimmt, werde ich das Ergebnis der Untersuchung darüber teilen, wie man dasselbe mit Python schreibt.

Basiskonzept

1. Sammeln Sie Optionen in einem Objekt. Beispiel: Klassenoptionen
2. Lesen Sie beim Erstellen des Objekts Optionen aus der JSON-Datei. Beispiel: opt = Options ('some.json') liest Optionen aus einer JSON-Datei.
3. Verwenden Sie das Objektattribut, um auf Optionen zuzugreifen. Beispiel: Sie können wie opt.option_1 darauf zugreifen.
4. Erfassen Sie Befehlszeilenargumente mit Argparse.
5. Das optionale Objekt verfügt über eine Methode zum Abrufen des Werts aus dem von Arguparse generierten Ergebnis. Beispiel: Importieren Sie mit so etwas wie "opt.import_opt (options)".

Implementierungsbeispiel

https://gist.github.com/aikige/470f4ef93753638cc3a18d62e195eb19

#!/usr/bin/env python

import json
import os

class Options:
    OPTS = { 'option_1': 'bool', 'option_2': 'str' }

    def __init__(self, filename='config.json'):
        if (os.path.exists(filename)):
            with open(filename) as f:
                self.import_dict(json.load(f))

    def import_attr(self, key, value):
        if (value is None):
            return
        if (isinstance(value, eval(self.OPTS[key]))):
            setattr(self, key, value)
        else:
            raise ValueError("invalid type")

    def import_dict(self, d):
        for key in self.OPTS.keys():
            if (key in d.keys()):
                self.import_attr(key, d[key])

    def import_opt(self, args):
        for key in self.OPTS.keys():
            if (hasattr(args, key)):
                self.import_attr(key, getattr(args, key))

if __name__ == '__main__':
    import argparse

    opt = Options()
    print(vars(opt))

    parser = argparse.ArgumentParser()
    parser.add_argument('-1', '--option_1', action='store_true', default=None)
    parser.add_argument('-2', '--option_2', type=str)
    args = parser.parse_args()
    print(vars(args))
    opt.import_opt(args)
    print(vars(opt))

Hauptunterschiede zu Ruby-Version

1. Im Gegensatz zu Ruby hat Python einen Typ "bool", sodass die Typbestimmung relativ einfach integriert werden kann ("import_attr").
2. Im Fall von Python wird Arrgparse für die Optionsanalyse verwendet, sodass die Methoden für die JSON-Analyse und die Argumentanalyse nicht einheitlich sind. Leicht überflüssig.
3. Im Fall von Python scheint es ein wenig schwierig zu sein, das Attribut schreibgeschützt zu machen, daher habe ich es weggelassen.