Python 3 - Processamento XML
XML é uma linguagem portátil e de código aberto que permite aos programadores desenvolver aplicativos que podem ser lidos por outros aplicativos, independentemente do sistema operacional e / ou linguagem de desenvolvimento.
O que é XML?
A Extensible Markup Language (XML) é uma linguagem de marcação muito parecida com HTML ou SGML. Isso é recomendado pelo World Wide Web Consortium e está disponível como um padrão aberto.
XML é extremamente útil para manter o controle de pequenas e médias quantidades de dados sem exigir um backbone baseado em SQL.
Arquiteturas XML Parser e APIs
A biblioteca padrão Python fornece um conjunto mínimo, mas útil de interfaces para trabalhar com XML.
As duas APIs mais básicas e amplamente utilizadas para dados XML são as interfaces SAX e DOM.
Simple API for XML (SAX)- Aqui, você registra retornos de chamada para eventos de interesse e, em seguida, permite que o analisador prossiga pelo documento. Isso é útil quando seus documentos são grandes ou você tem limitações de memória, ele analisa o arquivo à medida que o lê do disco e o arquivo inteiro nunca é armazenado na memória.
Document Object Model (DOM) API - Esta é uma recomendação do World Wide Web Consortium em que todo o arquivo é lido na memória e armazenado em uma forma hierárquica (baseada em árvore) para representar todos os recursos de um documento XML.
SAX obviamente não pode processar informações tão rápido quanto DOM, ao trabalhar com arquivos grandes. Por outro lado, usar o DOM exclusivamente pode realmente matar seus recursos, especialmente se usado em muitos arquivos pequenos.
SAX é somente leitura, enquanto DOM permite alterações no arquivo XML. Uma vez que essas duas APIs diferentes se complementam literalmente, não há razão para que você não possa usá-las para grandes projetos.
Para todos os nossos exemplos de código XML, vamos usar um arquivo XML simples movies.xml como entrada -
<collection shelf = "New Arrivals">
<movie title = "Enemy Behind">
<type>War, Thriller</type>
<format>DVD</format>
<year>2003</year>
<rating>PG</rating>
<stars>10</stars>
<description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
<type>Anime, Science Fiction</type>
<format>DVD</format>
<year>1989</year>
<rating>R</rating>
<stars>8</stars>
<description>A schientific fiction</description>
</movie>
<movie title = "Trigun">
<type>Anime, Action</type>
<format>DVD</format>
<episodes>4</episodes>
<rating>PG</rating>
<stars>10</stars>
<description>Vash the Stampede!</description>
</movie>
<movie title = "Ishtar">
<type>Comedy</type>
<format>VHS</format>
<rating>PG</rating>
<stars>2</stars>
<description>Viewable boredom</description>
</movie>
</collection>Análise de XML com APIs SAX
SAX é uma interface padrão para análise XML baseada em eventos. A análise de XML com SAX geralmente requer que você crie seu próprio ContentHandler criando uma subclasse de xml.sax.ContentHandler.
Seu ContentHandler lida com as tags e atributos específicos de seu (s) tipo (s) de XML. Um objeto ContentHandler fornece métodos para lidar com vários eventos de análise. Seu próprio analisador chama métodos ContentHandler à medida que analisa o arquivo XML.
Os métodos startDocument e endDocument são chamados no início e no final do arquivo XML. Os caracteres do método (texto) são transmitidos aos dados dos caracteres do arquivo XML por meio do texto do parâmetro.
O ContentHandler é chamado no início e no final de cada elemento. Se o analisador não estiver no modo de namespace, os métodos startElement (tag, atributos) e endElement (tag) são chamados; caso contrário, os métodos correspondentes startElementNS e endElementNS são chamados. Aqui, tag é a tag do elemento, e attribute é um objeto Attributes.
Aqui estão outros métodos importantes para entender antes de prosseguir -
O método make_parser
O método a seguir cria um novo objeto analisador e o retorna. O objeto analisador criado será do primeiro tipo de analisador que o sistema encontrar.
xml.sax.make_parser( [parser_list] )Aqui estão os detalhes dos parâmetros -
parser_list - O argumento opcional que consiste em uma lista de analisadores a serem usados, os quais devem implementar o método make_parser.
O método de análise
O método a seguir cria um analisador SAX e o usa para analisar um documento.
xml.sax.parse( xmlfile, contenthandler[, errorhandler])Aqui estão os detalhes dos parâmetros -
xmlfile - Este é o nome do arquivo XML a partir do qual ler.
contenthandler - Deve ser um objeto ContentHandler.
errorhandler - Se especificado, errorhandler deve ser um objeto SAX ErrorHandler.
O método parseString
Há mais um método para criar um analisador SAX e analisar o especificado XML string.
xml.sax.parseString(xmlstring, contenthandler[, errorhandler])Aqui estão os detalhes dos parâmetros -
xmlstring - Este é o nome da string XML a partir da qual ler.
contenthandler - Deve ser um objeto ContentHandler.
errorhandler - Se especificado, errorhandler deve ser um objeto SAX ErrorHandler.
Exemplo
#!/usr/bin/python3
import xml.sax
class MovieHandler( xml.sax.ContentHandler ):
def __init__(self):
self.CurrentData = ""
self.type = ""
self.format = ""
self.year = ""
self.rating = ""
self.stars = ""
self.description = ""
# Call when an element starts
def startElement(self, tag, attributes):
self.CurrentData = tag
if tag == "movie":
print ("*****Movie*****")
title = attributes["title"]
print ("Title:", title)
# Call when an elements ends
def endElement(self, tag):
if self.CurrentData == "type":
print ("Type:", self.type)
elif self.CurrentData == "format":
print ("Format:", self.format)
elif self.CurrentData == "year":
print ("Year:", self.year)
elif self.CurrentData == "rating":
print ("Rating:", self.rating)
elif self.CurrentData == "stars":
print ("Stars:", self.stars)
elif self.CurrentData == "description":
print ("Description:", self.description)
self.CurrentData = ""
# Call when a character is read
def characters(self, content):
if self.CurrentData == "type":
self.type = content
elif self.CurrentData == "format":
self.format = content
elif self.CurrentData == "year":
self.year = content
elif self.CurrentData == "rating":
self.rating = content
elif self.CurrentData == "stars":
self.stars = content
elif self.CurrentData == "description":
self.description = content
if ( __name__ == "__main__"):
# create an XMLReader
parser = xml.sax.make_parser()
# turn off namepsaces
parser.setFeature(xml.sax.handler.feature_namespaces, 0)
# override the default ContextHandler
Handler = MovieHandler()
parser.setContentHandler( Handler )
parser.parse("movies.xml")Resultado
Isso produziria o seguinte resultado -
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredomPara obter detalhes completos sobre a documentação da API SAX, consulte as APIs SAX Python padrão .
Analisando XML com APIs DOM
O Document Object Model ("DOM") é uma API de linguagem cruzada do World Wide Web Consortium (W3C) para acessar e modificar os documentos XML.
O DOM é extremamente útil para aplicativos de acesso aleatório. SAX só permite a visualização de um bit do documento por vez. Se você estiver olhando para um elemento SAX, não terá acesso a outro.
Aqui está a maneira mais fácil de carregar um documento XML rapidamente e criar um objeto minidom usando o módulo xml.dom. O objeto minidom fornece um método analisador simples que cria rapidamente uma árvore DOM a partir do arquivo XML.
A frase de amostra chama a função parse (file [, parser]) do objeto minidom para analisar o arquivo XML, designado por arquivo em um objeto de árvore DOM.
Exemplo
#!/usr/bin/python3
from xml.dom.minidom import parse
import xml.dom.minidom
# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
print ("Root element : %s" % collection.getAttribute("shelf"))
# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")
# Print detail of each movie.
for movie in movies:
print ("*****Movie*****")
if movie.hasAttribute("title"):
print ("Title: %s" % movie.getAttribute("title"))
type = movie.getElementsByTagName('type')[0]
print ("Type: %s" % type.childNodes[0].data)
format = movie.getElementsByTagName('format')[0]
print ("Format: %s" % format.childNodes[0].data)
rating = movie.getElementsByTagName('rating')[0]
print ("Rating: %s" % rating.childNodes[0].data)
description = movie.getElementsByTagName('description')[0]
print ("Description: %s" % description.childNodes[0].data)Resultado
Isso produziria o seguinte resultado -
Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A scientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredomPara obter detalhes completos sobre a documentação da API DOM, consulte as APIs DOM padrão do Python .