Ejemplo de Python xml.dom.minidom

Código fuente:Lib / xml / dom / minidom.py

xml.dom.minidom es una implementación mínima de la interfaz Document Object Model, con una API similar a la de otros lenguajes. Está destinado a ser más simple que el DOM completo y también significativamente más pequeño. Los usuarios que aún no dominan el DOM deben considerar el uso de xml.etree.ElementTree módulo para su procesamiento XML en su lugar.

Advertencia

los xml.dom.minidom módulo no es seguro contra datos construidos maliciosamente. Si necesita analizar datos que no son de confianza o no autenticados, consulte Vulnerabilidades XML.

Las aplicaciones DOM normalmente comienzan analizando algunos XML en un DOM. Con xml.dom.minidom, esto se hace a través de las funciones de análisis:

from xml.dom.minidom import parse, parseString

dom1 = parse('c:\temp\mydata.xml')# parse an XML file by name

datasource =open('c:\temp\mydata.xml')
dom2 = parse(datasource)# parse an open file

dom3 = parseString('Some data some more data')

los parse() La función puede tomar un nombre de archivo o un objeto de archivo abierto.

xml.dom.minidom.parse(filename_or_file, parser=None, bufsize=None)

Devolver un Document de la entrada dada. nombre_archivo_o_archivo puede ser un nombre de archivo o un objeto similar a un archivo. analizador, si se proporciona, debe ser un objeto analizador SAX2. Esta función cambiará el manejador de documentos del analizador y activará la compatibilidad con el espacio de nombres; otra configuración del analizador (como configurar un solucionador de entidades) debe haberse realizado de antemano.

Si tiene XML en un string, puedes usar el parseString() función en su lugar:

xml.dom.minidom.parseString(string, parser=None)

Devolver un Document que representa el string. Este método crea una io.StringIO objeto para el string y pasa eso a parse().

Ambas funciones devuelven un Document objeto que representa el contenido del documento.

Que parse() y parseString() Las funciones que hacen es conectar un analizador XML con un “constructor DOM” que puede aceptar eventos de análisis de cualquier analizador SAX y convertirlos en un árbol DOM. El nombre de las funciones es quizás engañoso, pero es fácil de entender al aprender las interfaces. El análisis del documento se completará antes de que regresen estas funciones; es simplemente que estas funciones no proporcionan una implementación de analizador por sí mismas.

También puede crear un Document llamando a un método en un objeto “Implementación DOM”. Puede obtener este objeto llamando al getDOMImplementation() función en el xml.dom paquete o el xml.dom.minidom módulo. Una vez que tienes un Document, puede agregarle nodos secundarios para completar el DOM:

from xml.dom.minidom import getDOMImplementation

impl = getDOMImplementation()

newdoc = impl.createDocument(None,"some_tag",None)
top_element = newdoc.documentElement
text = newdoc.createTextNode('Some textual content.')
top_element.appendChild(text)

Una vez que tenga un objeto de documento DOM, puede acceder a las partes de su documento XML a través de sus propiedades y métodos. Estas propiedades se definen en la especificación DOM. La propiedad principal del objeto de documento es la documentElement propiedad. Le da el elemento principal en el documento XML: el que contiene todos los demás. Aquí hay un programa de ejemplo:

dom3 = parseString("Some data")assert dom3.documentElement.tagName =="myxml"

Cuando haya terminado con un árbol DOM, opcionalmente puede llamar al unlink() método para fomentar la limpieza temprana de los objetos ahora innecesarios. unlink() es un xml.dom.minidom-extensión específica de la API DOM que hace que el nodo y sus descendientes sean esencialmente inútiles. De lo contrario, el recolector de basura de Python eventualmente se encargará de los objetos en el árbol.

Ver también

Especificación de nivel 1 del modelo de objetos de documento (DOM)

La recomendación del W3C para DOM respaldada por xml.dom.minidom.

Objetos DOM

La definición de la API DOM para Python se proporciona como parte de la xml.dom documentación del módulo. Esta sección enumera las diferencias entre la API y xml.dom.minidom.

Node.unlink()

Romper las referencias internas dentro del DOM para que se recolecte la basura en las versiones de Python sin GC cíclico. Incluso cuando la GC cíclica está disponible, su uso puede hacer que grandes cantidades de memoria estén disponibles antes, por lo que llamar a esto en objetos DOM tan pronto como ya no se necesiten es una buena práctica. Esto solo necesita ser llamado en el Document objeto, pero se puede llamar en los nodos secundarios para descartar los elementos secundarios de ese nodo.

Puede evitar llamar a este método explícitamente utilizando el with declaración. El siguiente código se desvinculará automáticamente dom cuando el with se sale del bloque:

with xml.dom.minidom.parse(datasource)as dom:...# Work with dom.

Node.writexml(writer, indent="", addindent="", newl="", encoding=None, standalone=None)

Escriba XML en el objeto escritor. El escritor recibe textos pero no bytes como entrada, debe tener un write() método que coincide con el de la interfaz del objeto de archivo. los sangrar El parámetro es la sangría del nodo actual. los addindent El parámetro es la sangría incremental que se utilizará para los subnodos del actual. los newl parámetro especifica el string utilizar para terminar las nuevas líneas.

Para el Document nodo, un argumento de palabra clave adicional codificacion se puede utilizar para especificar el campo de codificación del encabezado XML.

Silimar, declarando explícitamente el ser único El argumento hace que las declaraciones del documento independiente se agreguen al prólogo del documento XML. Si el valor se establece en True, standalone=”yes” se agrega, de lo contrario, se establece en “no”. No declarar el argumento omitirá la declaración del documento.

