La comparaison de deux fichiers xml en python

Je suis nouveau à la programmation en python,et j'ai quelques problèmes pour comprendre le concept. Je souhaite comparer deux fichiers xml. Ces fichiers xml sont assez grandes.
Je vais donner un exemple pour le type de fichiers que je souhaite comparer.

xmlfile1:

<xml>
    <property1>
          <property2>    
               <property3>

               </property3>
          </property2>    
    </property1>    
</xml>

xml fichier2:

<xml>
    <property1>
        <property2>    
            <property3> 
                <property4>

                </property4>    
            </property3>
        </property2>    
    </property1>

</xml>

la propriété1,propriété2 que j'ai cités sont différents de ceux qui sont réellement dans le fichier. Il y a beaucoup de propriétés dans le fichier xml.
Et je souhaite comparer les deux fichiers xml.

Je suis en utilisant un lxml analyseur essayer de comparer les deux fichiers et imprimer la différence entre eux.

Je ne sais pas comment l'analyser et de comparer automatiquement.

J'ai essayé de lire l'lxml de l'analyseur, mais je ne pourrais pas comprendre comment l'utiliser pour mon problème.

Quelqu'un peut-il me dire comment dois-je procéder avec ce problème.

Des extraits de Code peut être très utile

Encore une question, Suis-je sur la bonne notion de la ou je suis absent quelque chose d'autre? S'il vous plaît corrigez-moi de tous les nouveaux concepts que vous connaissez à propos de

Que recherchez-vous dans la sortie - si c'est juste une différence, vous pourriez vouloir utiliser diff dans linux ou fc dans windows
en fait, je veux savoir quelle partie du fichier a été modifié.

InformationsquelleAutor sankar | 2014-06-30

7

C'est en fait un raisonnablement problème difficile (en raison de ce que la "différence" signifie souvent être dans l'œil du spectateur, ici, comme il n'y aura point de vue sémantique "équivalent" d'informations que vous ne voulez probablement pas marquées que les différences).

Vous pouvez essayer d'utiliser xmldiff, qui est basée sur le travail dans le papier La Détection de changement dans Hiérarchiquement Structurée de l'Information.
- xmldiff est GPL. Cela signifie que je dois ouvrir la source de mon code source, si je l'utiliser?
- Nécro-de répondre de référence: GPL signifie que vous devrez fournir le code source à un utilisateur, si la demande lui/elle pour le faire. Cela ne signifie pas que vous pour pour le rendre public pour tout le monde (ni libre), et vous pouvez toujours mettre des restrictions supplémentaires sur l'utilisateur avec les autres contrats.
InformationsquelleAutor Nick Bastin

Mon approche du problème a été la transformation de chaque document XML dans une xml.programme etree.ElementTree et d'une itération dans chacune des couches.
J'ai aussi inclus la fonctionnalité d'ignorer une liste d'attributs, tout en faisant la comparaison.

Le premier bloc de code est titulaire de la classe utilisée:

import xml.etree.ElementTree as ET
import logging
class XmlTree():
def __init__(self):
self.hdlr = logging.FileHandler('xml-comparison.log')
self.formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
@staticmethod
def convert_string_to_tree( xmlString):
return ET.fromstring(xmlString)
def xml_compare(self, x1, x2, excludes=[]):
"""
Compares two xml etrees
:param x1: the first tree
:param x2: the second tree
:param excludes: list of string of attributes to exclude from comparison
:return:
True if both files match
"""
if x1.tag != x2.tag:
self.logger.debug('Tags do not match: %s and %s' % (x1.tag, x2.tag))
return False
for name, value in x1.attrib.items():
if not name in excludes:
if x2.attrib.get(name) != value:
self.logger.debug('Attributes do not match: %s=%r, %s=%r'
% (name, value, name, x2.attrib.get(name)))
return False
for name in x2.attrib.keys():
if not name in excludes:
if name not in x1.attrib:
self.logger.debug('x2 has an attribute x1 is missing: %s'
% name)
return False
if not self.text_compare(x1.text, x2.text):
self.logger.debug('text: %r != %r' % (x1.text, x2.text))
return False
if not self.text_compare(x1.tail, x2.tail):
self.logger.debug('tail: %r != %r' % (x1.tail, x2.tail))
return False
cl1 = x1.getchildren()
cl2 = x2.getchildren()
if len(cl1) != len(cl2):
self.logger.debug('children length differs, %i != %i'
% (len(cl1), len(cl2)))
return False
i = 0
for c1, c2 in zip(cl1, cl2):
i += 1
if not c1.tag in excludes:
if not self.xml_compare(c1, c2, excludes):
self.logger.debug('children %i do not match: %s'
% (i, c1.tag))
return False
return True
def text_compare(self, t1, t2):
"""
Compare two text strings
:param t1: text one
:param t2: text two
:return:
True if a match
"""
if not t1 and not t2:
return True
if t1 == '*' or t2 == '*':
return True
return (t1 or '').strip() == (t2 or '').strip()

