Guia sobre como realizar Parsing de XML em Python

A Linguagem de Marcação Extensível (XML) é um formato amplamente utilizado para armazenar e trocar dados estruturados. Os arquivos XML são comumente usados para representar dados hierárquicos, como arquivos de configuração, formatos de intercâmbio de dados, respostas de serviços da web e mapas de sites.

Parsing de arquivos XML em Python é uma tarefa comum, especialmente para automatizar processos manuais, como processar dados recuperados de APIs da web ou Scraping de dados.

Neste artigo, você aprenderá sobre algumas das bibliotecas que podem ser usadas para realizar Parsing de XML em Python, incluindo o móduloElementTree, a biblioteca lxml, minidom, Simple API for XML (SAX) e untangle.

Conceitos-chave de um arquivo XML

Antes de aprender a realizar Parsing de XML em Python, você deve entender o que é XML Schema Definition (XSD) e quais elementos compõem um arquivo XML. Esse entendimento pode ajudá-lo a selecionar a biblioteca Python apropriada para sua tarefa de Parsing.

XSD é uma especificação de esquema que define a estrutura, o conteúdo e os tipos de dados permitidos em um documento XML. Ela serve como uma sintaxe para validar a estrutura e o conteúdo dos arquivos XML em relação a um conjunto predefinido de regras.

Um arquivo XML geralmente inclui os elementos Namespace, raiz, atributos, elementos e conteúdo de texto, que juntos representam dados estruturados.

• Espaço de nomes
• raiz
• atributos
• elementos
• conteúdo de texto

Por exemplo, o mapa do site da Bright Data tem a seguinte estrutura XML:

• urlset é o elemento raiz.
• <urlset xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd> é a declaração de namespace específica para o elemento urlset, o que implica que as regras desta declaração se estendem ao elemento urlset. Todos os elementos abaixo dele devem estar em conformidade com o esquema descrito por este namespace.
• url é o primeiro filho do elemento raiz.
• loc é o elemento filho do elemento url.

Agora que você sabe um pouco mais sobre XSD e elementos de arquivos XML, vamos usar essas informações para ajudar no Parsing de um arquivo XML com algumas bibliotecas.

Várias maneiras de realizar Parsing de XML em Python

Para fins de demonstração, você usará o mapa do site da Bright Data para este tutorial, que está disponível no formato XML. Nos exemplos a seguir, o conteúdo do mapa do site da Bright Data é buscado usando abiblioteca de solicitações Python.

A biblioteca Python requests não é integrada, portanto, você precisa instalá-la antes de continuar. Você pode fazer isso usando o seguinte comando:

pip install requests

ElementTree

A API XML ElementTreefornece uma API simples e intuitiva para realizar Parsing e criar dados XML em Python. É um módulo integrado na biblioteca padrão do Python, o que significa que você não precisa instalar nada explicitamente.

Por exemplo, você pode usar o métodofindall()para encontrar todos os elementosurlda raiz e imprimir o valor do texto do elementoloc, assim:

import xml.etree.ElementTree as ET
import requests

url = 'https://brightdata.com/post-sitemap.xml'

response = requests.get(url)
if response.status_code == 200:
   
    root = ET.fromstring(response.content)

    para url_element em root.findall('.//{http://www.sitemaps.org/schemas/sitemap/0.9}url'):
        loc_element = url_element.find('{http://www.sitemaps.org/schemas/sitemap/0.9}loc')
        se loc_element não for None:
            imprimir(loc_element.text)
else:
    imprimir("Falha ao recuperar o arquivo XML da URL.")

Todas as URLs no mapa do site são impressas na saída:

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Proteção de marca
https://brightdata.com/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

O ElementTree é uma maneira fácil de realizar Parsing de dados XML em Python, com uma API simples que facilita a navegação e a manipulação de estruturas XML. No entanto, o ElementTree tem suas limitações; ele não oferece suporte robusto para validação de esquema e não é ideal se você precisa garantir a adesão estrita a uma especificação de esquema antes do Parsing.

Se você tiver um pequeno script que lê um feed RSS, a API fácil de usar do ElementTree seria uma ferramenta útil para extrair títulos, descrições e links de cada item do feed. No entanto, se você tiver um caso de uso com validação complexa ou arquivos enormes, seria melhor considerar outra biblioteca, como lxml.

lxml

O lxmlé uma API rápida, fácil de usar e rica em recursos para realizar o Parsing de arquivos XML em Python; no entanto, não é uma biblioteca pré-construída em Python. Embora algumas plataformas Linux e Mac já tenham o pacote lxml instalado, outras plataformas precisam de instalação manual.

