Edit HTML Documents in Python

Aspose.HTML for Python via .NET represents HTML as a Document Object Model (DOM) tree. After creating or loading an HTMLDocument, you can create or remove nodes, update attributes and text, replace element markup, and change inline or internal CSS.

To edit HTML in Python, create or load an HTMLDocument, locate or create the required DOM node, modify it with methods such as create_element(), append_child(), or set_attribute(), and call save() to persist the result. Use inner_html when trusted markup should replace an element’s child content.

HTML DOM APIs for Editing

The DOM represents a document as a tree of nodes. The document is the root, elements define the structure, attributes describe elements, and text nodes hold character data. These concepts and operations are defined by the WHATWG DOM Standard. The aspose.html.dom module provides the core types used to inspect and modify that tree.

API	Purpose
Document	Represents the complete document tree and provides methods for creating nodes.
Node	Represents one node and provides tree operations such as appending, inserting, and removing children.
Element	Represents an element and provides access to attributes and serialized markup.
Attr	Represents an attribute associated with an element.

Common editing methods and properties include:

API	Use it to
create_element()	Create an element with the specified tag name.
create_text_node()	Create text that is not parsed as HTML markup.
query_selector()	Return the first element that matches a CSS selector.
append_child()	Add a node as the last child of another node.
insert_before()	Insert a node before an existing child.
remove_child()	Remove a child node from its parent.
set_attribute()	Add an attribute or replace its value.
get_attribute()	Read an attribute value.
inner_html	Get or replace the markup inside an element.
outer_html	Get the element’s own markup together with its descendants.

Edit Existing HTML and Create New Elements

You can apply the same DOM operations to a newly created document or an existing HTML file. To edit an existing file, pass its path to HTMLDocument, modify the loaded DOM, and save the document to the required output path. See Create and Load HTML Documents for loading examples.

Edit an Existing HTML File

The following example loads edit-document.html from the data directory, updates existing elements, and saves the edited document as output/edited-document.html:

1. Prepare the input and output paths and create the output directory.
2. Load the existing HTML file into an HTMLDocument.
3. Find the heading and status paragraph with query_selector().
4. Update the document title, heading text, paragraph text, and paragraph class.
5. Save the modified DOM as output/edited-document.html.

# Edit an existing HTML file in Python

import os
import aspose.html as ah

# Prepare input and output paths
data_dir = "data"
output_dir = "output"
os.makedirs(output_dir, exist_ok=True)

input_path = os.path.join(data_dir, "edit-document.html")
output_path = os.path.join(output_dir, "edited-document.html")

# Load and edit the HTML document
with ah.HTMLDocument(input_path) as document:
    heading = document.query_selector("h1")
    status = document.query_selector("#status")

    document.title = "Final Project Status"
    heading.text_content = "Final Project Status"
    status.text_content = "Approved"
    status.set_attribute("class", "approved")

    # Save the edited HTML document
    document.save(output_path)

The saved file contains the updated <title> and <h1> text. The status changes from Draft to Approved, and the existing .approved CSS rule displays it in bold green text.

Create Styled HTML with DOM Methods

The next example builds a document with an internal CSS rule and a styled paragraph:

1. Create an empty HTMLDocument.
2. Create a <style> element containing a .col color rule and append it to <head>.
3. Create a paragraph, assign the col class, and append a text node.
4. Append the paragraph to <body>.
5. Save the result as output/edit-document.html.

# Create HTML elements using the DOM in Python

import os
import aspose.html as ah

# Prepare the output path
output_dir = "output"
save_path = os.path.join(output_dir, "edit-document.html")
os.makedirs(output_dir, exist_ok=True)

# Create an HTML document and add new elements
with ah.HTMLDocument() as document:
    style = document.create_element("style")
    style.text_content = ".col { color: teal }"
    head = document.get_elements_by_tag_name("head")[0]
    head.append_child(style)

    paragraph = document.create_element("p")
    paragraph.class_name = "col"
    paragraph.append_child(document.create_text_node("Edit HTML document"))
    document.body.append_child(paragraph)

    # Save the HTML document
    document.save(save_path)

This example saves HTML only. The two CSS examples later on the page additionally render their edited documents to PDF.

Creating an element does not insert it into the document automatically. The element becomes part of the saved DOM only after it is appended to a parent node, as shown when the example adds <style> to <head> and <p> to <body>.

Edit HTML with inner_html and outer_html

Use inner_html to get or replace the markup inside an element. Use outer_html to read the serialized markup of the element itself together with its descendants.

The following example:

1. Creates an empty document and prints its initial root markup.
2. Assigns a paragraph fragment to document.body.inner_html.
3. Reads the paragraph’s inner_html.
4. Prints the complete updated markup through document.document_element.outer_html.

# Edit HTML with innerHTML and outerHTML in Python

import aspose.html as ah

# Create an HTML document and inspect its markup
with ah.HTMLDocument() as document:
    print(document.document_element.outer_html)

    # Replace the body content using innerHTML
    document.body.inner_html = "<p>HTML is the standard markup language for Web pages.</p>"
    paragraph = document.get_elements_by_tag_name("p")[0]

    # Print the element content and updated document markup
    print(paragraph.inner_html)
    print(document.document_element.outer_html)

