Wie soll ich meine Funktionen mit Pyparsing organisieren?

Question

Ich analysiere eine Datei mit Python und Pyparsing (Es ist die Berichtsdatei für Psat in Matlab, aber das ist nicht wichtig). hier ist was ich bisher habe. Ich denke, es ist ein Chaos und möchte Ratschläge zur Verbesserung. Insbesondere, wie soll ich meine Grammatikdefinitionen mit Pyparsing organisieren?

Sollte ich alle meine Grammatikdefinitionen in einer Funktion haben? Wenn ja, wird es eine große Funktion sein. Wenn nicht, wie breche ich es dann aus? Im Moment habe ich es in den Abschnitten der Datei geteilt. Lohnt es sich, viele Funktionen zu erstellen, die nur einmal von einem Ort ausgerufen werden? Weder fühlt sich für mich wirklich richtig.

Sollte ich alle meine Eingabe- und Ausgabecode in eine separate Datei in die anderen Klassenfunktionen platzieren? Es würde den Zweck der Klasse viel klarer machen.

Ich bin auch interessiert zu wissen, ob es eine einfachere Möglichkeit gibt, eine Datei zu analysieren, einige Gesundheitsprüfungen durchzuführen und die Daten in einer Klasse zu speichern. Ich scheine viel Zeit damit zu verbringen.

(Ich werde Antworten von akzeptieren es ist gut genug oder Verwenden Sie X anstelle von Pyparsing Wenn Menschen zustimmen)

Answer 1

Ich könnte in beide Richtungen mit einer einzigen großen Methode gehen, um Ihren Parser zu erstellen, als wenn Sie ihn in die Art und Weise unternehmen, wie Sie ihn jetzt haben.

Ich kann sehen, dass Sie einige nützliche Helfer -Dienstprogramme definiert haben, wie z. Das sieht für mich gut aus.

Ich mag es, dass Sie Ergebnissenamen verwenden, sie verbessern die Robustheit Ihres Nachparing-Codes wirklich. Ich würde empfehlen, das Verknüpfungsformular zu verwenden, das in Pyparsing 1.4.7 hinzugefügt wurde, in dem Sie ersetzen können

busname.setResultsName("bus1")

mit

busname("bus1")

Dies kann Ihren Code ziemlich viel entstöbern.

Ich würde durch Ihre Parse -Aktionen zurückblicken, um zu sehen, wo Sie numerische Indizes verwenden, um auf einzelne Token zuzugreifen, und stattdessen zurückgehen und die Ergebnisnamen zuweisen. Hier ist ein Fall, in dem GetStats zurückkehrt (ngroup + sgroup).setParseAction(self.process_stats). Process_Stats hat Referenzen wie:

self.num_load = tokens[0]["loads"]
self.num_generator = tokens[0]["generators"]
self.num_transformer = tokens[0]["transformers"]
self.num_line = tokens[0]["lines"]
self.num_bus = tokens[0]["buses"]
self.power_rate = tokens[1]["rate"]

Ich mag es, dass Sie die Werte und die Statistiken gruppiert haben, aber geben Sie ihnen Namen wie "Netzwerk" und "Soln". Dann können Sie diesen Parse-Aktionscode als (ich habe auch in die-leichter zu lesende Notation von Objekt-Attribute anstelle der Diktelelementnotation konvertiert) schreiben:

self.num_load = tokens.network.loads
self.num_generator = tokens.network.generators
self.num_transformer = tokens.network.transformers
self.num_line = tokens.network.lines
self.num_bus = tokens.network.buses
self.power_rate = tokens.soln.rate

Auch eine Stilfrage: Warum verwenden Sie manchmal den expliziten und Konstruktor, anstatt den '+' -Preiber zu verwenden?

busdef = And([busname.setResultsName("bus1"),
            busname.setResultsName("bus2"),
            integer.setResultsName("linenum"),
            decimaltable("pf qf pl ql".split())])

Dies ist genauso leicht zu schreiben:

busdef = (busname("bus1") + busname("bus2") + 
            integer("linenum") + 
            decimaltable("pf qf pl ql".split()))

Insgesamt denke ich, dass dies für eine Datei über diese Komplexität ums Leben kostet. Ich habe ein ähnliches Format (leider nicht proprietär, in dem ich nicht geteilt werden kann), in dem ich den Code in Stücken erstellt habe, die der Art und Weise ähnlich sind, aber in einer großen Methode so etwas wie folgt:

def parser():
    header = Group(...)
    inputsummary = Group(...)
    jobstats = Group(...)
    measurements = Group(...)
    return header("hdr") + inputsummary("inputs") + jobstats("stats") + measurements("meas")

Die Gruppenkonstrukte sind besonders in einem großen Parser wie diesem hilfreich, um eine Art Namespace für Ergebnissenamen in jedem Abschnitt der analysierten Daten festzulegen.