comptage de balise <Page> dans un grand fichier XML

Version imprimable

Bonjour à tous,
Je suis débutante en Python et j'essaye de faire un script pour extraire le nombre de balise <Page> afin de connaitre le nombre de pages que j'ai dans mon fichier XML. Ce fichier XML est très grand c'est pourquoi j'utilise le module SAX.
Voici mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
#!/usr/bin/python
#-*- coding:utf-8 -*-
import string
import sys
from xml.sax import ContentHandler,make_parser
 
 
class MaClasseContentHandler(ContentHandler):
  def startElement(self, name, attrs):
     print "Start element:", name
 
class MaClassePage(ContentHandler):
    def __init__(self):
        ContentHandler.__init__(self)
        self.n = 0
 
    def startElement(self, Page, attrs):
        self.n += 1
 
####parser = make_parser()# parser le doc
####handler = MaClasseContentHandler()
####parser.setContentHandler(handler)
####parser.parse("monfic.xml")
 
handler = MaClassePage()
parser = make_parser()
parser.setContentHandler(handler)
parser.parse("monfic.xml")
 
print  handler.n

Merci de votre aide !

Salut,

Si minidom te convient pareil voici un exemple, je n'ai pas de fichier avec la balise <Page> mais j'en ai un très gros (112.000 lignes) avec des balises <trk>
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 # -*- coding: utf-8 -*- import xml.dom.minidom class HandleGPX(object): def __init__(self, f): self.dom = xml.dom.minidom.parse(f) def read_gpx(self): trks = self.dom.getElementsByTagName("trk") print "Found {0} tracks".format(len(trks)) hgpx = HandleGPX("/home/vincent/devel/GPS/GPSout.gpx") hgpx.read_gpx()
Il a mis une douzaine de secondes quand même, peut-être que sax est plus rapide.

03/02/2012, 16h59
funmatica

Bonjour
Merci VinsS pour ta réponse.
J'ai déjà fait un code avec minidom, mais il ne marche pas sur mon document xml.
Je préfère le faire en sax puisqu'il ne met pas tout le document en mémoire.
Merci

Salut,
Votre code est un peu "brouillon" mais "fonctionne" modulo le fait que la méthode "startElement" étant appelée chaque fois qu'un élément est "rencontré", si vous voulez "comptez" les "tags" page, il faut être un peu plus explicite:

Code:

1
2
3
4
    def startElement(self, name, attrs):
        print "Start element:", name
        if name == 'page':                     #<---
            self.n += 1

Sinon, j'écrirais le tout ainsi:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from xml.sax import make_parser, handler
class TagCounter(handler.ContentHandler):
 
    def __init__(self, *tags):
         self._counters = { tag:0 for tag in tags }
         handler.ContentHandler.__init__(self)
 
    def startElement(self, tag, attrs):
        if tag in self._counters:
             self._counters[tag] += 1
 
    def endDocument(self):
         print 'end document'
         print self._counters

=> TagCounter accepte une liste de "tags" à compter.

Une des difficultés étant "les tests", je vous suggère d'utiliser StringIO (ou encore io). Cela permet de faire des "reproducteurs" faciles à copier/coller/poster...
Genre:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
if __name__ == '__main__':
     import StringIO as io
     XML = """
     <a>
        <bb>
        </bb>
        <bb>
          <c>
            <d>
            </d>
          </c>
        </bb>
     </a>"""         
     xmlfile = io.StringIO(XML)          
     parser = make_parser()
     parser.setContentHandler(TagCounter('bb', 'c'))
     parser.parse(xmlfile)

Il n'est pas nécessaire de passer par SAX pour faire cela. La bibliothèque xml.etree.ElementTree "vient" avec un parser qui peut être nourrit ("feed") au fil de l'eau et attaquer une classe de handling des "events" similaire.
Comme on jette tout, çà ne pose pas de soucis (côté utilisation mémoire).

Le code ressemble à:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import xml.etree.ElementTree as et
 
class TagCounter:                     
     def __init__(self, *tags):
         self._counters = { tag:0 for tag in tags }
 
      def end(self, tag):
          pass
 
     def data(self, tag):
          pass
 
     def start(self, tag, attrib):
         if tag in self._counters:
             self._counters[tag] += 1
 
     def close(self):
         print (self._counters)

Pour le tester,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
if __name__ == '__main__':
     import StringIO as io
     XML = """<a>
        <bb>
        </bb>
        <bb>
          <c>
            <d>
            </d>
          </c>
        </bb>
     </a>"""         
     xmlfile = io.StringIO(XML)          
     counters = TagCounter('bb', 'c')
     parser = et.XMLParser(target=counters)
     for line in xmlfile.readlines():
          print 'line', line
          parser.feed(line)
     parser.close()

nota, la chose suivante ne sert qu'à montrer "au fil de l'eau" mais n'a pas grande utilité.

Code:

1
2
3
     for line in xmlfile.readlines():
          print 'line', line
          parser.feed(line)

- W

04/02/2012, 21h10
afranck64

J'aurais une question. Vu qu'il s'agit uniquement de compter Une regexp ne ferais pas l'affaire? Ou c'est plus lent? :roll:
05/02/2012, 13h41
wiztricks

Salut,

Citation:

Envoyé par afranck64

J'aurais une question. Vu qu'il s'agit uniquement de compter Une regexp ne ferais pas l'affaire? Ou c'est plus lent? :roll:

Utiliser 'grep' serait encore plus simple et rapide!
- W
06/02/2012, 15h08
funmatica

Bonjour à tous et merci à tous pour votre aide

