In this Article
Los datos existen en diferentes formatos, desde simples tablas CSV y objetos JSON hasta documentos XML más descriptivos y jerárquicos.XML puede parecer un poco anticuado, pero todavía está en todas partes: en los feeds, API y configuraciones de software de RSS.
Antes de poder utilizar los datos de XML, debe analizarlos. En otras palabras, le enseñas a tu programa a leer lo que hay dentro. Con bibliotecas de Python como ElementTree,minidom y lxml, analizar XML es un proceso claro e intuitivo.
No importa qué formato de datos encuentre, aprender a trabajar con ellos, especialmente XML, es una habilidad imprescindible para cualquier desarrollador. En esta guía, aprenderá cómo leer, navegar y extraer datos de XML paso a paso.
Los fundamentos de XML
XML significa lenguaje de marcado extensible y es un formato universal para almacenar y transportar datos. Su estructura permite que los humanos lo lean fácilmente sin dejar de ser compatible con las máquinas. El lenguaje se creó centrándose en la simplicidad, la adaptabilidad y la amplia usabilidad en línea.
XML se puede describir mejor como un árbol. Similar a un árbol real con ramas y hojas, tiene una raíz y elementos secundarios anidados. Este marco ilustra cómo XML organiza los datos en un formato jerárquico.Python ofrece varios métodos para manejar datos de XML, siendo el módulo ElementTree una de las opciones más populares. El módulo ElementTree incluye dos clases principales:ElementTree, que representa el documento completo, y Elemento, que denota un nodo individual.
Cómo los desarrolladores analizan XML: las técnicas principales
En Python, el Funciónparse() suele ser el paso inicial para manejar archivos XML. Procesa un documento XML y lo transforma en una estructura de árbol por la que su programa puede navegar. Esta función sirve como base para varios métodos de análisis, ya sea que esté utilizando ElementTree,lxml u otras bibliotecas.
Para comprender los métodos de análisis, primero debe conocer los elementos de un archivo XML:
- Espacio de nombres – ayuda a evitar conflictos de nombres al calificar los nombres de elementos y atributos.
- elemento raíz – el contenedor principal que abarca todos los demás elementos.
- Atributos – pares de claves y valores que ofrecen información adicional sobre elementos.
- Elementos secundarios – elementos anidados que organizan jerárquicamente los datos.
- Contenido del texto – la información real contenida en los elementos.
Estos elementos crean un formato estructurado que permite a los programas almacenar y compartir datos complejos. Después de comprender la estructura, podemos investigar las principales técnicas de análisis de XML en Python:
1. Módulo ElementTree
Una biblioteca integrada en Python con un API fácil de usar para explorar árboles XML. Funciona muy bien para la mayoría de las tareas, ya que equilibra la usabilidad con el rendimiento.
2.lxml
Una biblioteca de terceros que incluye soporte para XPath,XSLT y validación. Es más rápido y tiene más funciones que ElementTree. Es perfecto para procesamiento complejo XML.
3.DOM (Modelo de objetos de documento)
Esto carga el documento XML completo en la memoria como una estructura de árbol. Mientras es sencillo de navegar y modificar, y puede consumir mucha memoria para archivos más grandes.
4.SAX (API simple para XML)
Un analizador controlado por eventos que procesa secuencialmente XML. Es eficiente en términos de uso de memoria y rápido para manejar archivos grandes, pero puede ser menos intuitivo para administrar operaciones complejas.
5.Untangle
Transforma datos XML en objetos Python para facilitar el acceso. Es perfecto para un análisis rápido con un código mínimo. Sin embargo, es menos adaptable a estructuras intrincadas XML.
Para este tutorial, necesitarás…
- Solicitudes Python y Python
En caso de que no tengasPython3.xinstalado en tu computadora, puedes descargarlo desde https://www.python.org/. Abra una terminal e instale Requests usando pip:
solicitudes de instalación de pip o solicitudes de instalación de pip3
- Visual Studio Code(VS Code)
Para ejecutar todos los comandos necesarios, puede usar la terminal en Visual Studio Code(VS Code). Simplemente descárgalo desde sitio web oficial y siga las instrucciones de instalación de su sistema operativo.
- Feed de RSS
Un feed RSS es un formato de archivo especial XML que se utiliza para entregar automáticamente noticias o actualizaciones desde un sitio web. En pocas palabras, es una especie de “lista de las últimas publicaciones” estructurada de manera que los programas puedan leerla.
Por ejemplo, en nuestra web hay una sección con tutoriales. En lugar de consultar el sitio todos los días para ver si se ha publicado un nuevo tutorial, el sitio proporciona un feed RSS, un archivo XML que contiene información sobre todas las publicaciones recientes. Usaremos el Alimentación DataImpulse RSS para nuestro tutorial. Ahora, veamos las bibliotecas que necesitamos y el siguiente código.
ElementTree
Veamos cómo utilizar el módulo ElementTree integrado de Python para analizar datos de XML de un feed RSS.
El primer paso es importar. xml.etree.ElementTree. El proceso es simple: enviamos una solicitud GET al feed RSS URL y el servidor responde con datos de XML. El .content El atributo de la respuesta nos proporciona los datos de bytes sin procesar que ElementTree puede analizar. Usando ET.fromstring(), convertimos este texto XML en una estructura de árbol y obtenemos el elemento raíz. En su interior, la mayor parte del contenido está organizado en <channel> → <item> elementos.
El find() El método devuelve el primer elemento coincidente, mientras que findall() devuelve todos los elementos secundarios con una etiqueta determinada. Aquí, elementos es una lista de todos los elementos, cada uno de los cuales representa un tutorial o artículo.
Ejemplo del código:
import xml.etree.ElementTree as ET
import requests
# URL of the RSS feed (from DataImpulse site)
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"
# Download the XML data
response = requests.get(FEED_URL)
xml_data = response.content
# Parse the XML
root = ET.fromstring(xml_data)
# In RSS feeds, items are inside -
channel = root.find("channel")
items = channel.findall("item")
# Print titles and links of the items
for item in items:
title = item.findtext("title")
link = item.findtext("link")
print(f"Title: {title}")
print(f"Link: {link}\n")
Finalmente, extraemos e imprimimos el título y el enlace de cada elemento usando findtext(), que obtiene el contenido del texto directamente. Cuando ejecute el script, obtendrá una lista claramente impresa de todos los títulos de los tutoriales y sus URL.
lxml
Lxml es una biblioteca externa que amplía la funcionalidad de ElementTree y agrega soporte para XPath, un lenguaje de consulta para navegar por documentos XML. En este ejemplo, usaremos lxml.etree para analizar un feed RSS y extraer títulos de publicaciones.
Comenzamos obteniendo el feed RSS usando requests.get(), como antes. El contenido de la respuesta se pasa a etree.fromstring(), que analiza el XML y devuelve el elemento raíz. Con lxml, podemos usar expresiones XPath para buscar elementos porque hacen que la navegación sea más rápida y flexible que los métodos estándar ElementTree.
import requests
from lxml import etree
# URL of the RSS feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"
# Download the XML data
response = requests.get(FEED_URL)
xml_data = response.content
# Parse XML
root = etree.fromstring(xml_data)
items = root.xpath("//channel/item")
# Show list of titles with numbers
print("Available blog posts:\n")
for item in items:
title = item.findtext("title")
print(title)
Finalmente, recorremos el <item> elementos, extraiga el título de cada publicación usando findtext(“title”)e imprimirlos.
Minidom
En este ejemplo, usamos Minidom, abreviatura de Implementación mínima de DOM. Es parte de la biblioteca estándar de Python y funciona cargando todo el documento XML en la memoria como un modelo de objetos de documento (DOM).
llamamos minidom.parseString() para analizar el XML y construir un objeto DOM (doc). Entre los métodos familiares DOM, usaremos dos. El primero es getElementsByTagName(“tag”,) que encuentra todos los elementos con un nombre de etiqueta determinado. Y el siguiente es .firstChild.nodeValue que recupera el contenido de texto de un nodo.
Finalmente, utilizamos toprettyxml(). Se utiliza para imprimir el primer elemento del elemento en un diseño XML formateado.
A continuación se explica cómo analizar datos de un feed RSS usando Minidom:
import requests
from xml.dom import minidom
# URL of the RSS feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"
# Download XML data
response = requests.get(FEED_URL)
xml_data = response.content
# Parse XML with minidom
doc = minidom.parseString(xml_data)
# Get all - elements
items = doc.getElementsByTagName("item")
print(f"Total articles found in feed: {len(items)}\n")
# Show titles with links
for i, item in enumerate(items, start=1):
title = item.getElementsByTagName("title")[0].firstChild.nodeValue
link = item.getElementsByTagName("link")[0].firstChild.nodeValue
print(f"{i}. {title}")
print(f" Link: {link}\n")
# Show raw XML of the first
- (just for demo)
print("First
- as raw XML:\n")
print(items[0].toprettyxml())
SAX
SAX lee el XML secuencialmente, elemento por elemento. desencadena eventos específicos para cada pieza XML:
- startElement(name, attrs) → cuando comienza una etiqueta
- characters(content) → cuando se lee texto entre etiquetas
- endElement(name) → cuando termina una etiqueta
Guarde el código en el archivo y ejecútelo:
import requests
import xml.sax
# Custom handler for SAX parsing
class RSSHandler(xml.sax.ContentHandler):
def __init__(self):
super().__init__()
self.current_tag = ""
self.in_item = False
self.title = ""
self.link = ""
self.counter = 0
def startElement(self, name, attrs):
if name == "item":
self.in_item = True
self.title = ""
self.link = ""
self.current_tag = name
def characters(self, content):
if self.in_item:
if self.current_tag == "title":
self.title += content
elif self.current_tag == "link":
self.link += content
def endElement(self, name):
if name == "item":
self.counter += 1
print(f"{self.counter}. {self.title.strip()}")
print(f" Link: {self.link.strip()}\n")
self.in_item = False
self.current_tag = ""
# Download the XML feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"
response = requests.get(FEED_URL)
xml_data = response.content
# Parse XML with SAX
print("Parsing RSS feed with SAX...\n")
handler = RSSHandler()
xml.sax.parseString(xml_data, handler)
print(f"Total items parsed: {handler.counter}")
La ventaja de este método es la eficiencia de la memoria, ya que no almacena el documento completo.
Untangle
Este método se considera una forma más sencilla de manejar XML. La biblioteca Untangle convierte documentos XML en objetos Python. Significa que no hay necesidad de atravesar elementos manualmente o manejar eventos.
Cuando analizas XML con untangle.parse(), lee automáticamente el archivo XML, convierte cada etiqueta XML en un objeto Python y almacena los datos de la etiqueta en .cdata atributos (si es contenido de texto). En lugar de trabajar con nodos o eventos, simplemente navega por la estructura XML como un objeto Python normal.
Aquí está el código:
import requests
import untangle
from io import BytesIO
# RSS feed from DataImpulse
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"
# Download XML
resp = requests.get(FEED_URL)
resp.raise_for_status()
xml_bytes = resp.content
# Parse XML with untangle (use BytesIO for bytes input)
doc = untangle.parse(BytesIO(xml_bytes))
# Get all - elements
items = doc.rss.channel.item
print("Articles from DataImpulse RSS:\n")
# Print articles
for i, it in enumerate(items, start=1):
title = it.title.cdata if hasattr(it, "title") else ""
link = it.link.cdata if hasattr(it, "link") else ""
desc = it.description.cdata if hasattr(it, "description") else ""
print(f"{i}. {title}")
print(f" Link: {link}")
if desc:
print(f" Description: {desc}")
print()
Algunas recomendaciones adicionales
- Comprobar errores durante el análisis
A veces, los feeds pueden no estar disponibles o contener etiquetas inesperadas. En tales casos, utilice try/except al descargar o analizar XML.
- Elegir .content para descargas XML
El .content El atributo devuelve datos de bytes sin procesar, lo que evita problemas de codificación que .text atributo podría causar.
- Verificar que existan elementos
No todos los archivos XML tienen la misma estructura. Utilice condiciones como if item.find(‘title’) is not None antes de acceder a las etiquetas.
- Preste atención al uso de recursos para archivos grandes
Para documentos XML de gran tamaño, utilice SAX, que lee los datos secuencialmente sin cargarlos todos en la memoria.
Obtener XML de sitios externos puede resultar problemático. Los servidores proxy ayudan a garantizar un acceso fluido entre ubicaciones y preservar la privacidad.
Aspectos destacados clave
- Analizar XML es el proceso de leer archivos XML y extraer datos de una manera estructurada y utilizable.
- ElementTree proporciona un enfoque basado en árboles para navegar y extraer elementos XML.
- lxml es una biblioteca que admite consultas XPath para un análisis XML más rápido.
- Minidom carga todo el XML como un árbol DOM, lo que le permite acceder a nodos y texto como un objeto estructurado.
- SAX es ideal para archivos XML grandes porque procesa el XML paso a paso sin guardar todo en la memoria.
- Untangle convierte XML en objetos Python para acceder simplemente a las etiquetas y su contenido.
Artículos relacionados
Integración de proxies con solicitudes Python
Cómo raspar eBay con Python y proxies
Cómo configurar los servidores proxy DataImpulse en Java
Eliminación de datos del producto Amazon con Python