A lxml é distribuída viaPyPIe você podeinstalá-lausando o seguinte comandopip:

pip install lxml

Depois de instalado, você pode usaro lxmlpara parsear arquivos XML usandováriosmétodosde API, comofind(),findall(),findtext(),get() eget_element_by_id().

Por exemplo, você pode usar o métodofindall()para iterar sobre os elementosurl, encontrar seus elementosloc(que são elementos filhos do elementourl) e, em seguida, imprimir o texto de localização usando o seguinte código:

from lxml import etree
import requests

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)
if response.status_code == 200:

    root = etree.fromstring(response.content)
    

    para url em root.findall(".//{http://www.sitemaps.org/schemas/sitemap/0.9}url"):
        loc = url.find("{http://www.sitemaps.org/schemas/sitemap/0.9}loc").text.strip()
        imprimir(loc)
else:
    imprimir("Falha ao recuperar o arquivo XML da URL.")

A saída exibe todas as URLs encontradas no mapa do site:

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Proteção de marca
https://brightdata.com/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

Até agora, você aprendeu como encontrar elementos e imprimir seus valores. Agora, vamos explorar a validação do esquema antes do Parsing do XML. Esse processo garante que o arquivo esteja em conformidade com a estrutura especificada definida pelo esquema.

O XSD para o mapa do site é semelhante a este:

<?xml version="1.0"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
           targetNamespace="http://www.sitemaps.org/schemas/sitemap/0.9"
           xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
           elementFormDefault="qualified"
           xmlns:xhtml="http://www.w3.org/1999/xhtml">

  
  <xs:element nome="urlset">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="url" minOccurs="0" maxOccurs="unbounded"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  
  <xs:element name="url">
    <xs:complexType>
      <xs:sequence>
        <xs:element name="loc" type="xs:anyURI"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>

</xs:schema>

Para usar o mapa do site para validação de esquema, certifique-se de copiá-lo manualmente e criar um arquivo chamado schema.xsd.

Para validar o arquivo XML usando este XSD, use o seguinte código:

from lxml import etree

import requests

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)

if response.status_code == 200:

    root = etree.fromstring(response.content)

    try:
        print("Validação do esquema:")
        schema_doc = etree.parse("schema.xsd")  
        schema = etree.XMLSchema(schema_doc)  
        schema.assertValid(root)  
        print("XML é válido de acordo com o esquema.")
    except etree.DocumentInvalid as e:
        print("Erro de validação XML:", e)

Aqui, você realiza o Parsing do arquivo XSD usando o métodoetree.parse(). Em seguida, você cria um esquema XML usando o conteúdo do documento XSD analisado. Por fim, você valida o documento raiz XML em relação ao esquema XML usando o métodoassertValid(). Se a validação do esquema for aprovada, sua saída incluirá uma mensagem dizendo algo comoXML é válido de acordo com o esquema. Caso contrário, a exceçãoDocumentInvalidserá gerada.

Sua saída deve ficar assim:

 Validação do esquema:
    O XML é válido de acordo com o esquema.

Agora, vamos ler um arquivo XML que usa o método xpath para localizar os elementos usando seu caminho.

Para ler os elementos usando o método xpath(), use o seguinte código:

from lxml import etree

import requests

url = "https://brightdata.com/post-sitemap.xml"
response = requests.get(url)

if response.status_code == 200:
   
    root = etree.fromstring(response.content)
    
    print("Suporte a XPath:")
    root = etree.fromstring(response.content)

    namespaces = {"ns": "http://www.sitemaps.org/schemas/sitemap/0.9"}
    for url in root.xpath(".//ns:url/ns:loc", namespaces=namespaces):
        print(url.text.strip())

Neste código, você registra o prefixo do namespace ns e o mapeia para o URI do namespace http://www.sitemaps.org/schemas/sitemap/0.9. Na expressão XPath, você usa o prefixo ns para especificar elementos no namespace. Por fim, a expressão .//ns:url/ns:loc seleciona todos os elementos loc que são filhos dos elementos url no namespace.

Sua saída será semelhante a esta:

Suporte a XPath:

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Proteção de marca
https://brightdata.com/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

Como você pode ver, os métodos find() e findall() são mais rápidos do que o método xpath, pois o xpath coleta todos os resultados na memória antes de retorná-los. É recomendável usar o método find(), a menos que haja um motivo específico para usar consultas XPath.

O lxml oferece recursos poderosos para analisar e manipular XML e HTML. Ele suporta consultas complexas usandoexpressões XPath, valida documentos em relação a esquemas e até permitetransformações de linguagem de folha de estilo extensível (XSLT). Isso o torna ideal para cenários em que o desempenho e a funcionalidade avançada são cruciais. No entanto, lembre-se de que o lxml requer uma instalação separada, pois não faz parte do pacote Python principal.