@wiztricks :
J'ai essayé ton test, justement je cherchai un moyen, mais, quand j'applique le test j'ai une note sur le shell qui dit "TypeError: __init__() takes exactly 1 argument (3 given)"

Merci
06/02/2012, 16h18
wiztricks

Salut,

Citation:

Envoyé par funmatica

@wiztricks :
J'ai essayé ton test, justement je cherchai un moyen, mais, quand j'applique le test j'ai une note sur le shell qui dit "TypeError: __init__() takes exactly 1 argument (3 given)"

Sans le code, je ne puis que compatir.
- W
07/02/2012, 15h28
funmatica

Bonjour,

Voici le code jusqu'à présent, j'ai du mal à l'adapter !

#!/usr/bin/python
#-*- coding:utf-8 -*-

import string
import sys

from xml.sax import ContentHandler,make_parser

class MaClasseContentHandler(ContentHandler):
def startElement(self, name, attrs):
print "Start element:", name
if name == "Page":
self.n += 1

class MaClassePage(ContentHandler):
def __init__(self):
ContentHandler.__init__(self)
self.n = 0

def startElement(self, name, attrs):
self.n += 1

handler = MaClassePage()
parser = make_parser()
parser.setContentHandler(handler)
parser.parse("monfic.xml")

print handler.n

# TEST

if __name__ == '__main__':
import StringIO as io
XML = """
<a>
<bb>
</bb>
<bb>
<c>
<d>
</d>
</c>
</bb>
</a>"""
xmlfile = io.StringIO(XML)
parser = make_parser()
parser.setContentHandler(handler('bb', 'c'))
parser.parse(xmlfile)

Merci d'avance pour votre aide !

En plus joli :mrgreen:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#!/usr/bin/python
#-*- coding:utf-8 -*-
 
import string
import sys
 
from xml.sax import ContentHandler,make_parser
 
 
class MaClasseContentHandler(ContentHandler):
    def startElement(self, name, attrs):
        print "Start element:", name
        if name == "Page":
            self.n += 1
 
class MaClassePage(ContentHandler):
    def __init__(self):
        ContentHandler.__init__(self)
        self.n = 0
 
    def startElement(self, name, attrs):
        self.n += 1
 
 
handler = MaClassePage()
parser = make_parser()
parser.setContentHandler(handler)
parser.parse("monfic.xml")
 
print handler.n
 
# TEST
 
if __name__ == '__main__':
    import StringIO as io
    XML = """
    <a>
        <bb>
        </bb>
        <bb>
            <c>
                <d>
                </d>
            </c>
        </bb>
    </a>"""
    xmlfile = io.StringIO(XML)
    parser = make_parser()
    parser.setContentHandler(handler('bb', 'c'))
    parser.parse(xmlfile)

Avec le regex-finder:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import re
 
XML = """
    <a>
        <bb>
        </bb>
        <bb>
            <c>
                <d>
                </d>
            </c>
        </bb>
    </a>"""*16384
 
def count_pattern(pattern="<bb>", filename=None, file=None, text=None):
    if file:
        return len(re.count_parttern(pattern, file.read()))
    elif filename:
        return len(re.findall(pattern, open(filename).read()))
    elif text:
        return len(re.findall(pattern, text))
    else:
        return -1
 
if __name__ == "__main__":
    print (count_pattern("<bb>", text=XML))

Salut afranck64,

Si on fait du SAX, c'est pour éviter de lire tout le fichier d'un coup!
Donc, certes, il est "possible" d'écrire cela avec des regexp mais pour envoyer à la regexp les caractères un par un, il faut plus de code que le "toy" proposé.

Avec le parser.feed, çà supporte:
Code:

1 2 3 4 5 6 parser = et.XMLParser(target=counters) for line in xmlfile.readlines(): print 'line', line for c in line: parser.feed(c) parser.close()
@funmatica
Plusieurs choses.
Pourquoi définir:

class MaClasseContentHandler(ContentHandler) qui a une méthode qui filtre les name == "Page" et
class MaClassePage(ContentHandler) qui compte les appels à la méthode startElement

Essayez d'être cohérent, çà évitera des maux de têtes!

l'appel a handler('bb', 'c') se vautre car après l'initialisation de handler = MaClassePage()... handler n'est plus un "callable" sauf à définir la méthode __call__ mais ce n'est pas ce qu'on veut. Inutile de s'égarer.

Cela corrigé (écrire: handler = MaClassePage plutôt que MaClassePage()) on tombe dans la méthode __init__ n'admettant pour paramètre que (self) et non les 'bb', 'c' qu'on lui propose.

Hmm reprenons le b.a.ba du cut & paste!

Le TagCounter:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 from xml.sax import handler,make_parser class TagCounter(handler.ContentHandler): def __init__(self, *tags): self._counters = { tag:0 for tag in tags } handler.ContentHandler.__init__(self) def startElement(self, tag, attrs): if tag in self._counters: self._counters[tag] += 1 def endDocument(self): print 'end document' print self._counter
On le teste, il marche (ou pas) et on ferme.

Mais on le "spécialise" pour compter les tags "Page", genre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 class CountPage(TagCounter): def __init__(self): TagCounter.__init__(self, 'Page') class Countbb(TagCounter): # pas envie de re-ecrire les data de tests! def __init__(self): TagCounter.__init__(self, 'bb') if __name__ == '__main__': import StringIO as io XML = "<a><bb></bb><bb><c><d></d></c></bb></a>" xmlfile = io.StringIO(XML) parser = make_parser() parser.setContentHandler(Countbb()) parser.parse(xmlfile)
- W