1. Productos
  2.   Aspose.HTML
  3.   Aspose.HTML FOSS for Python

Aspose.HTML FOSS para Python

Analiza HTML en un DOM basado en estándares, aplica CSS y calcula estilos a partir de Python — gratuito, de código abierto y puro Python.

Aspose.HTML FOSS for Python Aspose.HTML FOSS
for Python

Documentación GitHub

Biblioteca Python de código abierto para el procesamiento de HTML

Aspose.HTML FOSS for Python es una biblioteca gratuita y de código abierto para trabajar con documentos HTML en aplicaciones Python. Instálala con un solo comando git clone https://github.com/aspose-html-foss/Aspose.HTML-FOSS-for-Python.git y comienza a analizar marcado en un modelo de objeto de documento, construir y modificar árboles de elementos, adjuntar hojas de estilo CSS, resolver estilos computados y trabajar con URLs y codificaciones de caracteres — todo en puro Python sin dependencia de navegador.

La biblioteca expone una API orientada a estándares construida alrededor de HTMLDocument, Document, Element y CSSStyleSheet. Analiza el marcado con HTMLDocument.parse(), crea y conecta nodos con Document.create_element() y append_child(), busca elementos con get_element_by_id(), dales estilo mediante CSSStyleSheet.replace_sync() y la declaración style a nivel de elemento, y lee el resultado con Element.get_computed_style(). Los bloques de construcción de nivel inferior — el HTML Tokenizer, el TreeBuilder, URL y URLSearchParams al estilo WHATWG, y el detector de flujo de bytes detect_encoding() — están disponibles cuando necesites control directo.

Aspose.HTML FOSS tiene licencia MIT y está implementado en puro Python, requiriendo Python 3.10 o posterior. Se ejecuta idénticamente en Windows, Linux y macOS — incluidos los runners de CI, contenedores Docker y entornos sin servidor. Para la familia de productos empresariales, consulta Aspose.HTML — Enterprise Product Family.

HTML Análisis y manipulación del DOM

  • Analiza páginas completas con HTMLDocument.parse() o fragmentos con HTMLDocument.parse_fragment()
  • Construye documentos programáticamente con Document.create_element() y append_child()
  • Busca nodos con Document.get_element_by_id() y lee atributos de marcado mediante Element.get_attribute()
  • Establece atributos con Element.set_attribute() y asigna texto a través de Node.text_content
  • Serializa cualquier subárbol de nuevo a marcado con la función serialise()

¿Quién usa el procesamiento DOM?

  • Servicios de backend que limpian o reescriben HTML enviados por el usuario antes del almacenamiento
  • Tuberías de contenido que extraen o reestructuran fragmentos de página a gran escala
  • Conjuntos de pruebas que verifican la estructura del marcado generado en CI

CSS Hojas de estilo y estilos computados

  • Analizar texto de hoja de estilo con CSSStyleSheet.replace_sync() y adjuntarlo mediante Document.attach_style_sheet()
  • Establecer declaraciones en línea a través de la propiedad style del elemento con CSSStyleDeclaration.set_property()
  • Resolver la cascada — especificidad, reglas en línea vs autor y herencia — con Element.get_computed_style()
  • Leer los valores resueltos con CSSStyleDeclaration.get_property_value()

¿Quién usa Style Computation?

  • Herramientas de correo electrónico y boletines que verifican los estilos efectivos antes de enviar
  • Sanitizadores de HTML que necesitan conocer el estilo con el que realmente se renderiza un elemento
  • Desarrolladores depurando el comportamiento de la cascada y la especificidad fuera de un navegador

Tokenizador y Construcción del Árbol

  • Conduce el tokenizador HTML directamente con Tokenizer.tokenize() o Tokenizer.tokenize_fragment()
  • Ejecuta la construcción de árbol basada en estándares con TreeBuilder.run()
  • Analiza el marcado directamente a un árbol con la función parse_html()

