Praktisches Tutorial zur Kombination von Python und XML

Dieses Mal bringe ich Ihnen ein praktisches Tutorial zum Kombinieren von Python und XML. Was sind die Vorsichtsmaßnahmen für die Kombination von Python und XML? Hier sind praktische Fälle.

Der Name dieses Projekts heißt nicht Universal XML, es ist besser, es als automatische Website-Erstellung zu bezeichnen. Basierend auf einer XML-Datei wird jedoch eine Website entsprechend der Verzeichnisstruktur generiert Nur HTML ist immer noch zu einfach. Es wäre leistungsfähiger, wenn es CSS zusammen generieren könnte. Dies muss in Zukunft weiterentwickelt werden. Lassen Sie uns zunächst untersuchen, wie die HTML-Website strukturiert wird. Da die Website durch eine XML-Struktur generiert wird, sollte alles aus dieser XML-Datei stammen. Werfen wir zunächst einen Blick auf diese XML-Datei, website.xml:

<website>
 <page>
 <h1 id="Welcome-to-my-Home-page">Welcome to my Home page</h1>
 <p>Hi, there. My name is Mr.gumby,and this is my home page,here are some of my int:</p>
 <ul>
  <li><a>Shouting</a></li>
  <li><a>Sleeping</a></li>
  <li><a>Eating</a></li>
 </ul>
 </page>
 <directory>
  <page>
   <h1 id="shouting-page">shouting page</h1>
   <p>....</p>
  </page>
  <page>
   <h1 id="sleeping-page">sleeping page</h1>
   <p>...</p>
  </page>
  <page>
    <h1 id="Eating-page">Eating page</h1>
    <p>....</p>
  </page>
 </directory>
</website>

Mit dieser Datei schauen wir uns an, wie man mithilfe dieser Datei eine Website generiert.

Zuerst müssen wir diese XML-Datei auf die gleiche Weise analysieren wie in Java. Der Unterschied zwischen den beiden Verarbeitungsmethoden liegt in der Geschwindigkeit und im Umfang Es wird jeweils nur ein kleiner Teil des Dokuments verarbeitet, wodurch der Speicher schnell und effektiv genutzt werden kann. Letzteres ist die umgekehrte Verarbeitungsmethode: Laden Sie zunächst alle Dokumente in den Speicher und verarbeiten Sie sie dann mehr Speicher Der einzige Vorteil besteht darin, dass Sie das gesamte Dokument bearbeiten können.

Um Sax zum Verarbeiten von XML in Python zu verwenden, müssen Sie zunächst die Parse-Funktion in xml.sax und den ContentHandler in xml.sax.handler einführen. Letztere Klasse wird in Verbindung mit der Parse-Funktion verwendet. Die Verwendung ist wie folgt: parse('xxx.xml',xxxHandler), der xxxHandler hier muss den obigen ContentHandler erben, aber er erbt ihn einfach, es ist nichts erforderlich. Wenn die Analysefunktion dann die XML-Datei verarbeitet, ruft sie die Funktion startElement und endElement in xxxHandler auf, um das Tag in XML zu starten und zu beenden. Der mittlere Prozess verwendet eine Funktion namens Zeichen, um alle Zeichenfolgen innerhalb des Tags zu verarbeiten.

Mit dem obigen Verständnis wissen wir bereits, wie man XML-Dateien verarbeitet und sich dann die Datei website.xml, die Quelle des Bösen, ansieht und ihre Struktur analysiert. Es gibt nur zwei Knoten: Seite und Verzeichnis. Es ist offensichtlich, dass die Seite eine Seite darstellt und das Verzeichnis ein Verzeichnis darstellt.

Damit wird die Idee der Verarbeitung dieser XML-Datei klar. Lesen Sie jeden Knoten der XML-Datei und bestimmen Sie dann, ob es sich um eine Seite oder ein Verzeichnis handelt. Wenn es sich um eine Seite handelt, erstellen Sie eine HTML-Seite und schreiben Sie dann den Inhalt des Knotens in die Datei. Wenn ein Verzeichnis gefunden wird, erstellen Sie einen Ordner und verarbeiten Sie dann den darin enthaltenen Seitenknoten (falls vorhanden).
Schauen wir uns diesen Teil des Codes an. Die Implementierung im Buch ist komplexer und flexibler. Schauen wir es uns zuerst an und analysieren wir es dann.

