Méthode efficace pour parcourir les éléments xml

j'ai un xml comme ceci:

<a>
    <b>hello</b>
    <b>world</b>
</a>
<x>
    <y></y>
</x>
<a>
    <b>first</b>
    <b>second</b>
    <b>third</b>
</a>

J'ai besoin de parcourir tous les <a> et <b> des balises, mais je ne sais pas combien d'entre eux sont dans le document. J'ai donc utiliser xpath de poignée:

from lxml import etree

doc = etree.fromstring(xml)

atags = doc.xpath('//a')
for a in atags:
    btags = a.xpath('b')
    for b in btags:
            print b

Il fonctionne, mais j'ai assez de gros fichiers, et cProfile me montre que xpath est très coûteux à utiliser.

Je me demande, peut-être n'est-il plus efficace de chemin à parcourir indéfiniment nombre de xml-éléments?

source d'informationauteur nukl

  1. 19

    XPath devrait être rapide. Vous pouvez réduire le nombre de XPath appels à:

    doc = etree.fromstring(xml)
btags = doc.xpath('//a/b')
for b in btags:
    print b.text

    Si ce n'est pas assez rapide, vous pouvez essayer de Liza Daly fast_iter. Ceci a l'avantage de ne pas exiger que l'ensemble de XML être traitées avec etree.fromstring premier, et les nœuds parents sont jetés après que les enfants ont été visités. Les deux de ces choses aident à réduire les besoins en mémoire. Ci-dessous est une version modifiée de fast_iter qui est plus agressif sur la suppression d'autres éléments qui ne sont plus nécessaires.

    def fast_iter(context, func, *args, **kwargs):
    """
    fast_iter is useful if you need to free memory while iterating through a
    very large XML file.

    http://lxml.de/parsing.html#modifying-the-tree
    Based on Liza Daly's fast_iter
    http://www.ibm.com/developerworks/xml/library/x-hiperfparse/
    See also http://effbot.org/zone/element-iterparse.htm
    """
    for event, elem in context:
        func(elem, *args, **kwargs)
        # It's safe to call clear() here because no descendants will be
        # accessed
        elem.clear()
        # Also eliminate now-empty references from the root node to elem
        for ancestor in elem.xpath('ancestor-or-self::*'):
            while ancestor.getprevious() is not None:
                del ancestor.getparent()[0]
    del context

def process_element(elt):
    print(elt.text)

context=etree.iterparse(io.BytesIO(xml), events=('end',), tag='b')
fast_iter(context, process_element)

    Liza Daly article sur l'analyse des fichiers XML peuvent être utiles à la lecture à vous aussi. Selon l'article, lxml avec fast_iter peut être plus rapide que cElementTree's iterparse. (Voir Le Tableau 1).

  2. 10

    Comment sur iter?

    >>> for tags in root.iter('b'):         # root is the ElementTree object
...     print tags.tag, tags.text
... 
b hello
b world
b first
b second
b third
  3. 5

    Utilisation iterparse:

       import lxml.etree as ET
   for event, elem in ET.iterparse(filelike_object):
        if elem.tag == "a":
            process_a(elem)
            for child in elem:
                process_child(child)
            elem.clear() # destroy all child elements
        elif elem.tag != "b":
            elem.clear()

    Noter que ce n'est pas de sauver la mémoire, mais j'ai été capable de passer à travers des flux XML de plus d'un Go à l'aide de cette technique.

    Essayer import xml.etree.cElementTree as ET ... il est livré avec Python et de ses iterparse est plus rapide que la lxml.etree iterparseselon le lxml docs:

    """Pour les applications qui nécessitent une haute analyseur de débit de gros fichiers, et qui ne sont peu ou pas de sérialisation, hec est le meilleur choix. Aussi pour iterparse applications extraire de petites quantités de données ou des données agrégées à partir de grands ensembles de données XML qui ne rentre pas dans la mémoire. Si il s'agit de performances aller-retour, cependant, lxml a tendance à être plusieurs fois plus rapide au total. Donc, chaque fois que les documents d'entrée ne sont pas beaucoup plus grande que la sortie, lxml est le gagnant clair."""

  4. -2

    bs4 est très utile pour ce

    from bs4 import BeautifulSoup
raw_xml = open(source_file, 'r')
soup = BeautifulSoup(raw_xml)
soup.find_all('tags')