Se você estiver lidando com dados XML grandes ou complexos que exigem alto desempenho e manipulação avançada, considere usar o lxml. Por exemplo, se você estiver processando feeds de dados financeiros no formato XML, talvez seja necessário usar expressões XPath para extrair elementos específicos, como preços de ações, validar os dados em relação a um esquema financeiro para garantir a precisão e, potencialmente, transformar os dados usando XSLT para análise posterior.

minidom

minidomé uma biblioteca de Parsing XML leve e simples incluída na biblioteca padrão do Python. Embora não seja tão rica em recursos ou eficiente quanto o Parsing com lxml, ela oferece uma maneira direta de analisar e manipular dados XML no Python.

Você pode usar os vários métodos disponíveis no objeto DOM para acessar elementos. Por exemplo, você pode usar ométodogetElementsByTagName()para recuperar o valor de um elemento usando seu nome de tag.

O exemplo a seguir demonstra como usar a biblioteca minidom para realizar o Parsing de um arquivo XML e buscar os elementos usando seus nomes de tag:

import requests
import xml.dom.minidom

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)
if response.status_code == 200:
    dom = xml.dom.minidom.parseString(response.content)
    
    urlset = dom.getElementsByTagName("urlset")[0]
    for url in urlset.getElementsByTagName("url"):
        loc = url.getElementsByTagName("loc")[0].firstChild.nodeValue.strip()
        print(loc)
else:
    print("Falha ao recuperar o arquivo XML da URL.")

Sua saída ficaria assim:

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Proteção de marca
https://brightdata.com/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

O minidom trabalha com dados XML representando-os como uma árvore DOM. Essa estrutura em árvore facilita a navegação e a manipulação de dados, sendo mais adequada para tarefas básicas, como ler, alterar ou construir estruturas XML simples.

Se o seu programa envolve a leitura de configurações padrão de um arquivo XML, a abordagem DOM do minidom permite que você acesse facilmente configurações específicas dentro do arquivo XML usando métodos como localizar nós filhos ou atributos. Com o minidom, você pode recuperar facilmente configurações específicas do arquivo XML, como o nó font-size, e utilizar seu valor dentro do seu aplicativo.

Analisador SAX

Oanalisador SAXé uma abordagem de Parsing XML orientada a eventos em Python que processa documentos XML sequencialmente e gera eventos à medida que encontra várias partes do documento. Ao contrário dos analisadores baseados em DOM que constroem uma estrutura em árvore representando todo o documento XML na memória, os analisadores SAX não constroem uma representação completa do documento. Em vez disso, eles emitem eventos como tags de início, tags de fim e conteúdo de texto à medida que analisam o documento.

Os analisadores SAX são bons para processar grandes arquivos ou fluxos XML em que a eficiência da memória é uma preocupação, pois operam em dados XML de forma incremental, sem carregar o documento inteiro na memória.

Ao usar o analisador SAX, você precisa definir os manipuladores de eventos que respondem a eventos XML específicos, como startElement e endElement emitidos pelo analisador. Esses manipuladores de eventos podem ser personalizados para executar ações com base na estrutura e no conteúdo do documento XML.

O exemplo a seguir demonstra como realizar o Parsing de um arquivo XML usando o analisador SAX, definindo os eventos startElement e endElement e recuperando as informações de URL do arquivo sitemap:

import requests
import xml.sax.handler
from io import BytesIO

class MyContentHandler(xml.sax.handler.ContentHandler):
    def __init__(self):
        self.in_url = False
        self.in_loc = False
        self.url = ""

    def startElement(self, name, attrs):
        if name == "url":
            self.in_url = True
        elif name == "loc" and self.in_url:
            self.in_loc = True

    def characters(self, content):
        if self.in_loc:
            self.url += content

    def endElement(self, name):
        if name == "url":
            imprimir(self.url.strip())
            self.url = ""
            self.in_url = False
        elif nome == "loc":
            self.in_loc = False

url = "https://brightdata.com/post-sitemap.xml"

resposta = requests.get(url)
se resposta.status_code == 200:

    xml_content = BytesIO(response.content)

content_handler = MyContentHandler()
parser = xml.sax.make_parser()
parser.setContentHandler(content_handler)
parser.parse(xml_content)
else:
print("Falha ao recuperar o arquivo XML da URL.")

Sua saída ficaria assim:

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Proteção de marca
https://brightdata.com/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