Assigning inner_html parses the supplied string as markup and replaces all existing child nodes of the target element. Use text_content or create_text_node() when a value must remain plain text. This example prints the result to the console and does not save a file.

Edit CSS in an HTML Document

Use an element’s style attribute for declarations that apply to one element. Add a <style> element to the document <head> when CSS rules should target elements through selectors or class names.

Edit Inline CSS

The inline CSS example sets font size, font family, and text color on a paragraph, saves the edited HTML, and renders the same document to PDF:

1. Create an HTMLDocument containing a paragraph.
2. Retrieve the paragraph and set its style attribute.
3. Save the document as output/edit-inline-css.html.
4. Create a PdfDevice and call render_to() to produce output/edit-inline-css.pdf.

# Add inline CSS to HTML in Python

import os
import aspose.html as ah
import aspose.html.rendering.pdf as rp

# Define the HTML content
content = "<p>Edit inline CSS using Aspose.HTML for Python via .NET</p>"

# Prepare output paths
output_dir = "output"
os.makedirs(output_dir, exist_ok=True)
html_path = os.path.join(output_dir, "edit-inline-css.html")
pdf_path = os.path.join(output_dir, "edit-inline-css.pdf")

# Add inline CSS, then save and render the document
with ah.HTMLDocument(content, ".") as document:
    paragraph = document.get_elements_by_tag_name("p")[0]
    paragraph.set_attribute("style", "font-size: 150%; font-family: arial; color: teal")
    document.save(html_path)

    with rp.PdfDevice(pdf_path) as device:
        document.render_to(device)

The rendered paragraph uses a 150% font size, Arial when that font is available, and teal text:

Edit Internal and Inline CSS

The final example combines class rules in a <style> element with inline declarations on individual elements:

1. Create an HTMLDocument containing a heading and paragraph.
2. Create a <style> element with .frame1 and .frame2 rules and append it to <head>.
3. Assign the classes to the heading and paragraph.
4. Add inline declarations that supplement or override the class rules.
5. Save output/edit-internal-css.html and render output/edit-internal-css.pdf.

# Add internal CSS to HTML in Python

import os
import aspose.html as ah
import aspose.html.rendering.pdf as rp

# Define the HTML content
content = "<div><h1>Internal CSS</h1><p>An internal CSS is used to define a style for a single HTML page</p></div>"

# Prepare output paths
output_dir = "output"
os.makedirs(output_dir, exist_ok=True)
html_path = os.path.join(output_dir, "edit-internal-css.html")
pdf_path = os.path.join(output_dir, "edit-internal-css.pdf")

# Add internal CSS, then save and render the document
with ah.HTMLDocument(content, ".") as document:
    style = document.create_element("style")
    style.text_content = (
        ".frame1 { margin-top:50px; margin-left:50px; padding:25px; width:360px; height:90px; "
        "background-color:#82011a; font-family:arial; color:#fff5ee;} \r\n"
        ".frame2 { margin-top:-70px; margin-left:160px; text-align:center; padding:20px; width:360px; "
        "height:100px; background-color:#ebd2d7;}"
    )
    head = document.get_elements_by_tag_name("head")[0]
    head.append_child(style)

    header = document.get_elements_by_tag_name("h1")[0]
    header.class_name = "frame1"
    header.set_attribute("style", "font-size: 200%; text-align: center;")

    paragraph = document.get_elements_by_tag_name("p")[0]
    paragraph.class_name = "frame2"
    paragraph.set_attribute("style", "color: #434343; font-size: 150%; font-family: verdana;")

    document.save(html_path)
    with rp.PdfDevice(pdf_path) as device:
        document.render_to(device)

The rendered PDF applies the internal class rules together with the inline font size, alignment, color, and font-family declarations:

Common HTML Editing Issues

Issue	Likely Cause	Recommended Action
A created element is missing from the output	The element was created but not attached to the document tree.	Append it to document.body or another parent node before saving.
Existing children disappear after assigning inner_html	Setting inner_html replaces all current child markup.	Use append_child() when existing children must be preserved.
HTML tags appear as visible text	The value was assigned as text content rather than parsed markup.	Use inner_html only when trusted markup should become DOM nodes.
A CSS class rule is not applied	The <style> element is not in the document, the class name does not match, or an inline declaration overrides the rule.	Check the DOM location, selector, class name, and CSS cascade.
Changes are missing from the output file	The document was changed in memory but not saved afterward.	Call save() after completing all DOM and CSS changes.

Other Platforms

• Edit HTML Documents in C# – modify DOM nodes, attributes, text, and markup with Aspose.HTML for .NET.
• Edit HTML Documents in Java – edit HTML structure, content, and CSS with Aspose.HTML for Java.

Related Articles

• Working with HTML Documents in Python – choose a document creation, editing, or saving workflow.
• Create and Load HTML Documents in Python – create HTML or load it from a file, URL, string, or stream.
• Save an HTML Document in Python – save edited HTML and control linked-resource handling.
• HTML Navigation in Python – find and inspect DOM nodes with navigation, XPath, and CSS selectors.
• Aspose.HTML for Python via .NET Examples – browse complete examples and supporting data files.