Modificado en la versión 3.8: los writexml() El método ahora conserva el attribute orden especificado por el usuario.

Node.toxml(encoding=None, standalone=None)

Devolver un string o byte string que contiene el XML representado por el nodo DOM.

Con un explícito codificacion1 argumento, el resultado es un byte string en la codificación especificada. Sin codificacion argumento, el resultado es un Unicode string, y la declaración XML en el resultado string no especifica una codificación. Codificando esto string en una codificación diferente a UTF-8 es probablemente incorrecta, ya que UTF-8 es la codificación predeterminada de XML.

los ser único El argumento se comporta exactamente como en writexml().

Modificado en la versión 3.8: los toxml() El método ahora conserva el attribute orden especificado por el usuario.

Node.toprettyxml(indent="t", newl="n", encoding=None, standalone=None)

Devuelva una versión bonita impresa del documento. sangrar especifica la sangría string y por defecto es un tabulador; newl especifica el string emitido al final de cada línea y por defecto es n.

los codificacion argumento se comporta como el argumento correspondiente de toxml().

los ser único El argumento se comporta exactamente como en writexml().

Modificado en la versión 3.8: los toprettyxml() El método ahora conserva el attribute orden especificado por el usuario.

Ejemplo de DOM

Este programa de ejemplo es un ejemplo bastante realista de un programa simple. En este caso particular, no aprovechamos mucho la flexibilidad del DOM.

import xml.dom.minidom

document ="""



This is a demo
Of a program for processing slides



It is important
To have more than
one slide


"""

dom = xml.dom.minidom.parseString(document)defgetText(nodelist):
    rc =[]for node in nodelist:if node.nodeType == node.TEXT_NODE:
            rc.append(node.data)return''.join(rc)defhandleSlideshow(slideshow):print("")
    handleSlideshowTitle(slideshow.getElementsByTagName("title")[0])
    slides = slideshow.getElementsByTagName("slide")
    handleToc(slides)
    handleSlides(slides)print("")defhandleSlides(slides):for slide in slides:
        handleSlide(slide)defhandleSlide(slide):
    handleSlideTitle(slide.getElementsByTagName("title")[0])
    handlePoints(slide.getElementsByTagName("point"))defhandleSlideshowTitle(title):print(""% getText(title.childNodes))defhandleSlideTitle(title):print("
%s
"% getText(title.childNodes))defhandlePoints(points):print("
")for point in points:
        handlePoint(point)print("
")defhandlePoint(point):print("
%s
"% getText(point.childNodes))defhandleToc(slides):for slide in slides:
        title = slide.getElementsByTagName("title")[0]print("
%s
"% getText(title.childNodes))

handleSlideshow(dom)

minidom y el estándar DOM

los xml.dom.minidom El módulo es esencialmente un DOM compatible con DOM 1.0 con algunas características de DOM 2 (principalmente características de espacio de nombres).

El uso de la interfaz DOM en Python es sencillo. Se aplican las siguientes reglas de mapeo:

• Se accede a las interfaces a través de objetos de instancia. Las aplicaciones no deben crear instancias de las clases en sí mismas; deben utilizar las funciones de creador disponibles en el Document objeto. Las interfaces derivadas admiten todas las operaciones (y attributes) desde las interfaces base, más cualquier operación nueva.
• Las operaciones se utilizan como métodos. Dado que el DOM solo usa in parámetros, los argumentos se pasan en orden normal (de izquierda a derecha). No hay argumentos opcionales. void retorno de operaciones None.
• IDL attributes mapear a instancia attributes. Para compatibilidad con el mapeo de lenguaje OMG IDL para Python, un attribute foo también se puede acceder a través de métodos de acceso _get_foo() y _set_foo(). readonly attributes no debe cambiarse; esto no se aplica en tiempo de ejecución.
• Los tipos short int, unsigned int, unsigned long long, y boolean todos se asignan a objetos enteros de Python.
• El tipo DOMString se asigna a cadenas de Python. xml.dom.minidom admite bytes o cadenas, pero normalmente producirá cadenas. Valores de tipo DOMString tambien puede ser None donde se permite tener la IDL null valor por la especificación DOM del W3C.
• const las declaraciones se asignan a variables en su ámbito respectivo (por ejemplo, xml.dom.minidom.Node.PROCESSING_INSTRUCTION_NODE); no deben cambiarse.
• DOMException actualmente no es compatible con xml.dom.minidom. En lugar de, xml.dom.minidom utiliza excepciones estándar de Python como TypeError y AttributeError.
• NodeList Los objetos se implementan usando el tipo de lista incorporado de Python. Estos objetos proporcionan la interfaz definida en la especificación DOM, pero con versiones anteriores de Python no son compatibles con la API oficial. Sin embargo, son mucho más “Pythonic” que la interfaz definida en las recomendaciones del W3C.

Las siguientes interfaces no tienen implementación en xml.dom.minidom:

• DOMTimeStamp
• EntityReference

La mayoría de estos reflejan información en el documento XML que no es de utilidad general para la mayoría de los usuarios de DOM.

Notas al pie

1

El nombre de codificación incluido en la salida XML debe ajustarse a los estándares apropiados. Por ejemplo, “UTF-8” es válido, pero “UTF8” no es válido en la declaración de un documento XML, aunque Python lo acepta como un nombre de codificación. Ver https://www.w3.org/TR/2006/REC-xml11-20060816/#NT-EncodingDecl y https://www.iana.org/assignments/character-sets/character-sets.xhtml.