Python - HTML-Generator, Teil 2

Im ersten Teil unseres Tutorials haben wir es geschafft, dass unser Programm eine Textdatei nimmt und Blöcke mit den darin enthaltenen Absätzen generiert.
Zweite Iteration
Wie wir am Anfang sagten, müssen wir tun das modularste Programm und um dies zu erreichen, müssen wir unsere objektorientierter Code.
Dazu müssen wir die notwendigen Abstraktionen vornehmen, damit wir Klassen bauen können, die die Methoden enthalten, die unsere Ziele erreichen.
Anforderungen
Lassen Sie uns eine Liste der Komponenten erstellen, die wir erstellen müssen, damit wir wissen, was wir haben müssen, damit unser Programm vollständiger ist:

• EIN Parser, Dieses Objekt ermöglicht es uns, den Text zu lesen und die anderen Klassen zu behandeln.
• Regeln, Wir werden für jede Art von Block eine Regel erstellen, damit wir erkennen können, welche Art von Block wir haben und welches Format wir darauf anwenden sollten.
• Filter, mit ihnen werden wir reguläre Ausdrücke integrieren, um einige interne Elemente handhaben zu können.
• Handler, diese Handler werden von den Parser um die verarbeitete Ausgabe zu erzeugen. Jeden handler es wird in der Lage sein, eine andere Art von Etiketten zu handhaben.

Handler
Diese Klasse ermöglicht es uns, bestimmte Typen von Labels für die Ausgaben zu behandeln. Sehen wir uns den Code an, den sie enthalten kann:

Dann müssen wir eine Superklasse bauen Handler, das wird es uns ermöglichen, die verschiedenen zu verwalten Handler das brauchen wir. Dazu sehen wir folgenden Code:

 class Handler: def callback (self, prefix, name, * args): method = getattr (self, prefix + name, None) falls aufrufbar (method): return method (* args) def start (self, name): self. callback ('start_', name) def end (self, name): self.callback ('end_', name) def sub (self, name): def substitution (match): result = self.callback ('sub_', name, match) default = match.group (0) Ergebnis zurückgeben oder Standard-Ersetzung zurückgeben 

Wenn wir jetzt eine kleine Übung machen, können wir unsere bisherigen Fortschritte sehen:

 >>> from handlers import HTMLRenderer >>> handler = HTMLRenderer () >>> import re >>> re.sub (r '\ * (. +?) \ *', handler.sub ('emphasis'),' Dies * ist * ein Test ')' Dies ist ein nachweisen' 

Wie wir im vorherigen Aufruf sehen, importieren wir zuerst unsere Klasse HTMLRenderer was ist unser handler, dann importieren wir betreffend mit denen wir die regulären Ausdrücke behandeln werden, dann gehen wir zu re.sub der Ausdruck und die Methode, mit der er angewendet werden soll, dann der Text und schließlich sehen wir, dass die Ausgabe den erforderlichen HTML-Code generiert hat.
Regeln
Sobald wir die Handler haben, ist es an der Zeit, die Regeln zu erstellen. Sie werden uns helfen, den verschiedenen Blöcken ein Ziel zu geben, es muss jedoch objektorientiert sein, damit wir nicht mit einer großen Anzahl von Blöcken enden verschachtelt, wenn alle Fälle zu validieren.
Wir müssen auch eine Superklasse haben, die unsere Regeln verwaltet. Sehen wir uns den folgenden Code an, der die Superklasse enthält.

 class Regel: def action (self, block, handler): handler.start (self.type) handler.feed (block) handler.end (self.type) return True 

Wie wir die Methode sehen Aktion () den Block und die Art des zu verwendenden Handlers empfängt, kann anhand dieser Parameter unterscheiden, welchen Block er auf das, was er empfängt, anwenden muss, und somit den zu druckenden Code abschließen.
Damit beenden wir das Tutorial und überlassen es jedem weiterzumachen, bis wir das Projekt nach den eingangs im ersten Teil dieses Tutorials gegebenen Richtlinien fertig haben.Hat dir dieses Tutorial gefallen und geholfen?Sie können den Autor belohnen, indem Sie diesen Knopf drücken, um ihm einen positiven Punkt zu geben