HTML-Dokument in Python bearbeiten
DOM-Namensraum
Aspose.HTML for Python via .NET ermöglicht Ihnen den Zugriff auf und die Bearbeitung von HTML DOM (Document Object Model) in der Sprache Python. Der aspose.html.dom Namespace bietet eine API für die Interaktion mit HTML-, XML- und SVG-Dokumenten. Er stellt das Dokument als Knotenbaum dar, wobei jeder Knoten einen Teil des Dokuments repräsentiert, z. B. ein Element, einen Textstring oder einen Kommentar. Der Namespace umfasst Klassen wie Attr, CharacterData, Comment und andere, die jeweils einem bestimmten Zweck innerhalb des Dokumentenmodells dienen.
Die Klasse Document repräsentiert das gesamte HTML-, XML- oder SVG-Dokument und dient als Wurzel des Dokumentbaums. Andere Klassen wie Element, Node, DocumentFragment und EventTarget bieten Zugriff auf verschiedene Teile des Dokuments und ermöglichen die Manipulation und Interaktion mit den Daten des Dokuments. Die API basiert auf dem WHATWG DOM Standard. Daher ist es einfach, Aspose.HTML for Python via .NET zu verwenden, wenn man Grundkenntnisse in den Sprachen HTML und JavaScript hat.
HTML bearbeiten
Um ein HTML-Dokument mit Hilfe des DOM-Baums zu bearbeiten, verwenden Sie die Klasse HTMLDocument, die das gesamte Dokument darstellt. Es gibt viele Möglichkeiten, wie Sie HTML mit unserer Python-Bibliothek bearbeiten können. Sie können das Dokument ändern, indem Sie neue Knoten einfügen, entfernen oder den Inhalt bestehender Knoten bearbeiten. Wenn Sie ein neues Element oder einen neuen Knoten erstellen müssen, sind die folgenden Methoden aufzurufen:
- create_element(
local_name) zur Erzeugung neuer Elemente wie<style>und<p>; - get_elements_by_tag_name(
tagname), um eine Liste der vorhandenen Elemente eines bestimmten Tagnamens zu erhalten; - get_element_by_id(
element_id), um das erste Element mit einem bestimmten ID-Attribut mit dem angegebenen Wert zurückzugeben; - create_text_node(
data) zum Hinzufügen von Textinhalten.
Um Elementattribute zu manipulieren, verwenden Sie die Methoden:
- set_attribute(
qualified_name, value) fügt ein neues Attribut hinzu und setzt seinen Wert. Wenn ein Attribut mit diesem Namen bereits in dem Element vorhanden ist, wird sein Wert in den des Parametersvaluegeändert; - get_attribute(
qualified_name) ruft den Wert eines Attributs nach seinem Namen ab.
Sobald Sie neue Knoten erstellt haben, gibt es mehrere Methoden im DOM, mit denen Sie Knoten in den Dokumentbaum einfügen können. Die folgende Liste beschreibt die gängigsten Methoden zum Einfügen oder Entfernen von Knoten:
- Die Methode
append_child(
node) wird verwendet, um Elemente oder Knoten zu bestehenden Elementen hinzuzufügen; - Die Methode
insert_before(
node, child) fügt dennodevor dem vorhandenen Kindknotenchildein. Wenn einchildnull ist, wird einKnotenam Ende der Liste der Kinder eingefügt. - Die Methode remove() entfernt diese Instanz aus dem HTML-DOM-Baum.
- Die Methode
remove_child(
child) entfernt den Kindknoten aus der Liste der Kinder.
Eine vollständige Liste der im DOM-Namensraum vertretenen Klassen und Methoden finden Sie unter API-Referenzquelle.
Bearbeiten eines Dokumentenbaums
Aspose.HTML Python API unterstützt eine Reihe von HTML-Elementen, die im HTML-Standard definiert sind, zusammen mit Regeln darüber, wie die Elemente verschachtelt werden können. Betrachten Sie einfache Schritte, um HTML von Grund auf zu erstellen und es mit einem DOM-Baum und den oben genannten Funktionen zu bearbeiten. Das Dokument wird einen Textabsatz mit dem Attribut id enthalten:
- Verwenden Sie den HTMLDocument() Konstruktor, um eine Instanz eines HTML-Dokuments zu erstellen.
- Die Eigenschaft “body” der Klasse
HTMLDocument verweist auf das Element
<body>des Dokuments. - Verwenden Sie die Methode
create_element() von
HTMLDocument, um ein Absatzelement<p>zu erstellen. - Verwenden Sie die Methode
set_attribute(), um das Attribut
idfür das Element paragraph zu setzen. - Erstellen Sie einen Textknoten mit der Methode create_text_node().
- Fügen Sie diesen Textknoten dem Absatzelement mit der Methode append_child() hinzu.
- Fügen Sie das Absatzelement in den
<body>des Dokuments mit der Methodeappend_child()ein. - Speichern Sie das HTML-Dokument in einer Datei.
Dieser Code zeigt, wie man ein einfaches HTML-Dokument programmatisch erstellt, einen Absatz mit einem Attribut und Text hinzufügt und den resultierenden HTML-Code in einer Datei speichert:
1import os
2from aspose.html import *
3
4# Define the output directory and file path
5output_dir = "output/"
6output_path = os.path.join(output_dir, "edit-document-tree.html")
7
8# Ensure the output directory exists
9os.makedirs(output_dir, exist_ok=True)
10
11# Create an instance of an HTML document
12document = HTMLDocument()
13
14# Access the document <body> element
15body = document.body
16
17# Create a paragraph element <p>
18p = document.create_element("p")
19
20# Set a custom attribute
21p.set_attribute("id", "my-paragraph")
22
23# Create a text node
24text = document.create_text_node("The Aspose.Html.Dom namespace provides an API for representing and interfacing with HTML, XML, or SVG documents.")
25
26# Add the text to the paragraph
27p.append_child(text)
28
29# Attach the paragraph to the document body
30body.append_child(p)
31
32# Save the HTML document to a file
33document.save(output_path)Betrachten wir nun die Erstellung eines komplexeren HTML-Dokuments. Im folgenden Codeschnipsel werden wir ein HTML-Dokument von Grund auf neu konstruieren, neue Elemente erstellen, sie mit Inhalt füllen und sie der HTML-Dokumentstruktur hinzufügen. Das HTML-DOM-Modell und die oben erwähnten Funktionen werden uns dabei helfen.
- Verwenden Sie den Konstruktor
HTMLDocument(), um ein neues HTMLDocument Objekt zu initialisieren, das das HTML-Dokument darstellt. - Verwenden Sie die
create_element() Methode von
HTMLDocument, um ein<style>Element zu erzeugen. - Weisen Sie dem Stilelement CSS-Regeln zu, indem Sie die Eigenschaft text_content verwenden.
- Das Element
<head>wird mit der Methode get_elements_by_tag_name() abgerufen. - Anhängen des Elements
<style>an das Element<head>mit der Methode append_child(). - Verwenden Sie die Methode
create_element(), um ein
<p>Absatzelement zu erstellen. - Setzen Sie die Eigenschaft “class_name” des Absatzes, um die gewünschten CSS-Stile anzuwenden.
- Erstellen Sie einen Textknoten mit der Methode create_text_node().
- Fügen Sie diesen Textknoten mit der Methode “append_child()” an das Absatzelement an.
- Fügen Sie das Absatzelement in den
<body>des Dokuments ein, indem Sie die Methodeappend_child()für die Eigenschaftbodyverwenden. - Rufen Sie die Methode
save()vonHTMLDocumentauf, um das Dokument in dem angegebenen HTML-Dateipfad zu speichern.
1import os
2from aspose.html import *
3from aspose.html.saving import *
4
5# Define output directory and file paths
6output_dir = "output/"
7save_path = os.path.join(output_dir, "edit-document.html")
8
9# Ensure the output directory exists
10os.makedirs(output_dir, exist_ok=True)
11
12# Create an instance of an HTML document
13document = HTMLDocument()
14
15# Create a style element and set the teal color for elements with class "col"
16style = document.create_element("style")
17style.text_content = ".col { color: teal }"
18
19# Find the document <head> element and append the <style> element
20head = document.get_elements_by_tag_name("head")[0]
21head.append_child(style)
22
23# Create a paragraph <p> element with class "col"
24p = document.create_element("p")
25p.class_name = "col"
26
27# Create a text node
28text = document.create_text_node("Edit HTML document")
29
30# Append the text node to the paragraph
31p.append_child(text)
32
33# Append the paragraph to the document <body>
34document.body.append_child(p)
35
36# Save the HTML document to a file
37document.save(save_path)Die API-Referenzquelle enthält eine umfassende Liste der Klassen und Methoden im DOM-Namensraum.
Verwendung der Eigenschaften inner_html und outer_html
Die Arbeit mit DOM-Objekten bietet eine leistungsfähige Möglichkeit, ein HTML-Dokument in Python zu manipulieren. In einigen Fällen kann es jedoch bequemer sein, direkt mit Strings zu arbeiten. Die Eigenschaften inner_html und outer_html werden verwendet, um auf HTML-Inhalte in einem Dokument zuzugreifen und sie zu manipulieren, aber sie unterscheiden sich darin, was sie darstellen und wie sie verwendet werden:
- Die Eigenschaft inner_html stellt den HTML-Inhalt innerhalb eines Elements dar, mit Ausnahme der eigenen Start- und End-Tags des Elements.
- Die Eigenschaft outer_html stellt den gesamten HTML-Inhalt eines Elements dar, einschließlich seiner eigenen Start- und End-Tags.
Der folgende Codeschnipsel zeigt Ihnen, wie Sie die Eigenschaften inner_html und outer_html der Klasse
Element zur Bearbeitung von HTML verwenden können.
1from aspose.html import *
2
3# Create an instance of an HTML document
4document = HTMLDocument()
5
6# Write the content of the HTML document to the console
7print(document.document_element.outer_html) # output: <html><head></head><body></body></html>
8
9# Set the content of the body element
10document.body.inner_html = "<p>HTML is the standard markup language for Web pages.</p>"
11
12# Find the document <p> element
13p = document.get_elements_by_tag_name("p")[0]
14
15# Write the content of the <p> element to the console
16print(p.inner_html) # output: HTML is the standard markup language for Web pages.
17
18# Write the updated content of the HTML document to the console
19print(document.document_element.outer_html) # output: <html><head></head><body><p>HTML is the standard markup language for Web pages.</p></body></html>CSS bearbeiten
Cascading Style Sheets (CSS) ist eine Stylesheet-Sprache, mit der beschrieben wird, wie Webseiten in einem Browser erscheinen. CSS kann HTML-Dokumenten auf Inline-, interne und externe Weise hinzugefügt werden. So können Sie einen einzigartigen Stil für ein einzelnes HTML-Element mit Inline-CSS definieren oder für mehrere Webseiten eine gemeinsame Formatierung festlegen, indem Sie das entsprechende CSS in einer separaten .css-Datei angeben. Aspose.HTML for Python via .NET unterstützt nicht nur CSS out-of-the-box, sondern gibt Ihnen auch Instrumente an die Hand, mit denen Sie Dokumentstile direkt vor der Konvertierung des HTML-Dokuments in andere Formate manipulieren können, wie im Folgenden beschrieben.
Inline-CSS
Wenn CSS mit dem Attribut style innerhalb eines HTML-Tags geschrieben wird, nennt man es “Inline-CSS”. Mit dem Inline-CSS können Sie einen individuellen Stil auf jeweils ein HTML-Element anwenden. Sie legen CSS für ein HTML-Element fest, indem Sie das Attribut style mit allen darin definierten CSS-Eigenschaften verwenden.
Im folgenden Codeschnipsel sehen Sie, wie Sie CSS-Stileigenschaften für ein HTML-Element <p> festlegen können.
1import os
2from aspose.html import *
3from aspose.html.rendering.pdf import *
4
5# Define the content of the HTML document
6content = "<p>Edit inline CSS using Aspose.HTML for Python via .NET</p>"
7
8# Create an instance of an HTML document with specified content
9document = HTMLDocument(content, ".")
10
11# Find the paragraph element and set a style attribute
12paragraph = document.get_elements_by_tag_name("p")[0]
13paragraph.set_attribute("style", "font-size: 150%; font-family: arial; color: teal")
14
15# Save the HTML document to a file
16output_dir = "output/"
17os.makedirs(output_dir, exist_ok=True)
18html_path = os.path.join(output_dir, "edit-inline-css.html")
19document.save(html_path)
20
21# Create an instance of the PDF output device and render the document to this device
22pdf_path = os.path.join(output_dir, "edit-inline-css.pdf")
23with PdfDevice(pdf_path) as device:
24 document.render_to(device)In diesem speziellen Beispiel gelten Farbe, Schriftgröße und Schriftart für das Element <p>. Das Fragment der gerenderten PDF-Seite sieht wie folgt aus:
Internes CSS
Die interne CSS-Styling-Option ist beliebt für die Anwendung von Eigenschaften auf einzelne Seiten, indem alle Stile in das <style>-Element eingeschlossen werden, das im <head> von HTML-Dokumenten platziert ist.
1import os
2from aspose.html import *
3from aspose.html.rendering.pdf import *
4
5
6# Define the content of the HTML document
7content = "<div><h1>Internal CSS</h1><p>An internal CSS is used to define a style for a single HTML page</p></div>"
8
9# Create an instance of an HTML document with specified content
10document = HTMLDocument(content, ".")
11
12# Create a <style> element and define internal CSS rules
13style = document.create_element("style")
14style.text_content = (
15 ".frame1 { margin-top:50px; margin-left:50px; padding:25px; width:360px; height:90px; "
16 "background-color:#82011a; font-family:arial; color:#fff5ee;} \r\n"
17 ".frame2 { margin-top:-70px; margin-left:160px; text-align:center; padding:20px; width:360px; "
18 "height:100px; background-color:#ebd2d7;}"
19)
20
21# Find the <head> element and append the <style> element
22head = document.get_elements_by_tag_name("head")[0]
23head.append_child(style)
24
25# Find the <h1> element and apply styles
26header = document.get_elements_by_tag_name("h1")[0]
27header.class_name = "frame1"
28
29# Update the style of <h1> using the style attribute directly
30header.set_attribute("style", "font-size: 200%; text-align: center;")
31
32# Find the paragraph element and apply styles
33paragraph = document.get_elements_by_tag_name("p")[0]
34paragraph.class_name = "frame2"
35paragraph.set_attribute("style", "color: #434343; font-size: 150%; font-family: verdana;")
36
37# Save the HTML document to a file
38output_dir = "output/"
39os.makedirs(output_dir, exist_ok=True)
40html_path = os.path.join(output_dir, "edit-internal-css.html")
41document.save(html_path)
42
43# Create an instance of the PDF output device and render the document to this device
44pdf_path = os.path.join(output_dir, "edit-internal-css.pdf")
45with PdfDevice(pdf_path) as device:
46 document.render_to(device)In diesem Beispiel verwenden wir internes CSS und deklarieren zusätzliche Stileigenschaften für einzelne Elemente, indem wir das Attribut style innerhalb der Tags <h1> und <p> verwenden. Die Abbildung veranschaulicht das Fragment der gerenderten Datei “edit-internal-css.pdf”:
Laden Sie die Bibliothek Aspose.HTML for Python via .NET herunter, um Ihre HTML-Dokumente erfolgreich, schnell und einfach zu bearbeiten. Die Python-Bibliothek kann HTML-Dokumente erstellen, ändern, Daten extrahieren, konvertieren und rendern, ohne dass externe Software erforderlich ist. Sie unterstützt gängige Dateiformate wie EPUB, MHTML, XML, SVG und Markdown und kann in die Dateiformate PDF, DOCX, XPS und Image rendern.