Modificare XML come dizionario in Python?

StackOverflow https://stackoverflow.com/questions/127606

  •  02-07-2019
  •  | 
  •  

Domanda

Sto provando a generare file XML personalizzati da un file XML modello in Python.

Concettualmente, voglio leggere nel modello xml, rimuovere alcuni elementi, modificare alcuni attributi di testo e scrivere il nuovo xml in un file. Volevo che funzionasse in questo modo: 

conf_base = ConvertXmlToDict('config-template.xml')
conf_base_dict = conf_base.UnWrap()
del conf_base_dict['root-name']['level1-name']['leaf1']
del conf_base_dict['root-name']['level1-name']['leaf2']

conf_new = ConvertDictToXml(conf_base_dict)

ora voglio scrivere su un file, ma non vedo come arrivare ElementTree.ElementTree.write () 

conf_new.write('config-new.xml')

C'è un modo per farlo o qualcuno può suggerire di farlo in un modo diverso?

È stato utile?

Soluzione

Per manipolare facilmente XML in Python, mi piace la libreria Beautiful Soup . Funziona in questo modo:

File XML di esempio: 

<root>
  <level1>leaf1</level1>
  <level2>leaf2</level2>
</root>

Codice Python: 

from BeautifulSoup import BeautifulStoneSoup, Tag, NavigableString

soup = BeautifulStoneSoup('config-template.xml') # get the parser for the xml file
soup.contents[0].name
# u'root'

Puoi usare i nomi dei nodi come metodi: 

soup.root.contents[0].name
# u'level1'

È anche possibile usare regex: 

import re
tags_starting_with_level = soup.findAll(re.compile('^level'))
for tag in tags_starting_with_level: print tag.name
# level1
# level2

L'aggiunta e l'inserimento di nuovi nodi è piuttosto semplice: 

# build and insert a new level with a new leaf
level3 = Tag(soup, 'level3')
level3.insert(0, NavigableString('leaf3')
soup.root.insert(2, level3)

print soup.prettify()
# <root>
#  <level1>
#   leaf1
#  </level1>
#  <level2>
#   leaf2
#  </level2>
#  <level3>
#   leaf3
#  </level3>
# </root>

Altri suggerimenti

Questo ti darà un dict meno attributi ... non so se questo è utile a chiunque. Stavo cercando un xml per dettare me stesso la soluzione quando ho trovato questo. 



import xml.etree.ElementTree as etree

tree = etree.parse('test.xml')
root = tree.getroot()

def xml_to_dict(el):
  d={}
  if el.text:
    d[el.tag] = el.text
  else:
    d[el.tag] = {}
  children = el.getchildren()
  if children:
    d[el.tag] = map(xml_to_dict, children)
  return d

Questo: http://www.w3schools.com/XML/note.xml 

<note>
 <to>Tove</to>
 <from>Jani</from>
 <heading>Reminder</heading>
 <body>Don't forget me this weekend!</body>
</note>

Sarebbe uguale a questo: 


{'note': [{'to': 'Tove'},
          {'from': 'Jani'},
          {'heading': 'Reminder'},
          {'body': "Don't forget me this weekend!"}]}

Non sono sicuro che sia più semplice convertire prima le informazioni in dadi nidificati. Utilizzando ElementTree, puoi farlo: 

import xml.etree.ElementTree as ET
doc = ET.parse("template.xml")
lvl1 = doc.findall("level1-name")[0]
lvl1.remove(lvl1.find("leaf1")
lvl1.remove(lvl1.find("leaf2")
# or use del lvl1[idx]
doc.write("config-new.xml")

ElementTree è stato progettato in modo da non dover prima convertire i tuoi alberi XML in elenchi e attributi, poiché utilizza esattamente quello internamente.

Supporta anche come piccolo sottoinsieme di XPath .

La mia modifica della risposta di Daniel, per dare un dizionario marginalmente più ordinato: 

def xml_to_dictionary(element):
    l = len(namespace)
    dictionary={}
    tag = element.tag[l:]
    if element.text:
        if (element.text == ' '):
            dictionary[tag] = {}
        else:
            dictionary[tag] = element.text
    children = element.getchildren()
    if children:
        subdictionary = {}
        for child in children:
            for k,v in xml_to_dictionary(child).items():
                if k in subdictionary:
                    if ( isinstance(subdictionary[k], list)):
                        subdictionary[k].append(v)
                    else:
                        subdictionary[k] = [subdictionary[k], v]
                else:
                    subdictionary[k] = v
        if (dictionary[tag] == {}):
            dictionary[tag] = subdictionary
        else:
            dictionary[tag] = [dictionary[tag], subdictionary]
    if element.attrib:
        attribs = {}
        for k,v in element.attrib.items():
            attribs[k] = v
        if (dictionary[tag] == {}):
            dictionary[tag] = attribs
        else:
            dictionary[tag] = [dictionary[tag], attribs]
    return dictionary

lo spazio dei nomi è la stringa xmlns, comprese le parentesi graffe, che ElementTree antepone a tutti i tag, quindi qui l'ho cancellato in quanto esiste uno spazio dei nomi per l'intero documento

NB che ho modificato anche l'xml non elaborato, in modo che i tag 'vuoti' producessero al massimo una '' proprietà text nella rappresentazione ElementTree 

spacepattern = re.compile(r'\s+')
mydictionary = xml_to_dictionary(ElementTree.XML(spacepattern.sub(' ', content)))

darebbe ad esempio 

{'note': {'to': 'Tove',
         'from': 'Jani',
         'heading': 'Reminder',
         'body': "Don't forget me this weekend!"}}

è progettato per xml specifici che è sostanzialmente equivalente a json, dovrebbe gestire attributi di elementi come 

<elementName attributeName='attributeContent'>elementContent</elementName>

Anche

esiste la possibilità di unire il dizionario degli attributi / dizionario dei tag secondari in modo simile a come vengono uniti i tag secondari ripetuti, anche se l'annidamento degli elenchi sembra un po 'appropriato :-)

Aggiunta di questa riga 

d.update(('@' + k, v) for k, v in el.attrib.iteritems())

nel codice dell'utente247686 puoi avere anche attributi di nodo.

Trovato in questo post https://stackoverflow.com/a/7684581/1395962

Esempio: 

import xml.etree.ElementTree as etree
from urllib import urlopen

xml_file = "http://your_xml_url"
tree = etree.parse(urlopen(xml_file))
root = tree.getroot()

def xml_to_dict(el):
    d={}
    if el.text:
        d[el.tag] = el.text
    else:
        d[el.tag] = {}
    children = el.getchildren()
    if children:
        d[el.tag] = map(xml_to_dict, children)

    d.update(('@' + k, v) for k, v in el.attrib.iteritems())

    return d

Chiama come 

xml_to_dict(root)

Hai provato questo? 

print xml.etree.ElementTree.tostring( conf_new )

il modo più diretto per me: 

root        = ET.parse(xh)
data        = root.getroot()
xdic        = {}
if data > None:
    for part in data.getchildren():
        xdic[part.tag] = part.text

XML ha un ricco infoset e ci vogliono alcuni trucchi speciali per rappresentarlo in un dizionario Python. Gli elementi sono ordinati, gli attributi sono distinti dai corpi degli elementi, ecc.

Un progetto per gestire i round trip tra i dizionari XML e Python, con alcune opzioni di configurazione per gestire i compromessi in diversi modi è Supporto XML negli strumenti di decapaggio . È richiesta la versione 1.3 e successive. Non è Python puro (e in effetti è progettato per facilitare l'interazione C ++ / Python), ma potrebbe essere appropriato per vari casi d'uso.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top