Como analisar XML e feeds RSS em Python - Residential proxies

Published: July 26, 2026
Last Updated: August 19, 2026
by Andrii Byzov
Step-by-step guide
8 min read

In this Article

Os dados existem em diferentes formatos – desde simples tabelas CSV e objetos JSON até documentos XML mais descritivos e hierárquicos.XML pode parecer um pouco antiquado, mas ainda está em toda parte: em feeds RSS, API s e configurações de software.

Antes de poder usar os dados XML, você precisa analisá-los. Em outras palavras, você ensina seu programa a ler o que está dentro. Com as bibliotecas Python como ElementTree,minidom e lxml, a análise de XML é um processo claro e intuitivo.

Não importa qual formato de dados você encontre, aprender como trabalhar com eles, especialmente XML, é uma habilidade obrigatória para qualquer desenvolvedor. Neste guia, você aprenderá como ler, navegar e extrair dados de XML passo a passo.

Os fundamentos do XML

XML significa linguagem de marcação extensível e é um formato universal para armazenar e transportar dados. Sua estrutura permite que seja facilmente lido por humanos, mantendo-se compatível com máquinas. A linguagem foi construída com foco na simplicidade, adaptabilidade e ampla usabilidade online.

XML pode ser melhor descrito como uma árvore. Semelhante a uma árvore real com galhos e folhas, ela possui uma raiz e elementos filhos aninhados. Esta estrutura ilustra como XML organiza os dados em um formato hierárquico.Python oferece vários métodos para lidar com dados XML, sendo o módulo ElementTree uma das opções mais populares. O módulo ElementTree inclui duas classes primárias:ElementTree, que significa o documento inteiro, e Element, que denota um nó individual.

Como os desenvolvedores analisam XML: as principais técnicas

Em Python, o Funçãoparse() normalmente é a etapa inicial para lidar com arquivos XML. Ele processa um documento XML e o transforma em uma estrutura em árvore que pode ser navegada pelo seu programa. Esta função serve como base para vários métodos de análise, quer você esteja utilizando ElementTree,lxml ou outras bibliotecas.

Para compreender os métodos de análise, você precisa primeiro conhecer os elementos de um arquivo XML:

Espaço para nome – ajuda a evitar conflitos de nomenclatura ao qualificar os nomes de elementos e atributos.
Elemento raiz – o contêiner principal que abrange todos os outros elementos.
Atributos – pares de chaves e valores que oferecem informações extras sobre os elementos.
Elementos filhos – elementos aninhados que organizam os dados hierarquicamente.
Conteúdo de texto – as informações reais contidas nos elementos.

Esses elementos criam um formato estruturado que permite aos programas armazenar e compartilhar dados complexos. Depois de compreender a estrutura, podemos investigar as principais técnicas de análise XML em Python:

1. Módulo ElementTree

Uma biblioteca integrada no Python com um API fácil de usar para explorar árvores XML. Funciona muito bem para a maioria das tarefas, pois equilibra usabilidade com desempenho.

2.lxml

Uma biblioteca de terceiros que inclui suporte para XPath,XSLT e validação. É mais rápido e possui mais recursos que o ElementTree. É perfeito para processamento XML complexo.

3.DOM (Modelo de objeto de documento)

Isso carrega o documento XML completo na memória como uma estrutura em árvore. Enquanto é simples de navegar e modificar e pode consumir muita memória para arquivos maiores.

4.SAX (API simples para XML)

Um analisador orientado a eventos que processa XML sequencialmente. É eficiente em termos de uso de memória e rápido para lidar com arquivos grandes, mas pode ser menos intuitivo para gerenciar operações complexas.

5.Untangle

Transforma dados XML em objetos Python para fácil acesso. É perfeito para análise rápida com código mínimo. No entanto, é menos adaptável para estruturas XML complexas.

Para este tutorial, você precisará…

Solicitações Python e Python

Caso você não tenhaPython3.xinstalado em seu computador, você pode baixá-lo em https://www.python.org/. Abra um terminal e instale Requests usando pip:

solicitações de instalação pip ou solicitações de instalação do pip3

Visual Studio Code(VS Code)

Para executar todos os comandos necessários, você pode usar o terminal em Visual Studio Code(VS Code). Basta baixá-lo do site oficial e siga as instruções de instalação do seu sistema operacional.

Alimentação RSS

Um feed RSS é um formato de arquivo XML especial usado para fornecer automaticamente notícias ou atualizações de um site. Simplificando, é uma espécie de “lista das últimas postagens” estruturada de forma que os programas possam ler.

Por exemplo, em nosso site há uma seção com tutoriais. Em vez de verificar o site todos os dias para ver se um novo tutorial foi publicado, o site fornece um feed RSS – um arquivo XML contendo informações sobre todas as postagens recentes. Usaremos o Alimentação DataImpulse RSS para nosso tutorial. Agora, vamos dar uma olhada nas bibliotecas de que precisamos e no código a seguir.