from xml.sax.handler import ContentHandler
from xml.sax import parse
import os
class Dispatcher:
    def dispatch(self, prefix, name, attrs=None):
        mname = prefix + name.capitalize()
        dname = 'default' + prefix.capitalize()
        method = getattr(self, mname, None)
        if callable(method): args = ()
        else:
            method = getattr(self, dname, None)
            args = name,
        if prefix == 'start': args += attrs,
        if callable(method): method(*args)
    def startElement(self, name, attrs):
        self.dispatch('start', name, attrs)
    def endElement(self, name):
        self.dispatch('end', name)
class WebsiteConstructor(Dispatcher, ContentHandler):
    passthrough = False
    def init(self, directory):
        self.directory = [directory]
        self.ensureDirectory()
    def ensureDirectory(self):
        path = os.path.join(*self.directory)
        print path
        print '----'
        if not os.path.isdir(path): os.makedirs(path)
    def characters(self, chars):
        if self.passthrough: self.out.write(chars)
    def defaultStart(self, name, attrs):
        if self.passthrough:
            self.out.write('')
    def defaultEnd(self, name):
        if self.passthrough:
            self.out.write('%s>' % name)
    def startDirectory(self, attrs):
        self.directory.append(attrs['name'])
        self.ensureDirectory()
    def endDirectory(self):
        print 'endDirectory'
        self.directory.pop()
    def startPage(self, attrs):
        print 'startPage'
        filename = os.path.join(*self.directory + [attrs['name']+'.html'])
        self.out = open(filename, 'w')
        self.writeHeader(attrs['title'])
        self.passthrough = True
    def endPage(self):
        print 'endPage'
        self.passthrough = False
        self.writeFooter()
        self.out.close()
    def writeHeader(self, title):
        self.out.write('\n \n  <title>')
        self.out.write(title)
        self.out.write('</title>\n \n \n')
    def writeFooter(self):
        self.out.write('\n \n\n')
parse('website.xml',WebsiteConstructor('public_html'))

Es scheint, dass die Analyse dieses Programms etwas komplizierter ist, aber der große Mann Maomao sagte, dass jedes komplexe Programm ein Papiertiger sei. Dann analysieren wir dieses Programm noch einmal.

Zuerst habe ich gesehen, dass dieses Programm zwei Klassen hat. Aufgrund der Vererbung kann es tatsächlich als eine Klasse betrachtet werden.

Dann schauen wir uns an, was es sonst noch hat: startPage, endDirectory, writeFooter; . diese Funktionen. Mit Ausnahme des Versands sind die vorherigen Funktionen leicht zu verstehen. Jedes Funktionspaar verarbeitet einfach das entsprechende HTML-Tag und den XML-Knoten. Der Versand ist komplizierter, da er zum dynamischen Kombinieren und Ausführen von Funktionen verwendet wird.

Die Verarbeitungsidee des Versands besteht darin, anhand der übergebenen Parameter (dh des Operationsnamens und des Knotennamens) zunächst festzustellen, ob eine entsprechende Funktion wie startPage vorhanden ist der Standard- und Operationsname: z. B. defaultStart.

Nachdem Sie jede Funktion einzeln verstanden haben, wissen Sie, wie der gesamte Verarbeitungsablauf aussieht. Erstellen Sie zunächst eine public_html-Datei, um die gesamte Website zu speichern, lesen Sie dann die XML-Knoten und rufen Sie den Dispatch über startElement und endElement zur Verarbeitung auf. Dann gibt es noch die Art und Weise, wie der Versand die spezifische Verarbeitungsfunktion aufruft. Zu diesem Zeitpunkt ist die Analyse dieses Projekts abgeschlossen.

Der Hauptinhalt, den es zu beherrschen gilt, ist die Verwendung von SAX zur Verarbeitung von XML in Python, und der andere ist die Verwendung von Funktionen in Python, wie z. B. getattr, Sternchen beim Übergeben von Parametern ...

Ich glaube, Sie haben diesen Artikel gelesen. Sie beherrschen die Fallmethode. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!

Empfohlene Lektüre:

So schreiben Sie Daten in einem Datenrahmen in die Datenbank in Python

Objektlebenszyklus in Python-Replikation. Verwendung von

Das obige ist der detaillierte Inhalt vonPraktisches Tutorial zur Kombination von Python und XML. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!