¿Quién usa el análisis de bajo nivel?

  • Linters y analizadores que inspeccionan flujos de tokens en lugar de árboles terminados
  • Herramientas que requieren manejo de errores personalizado durante la recuperación de marcado malformado
  • Proyectos educativos que estudian cómo funciona el análisis HTML basado en estándares

URLs y codificaciones de caracteres

  • Analiza y valida URLs con URL.parse() y URL.can_parse()
  • Lee y edita cadenas de consulta con URLSearchParams — append(), get(), has(), delete()
  • Detecta codificaciones de flujo de bytes (BOM y detección de contenido) con detect_encoding()
  • Normaliza etiquetas de codificación a nombres canónicos con get_canonical_name()

¿Quién usa herramientas de URL y codificación?

  • Rastreadores y recuperadores que deben resolver y desduplicar URLs de manera fiable
  • Canalizaciones de ingestión que manejan documentos heredados con codificaciones mixtas
  • Servicios que analizan o reescriben parámetros de consulta del lado del servidor

Construir un DOM y Resolver la Cascada CSS

Cree un documento, adjunte una hoja de estilo y lea el estilo calculado — el selector ID gana sobre la regla de clase:

from aspose_html.dom import Document
from aspose_html.cssom import CSSStyleSheet
doc = Document()
el = doc.create_element("div")
el.set_attribute("class", "foo")
el.set_attribute("id", "bar")
doc.append_child(el)
sheet = CSSStyleSheet()
sheet.replace_sync(".foo { color: red } #bar { color: blue }")
doc.attach_style_sheet(sheet)
style = el.get_computed_style()
print(style.get_property_value("color"))

Los estilos en línea tienen prioridad

Las declaraciones en línea tienen mayor especificidad que las reglas de la hoja de estilo del autor:

from aspose_html.dom import Document
from aspose_html.cssom import CSSStyleSheet
doc = Document()
el = doc.create_element("div")
doc.append_child(el)
sheet = CSSStyleSheet()
sheet.replace_sync("div { color: red }")
doc.attach_style_sheet(sheet)
inline = el.style
inline.set_property("color", "blue")
print(el.get_computed_style().get_property_value("color"))

Detectar la codificación de caracteres a partir de bytes

Detecta la codificación de un flujo de bytes sin procesar, incluido el BOM, y obtén el texto decodificado de vuelta:

from aspose_html.encoding.detection import detect_encoding
result = detect_encoding(b"\xef\xbb\xbf<p>x</p>")
print(result.encoding)
print(result.confidence)
print(result.text)

Preguntas frecuentes

¿Qué licencia usa Aspose.HTML FOSS for Python?

La Licencia MIT — el uso comercial, la modificación y la redistribución están permitidos; el único requisito es mantener el aviso de derechos de autor en copias sustanciales.

¿Qué versiones de Python son compatibles y cómo las instalo?

Python 3.10 o posterior. Instale con git clone https://github.com/aspose-html-foss/Aspose.HTML-FOSS-for-Python.git — la implementación es pura Python sin dependencias nativas.

¿Cómo parseo HTML en un documento?

Utilice HTMLDocument.parse() para páginas completas o HTMLDocument.parse_fragment() para marcado parcial; Document es la fábrica para crear árboles programáticamente.

¿El cascade de CSS maneja la especificidad y !important correctamente?

Sí — los valores calculados siguen la especificidad del selector, las declaraciones en línea superan las reglas del autor, las reglas del autor !important superan las declaraciones en línea que no son importantes, y la herencia fluye del padre al hijo.

¿La biblioteca renderiza páginas o convierte a otros formatos?

No. La versión actual se centra en el análisis, la manipulación del DOM, el cálculo de estilos CSS, las estructuras de diseño, URLs y codificaciones — sin conversión de formatos ni renderizado de imagen/PDF.

¿Se ejecuta JavaScript automáticamente durante el análisis?

No. El análisis nunca ejecuta scripts; la evaluación es explícita y opcional a través de JSContext con la carga de módulos controlada por ModuleRegistry y ModuleLoadPolicy.

  

Recursos de soporte y aprendizaje

 Español