ElementTree

Vejamos como usar o módulo ElementTree integrado do Python para analisar dados XML de um feed RSS.

O primeiro passo é importar xml.etree.ElementTree. O processo é simples: enviamos uma solicitação GET para o feed RSS URL e o servidor responde com dados XML. O .content O atributo da resposta nos fornece os dados brutos de bytes que ElementTree pode analisar. Usando ET.fromstring(), convertemos esse texto XML em uma estrutura de árvore e obtemos o elemento raiz. Dentro dele, a maior parte do conteúdo é organizada em <channel> → <item> elementos.

O find() método retorna o primeiro elemento correspondente, enquanto findall() retorna todos os elementos filhos com uma determinada tag. Aqui, items é uma lista de todos os elementos, cada um representando um tutorial ou artigo.

Exemplo do 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, extraímos e imprimimos o título e o link de cada item usando findtext(), que obtém o conteúdo do texto diretamente. Ao executar o script, você obterá uma lista bem impressa de todos os títulos dos tutoriais e seus URL s.

lxml

Lxml é uma biblioteca externa que estende a funcionalidade do ElementTree e adiciona suporte para XPath, uma linguagem de consulta para navegar em documentos XML. Neste exemplo, usaremos lxml.etree para analisar um feed RSS e extrair títulos de postagens.

Começamos buscando o feed RSS usando requests.get(), assim como antes. O conteúdo da resposta é passado para etree.fromstring(), que analisa XML e retorna o elemento raiz. Com lxml, podemos usar expressões XPath para localizar elementos porque elas tornam a navegação mais rápida e flexível do que os métodos ElementTree padrão.


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, percorremos o <item> elementos, extraia o título de cada postagem usando findtext(“title”)e imprima-os.

Minidom

Neste exemplo, estamos usando Minidom, abreviação de Implementação Mínima de DOM. Faz parte da biblioteca padrão do Python e funciona carregando todo o documento XML na memória como um Document Object Model (DOM).

Nós ligamos minidom.parseString() para analisar o XML e construir um objeto DOM (doc). Entre os métodos DOM familiares, usaremos dois. O primeiro é getElementsByTagName(“tag”,) que encontra todos os elementos com um determinado nome de tag. E o próximo é .firstChild.nodeValue que recupera o conteúdo de texto de um nó.

Finalmente, usamos toprettyxml(). É usado para imprimir o primeiro elemento do item em um layout XML formatado.

Veja como analisar dados de um 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 lê XML sequencialmente, elemento por elemento. ele aciona eventos específicos para cada peça XML:

startElement(name, attrs) → quando uma tag começa
characters(content) → quando o texto é lido entre tags
endElement(name) → quando uma tag termina

Salve o código no arquivo e execute-o:


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}")

A vantagem desse método é a eficiência da memória, pois não armazena o documento inteiro.

Untangle

Este método é considerado uma maneira mais simples de lidar com XML. A biblioteca Untangle converte documentos XML em objetos Python. Isso significa que não há necessidade de passagem manual de elementos ou manipulação de eventos.

Quando você analisa XML com untangle.parse(), ele lê automaticamente o arquivo XML, converte cada tag XML em um objeto Python e armazena dados de tag em .cdata atributos (se for conteúdo de texto). Em vez de trabalhar com nós ou eventos, basta navegar na estrutura XML como um objeto Python normal.

Aqui está o 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()

Algumas recomendações adicionais

Verifique se há erros durante a análise

Às vezes, os feeds podem estar indisponíveis ou conter tags inesperadas. Nesses casos, use try/except ao baixar ou analisar XML.

Escolher .content para downloads XML

O .content atributo retorna dados brutos de bytes, evitando problemas de codificação que .text atributo pode causar.

Verifique se os elementos existem

Nem todo arquivo XML possui a mesma estrutura. Use condições como if item.find(‘title’) is not None antes de acessar as tags.

Preste atenção ao uso de recursos para arquivos grandes

Para documentos XML enormes, use SAX, que lê os dados sequencialmente sem carregar tudo na memória.

Usar Proxies DataImpulse

Buscar XML de sites externos pode ser problemático. Os proxies ajudam a garantir um acesso tranquilo entre locais e a preservar a privacidade.

Principais destaques

Analisar XML é o processo de leitura de arquivos XML e extração de dados de forma estruturada e utilizável.
ElementTree fornece uma abordagem baseada em árvore para navegar e extrair elementos XML.
lxml é uma biblioteca que suporta consultas XPath para análise XML mais rápida.
Minidom carrega XML inteiro como uma árvore DOM, permitindo acessar nós e texto como um objeto estruturado.
SAX é ideal para arquivos XML grandes porque processa XML passo a passo sem manter tudo na memória.
Untangle converte XML em objetos Python para simplesmente acessar tags e seu conteúdo.