Le deuxième bloc de code est titulaire d'un couple d'exemples de XML et leur comparaison:

xml1 = "<note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>"
xml2 = "<note><to>Tove</to><from>Daniel</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>"
tree1 = XmlTree.convert_string_to_tree(xml1)
tree2 = XmlTree.convert_string_to_tree(xml2)
comparator = XmlTree()
if comparator.xml_compare(tree1, tree2, ["from"]):
print "XMLs match"
else:
print "XMLs don't match"

Plus grande partie du crédit de ce code doit être donnée à la syawar

ce code doit tweaks pour travailler sur Python3.5 comme ci-dessous: def __init__(self): self.logger = logging.getLogger('xml_compare') self.logger.setLevel(logging.DEBUG) self.hdlr = logging.FileHandler('xml-comparison.log') self.formatter = logging.Formatter('%(asctime)s - %(levelname)s- %(message)s') self.hdlr.setLevel(logging.DEBUG) self.hdlr.setFormatter(self.formatter) self.logger.addHandler(self.hdlr)
Peut-être que j'ai raté quelque chose, mais cette méthode dès qu'il trouve une différence arrêter de vérifier le XML, c'est une bonne façon de commencer, mais il ne fonctionne pas comme prévu...

InformationsquelleAutor danimirror

Un autre script à l'aide de xml.programme etree. Son horrible mais il fonctionne 🙂

#!/usr/bin/env python
import sys
import xml.etree.ElementTree as ET
from termcolor import colored
tree1 = ET.parse(sys.argv[1])
root1 = tree1.getroot()
tree2 = ET.parse(sys.argv[2])
root2 = tree2.getroot()
class Element:
def __init__(self,e):
self.name = e.tag
self.subs = {}
self.atts = {}
for child in e:
self.subs[child.tag] = Element(child)
for att in e.attrib.keys():
self.atts[att] = e.attrib[att]
print "name: %s, len(subs) = %d, len(atts) = %d" % ( self.name, len(self.subs), len(self.atts) )
def compare(self,el):
if self.name!=el.name:
raise RuntimeError("Two names are not the same")
print "----------------------------------------------------------------"
print self.name
print "----------------------------------------------------------------"
for att in self.atts.keys():
v1 = self.atts[att]
if att not in el.atts.keys():
v2 = '[NA]'
color = 'yellow'
else:
v2 = el.atts[att]
if v2==v1:
color = 'green'
else:
color = 'red'
print colored("first:\t%s = %s" % ( att, v1 ), color)
print colored("second:\t%s = %s" % ( att, v2 ), color)
for subName in self.subs.keys():
if subName not in el.subs.keys():
print colored("first:\thas got %s" % ( subName), 'purple')
print colored("second:\thasn't got %s" % ( subName), 'purple')
else:
self.subs[subName].compare( el.subs[subName] )
e1 = Element(root1)
e2 = Element(root2)
e1.compare(e2)

InformationsquelleAutor user3483524

Vous devez vous connecter pour publier un commentaire.