Ao contrário de outros analisadores que carregam o arquivo inteiro na memória, o SAX processa os arquivos de forma incremental, economizando memória e melhorando o desempenho. No entanto, o SAX exige a escrita de mais código para gerenciar cada segmento de dados dinamicamente. Além disso, ele não pode revisitar e analisar partes específicas dos dados posteriormente.

Se você precisar verificar um arquivo XML grande (por exemplo, um arquivo de log contendo vários eventos) para extrair informações específicas (por exemplo, mensagens de erro), o SAX pode ajudá-lo a navegar com eficiência pelo arquivo. No entanto, se sua análise exigir a compreensão das relações entre diferentes segmentos de dados, o SAX pode não ser a melhor escolha.

untangle

O untangleé uma biblioteca leve de Parsing XML para Python que simplifica o processo de extração de dados de documentos XML. Ao contrário dos analisadores XML tradicionais, que exigem a navegação por estruturas hierárquicas, o untangle permite acessar elementos e atributos XML diretamente como objetos Python.

Com o untangle, você pode converter documentos XML em dicionários Python aninhados, onde os elementos XML são representados como chaves de dicionário e seus atributos e conteúdo de texto são armazenados como valores correspondentes. Essa abordagem facilita o acesso e a manipulação de dados XML usando estruturas de dados Python.

O untangle não está disponível por padrão no Python e precisa ser instalado usando o seguinte comando PyPI:

pip install untangle

O exemplo a seguir demonstra como realizar o Parsing do arquivo XML usando a biblioteca untangle e acessar os elementos XML:

import untangle
import requests

url = "https://brightdata.com/post-sitemap.xml"

response = requests.get(url)

if response.status_code == 200:
  
    obj = untangle.parse(response.text)
    
    for url in obj.urlset.url:
        print(url.loc.cdata.strip())
else:
    print("Falha ao recuperar o arquivo XML da URL.")

Sua saída ficará assim:

https://brightdata.com/case-studies/powerdrop-case-study
https://brightdata.com/case-studies/Proteção de marca
https://brightdata.com/case-studies/taking-control-of-the-digital-shelf-with-public-online-data
https://brightdata.com/case-studies/the-seo-transformation
https://brightdata.com/case-studies/data-driven-automated-e-commerce-tools
https://brightdata.com/case-studies/highly-targeted-influencer-marketing
https://brightdata.com/case-studies/data-driven-products-for-smarter-shopping-solutions
https://brightdata.com/case-studies/workplace-diversity-facilitated-by-online-data
https://brightdata.com/case-studies/alternative-travel-solutions-enabled-by-online-data-railofy
https://brightdata.com/case-studies/data-intensive-analytical-solutions
https://brightdata.com/case-studies/canopy-advantage-solutions
https://brightdata.com/case-studies/seamless-digital-automations

O untangle oferece uma abordagem fácil de usar para trabalhar com dados XML em Python. Ele simplifica o processo de Parsing com uma sintaxe clara e converte automaticamente a estrutura XML em objetos Python fáceis de usar, eliminando a necessidade de técnicas de navegação complexas. No entanto, lembre-se de que o untangle requer instalação separada, pois não faz parte do pacote Python principal.

Você deve considerar o uso do untangle se tiver um arquivo XML bem formado e precisar convertê-lo rapidamente em objetos Python para processamento posterior. Por exemplo, se você tiver um programa que baixa dados meteorológicos no formato XML, o untangle pode ser uma boa opção para analisar o XML e criar objetos Python que representam a temperatura, a umidade e a previsão do tempo atuais. Esses objetos podem então ser facilmente manipulados e exibidos em seu aplicativo.

Conclusão

Neste artigo, você aprendeu tudo sobre arquivos XML e os vários métodos de Parsing de arquivos XML em Python.

Esteja você trabalhando com pequenos arquivos de configuração, analisando grandes respostas de serviços da web ou extraindo dados de mapas de sites extensos, o Python oferece bibliotecas versáteis para automatizar e otimizar suas tarefas de Parsing de XML. No entanto, ao acessar arquivos da web usando a biblioteca de solicitações sem gerenciamento de Proxy, você pode encontrar exceções de cota e problemas de limitação.A Bright Dataé uma rede de Proxy premiada que fornecesoluções de Proxyconfiáveis e eficientes para garantir a recuperação e Parsing de dados sem interrupções. Com a Bright Data, você pode realizar tarefas de Parsing de XML sem se preocupar com limitações ou interrupções. Contate-nos para saber mais.

Quer pular todo o processo de scraping e Parsing? Experimente nosso mercado de Conjuntos de dados gratuitamente!