Discussion :

[DonKnacki]

Bonjour

Comme souvent, je bute sur la création d'une fonction récursive

Mon but est de parser un fichier xml et d'enregistrer les informations contenu dans ce fichier tout en gardant la hiérarchie des "objets" du fichier XML

Pour mieux comprendre, prenons un exemple de XML

Code xml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<Structure>
    <Object>Objet 1</Object>
    <Children>
        <Structure>
            <Object>Objet 1.1</Object>
        </Structure>
        <Structure>
            <Object>Objet 1.2</Object>
            <Children>
                <Structure>
                     <Object>Objet 1.2.1</Object>
                 </Structure>
             </Children>
        </Structure>
    </Children>
</Structure>

Donc une structure à un objet parent qui peut avoir des enfants. Ces enfants peuvent eux même avoir des enfants
Mon but est donc de récupérer ces informations dans des objets python tout en conservant la hiérachie
J'ai donc pense avoir un dictionnaire avec pour clé le parent et pour valeur la liste des enfants (qui contiendra un dictionnaire si elle n'est pas vide)
Je suis libre de choisir la structure python pour cela donc n'hésitez pas à me proposer autre chose si besoin

Dans notre exemple, le résultat que j'ai imaginé sera le suivant :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

{ Objet 1 : [ {Objet 1.1 : [ ] ,  Objet 1.2 : [ { Objet 1.2.1 : [] } ] ] }

Pour ce faire, j'ai créé une fonction que voici :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def GetChildren(structure):   
        childList = []    
        objRef = ''
        for node in structure.childNodes:
            if node.nodeType == minidom.Node.ELEMENT_NODE and node.nodeName == "Object":
                objRef = node.childNodes[1].firstChild.data.encode("mbcs")
            elif node.nodeType == minidom.Node.ELEMENT_NODE and node.nodeName == "Children" :
                for child in node.childNodes:
                    if child.nodeType == minidom.Node.ELEMENT_NODE and child.nodeName ==  "Structure":                    
                        childList.append(child.childNodes[1].childNodes[1].firstChild.data.encode("mbcs"))
                        r = GetChildren(child)
        return {objRef : childList}
 
print GetChildren((structure)

Mon problème est le suivant ; je ne récupère que les fils directs de Objet 1 (donc Objet 1.1 et Objet 1.2) alors que je parcours ma fonction en pas à pas, je vois bien que dans childList, la valeur Objet 1.2.1 est présente mais je la perd tout à la fin

Ca doit être une petite bêtise mais je vois pas ou

[wiztricks]

Salut,

Si le sujet est de parcourir une hiérarchie d'éléments XML, pourquoi ne pas essayer de comprendre avec une structure beaucoup plus simple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
XML = '''<document>
<object ident="objet 1">
    <object ident="objet 1.1"/>
    <object ident="objet 1.2">
        <object ident="objet 1.2.1"/>
    </object>
</object>
</document>
'''
 
from xml.etree import ElementTree as ET
 
def show_objects(node, level=0):
    for e in node.findall('./object'):
        print ('*' * (4*level), e.attrib['ident'])
        show_objects(e, level=level+1)
 
tree = ET.fromstring(XML)
show_objects(tree)

Pour ce qui est de reconstruire cette structure dans des dicts emboîtés, c'est une variation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
def map_objects(node, level=0):
    map = {}
    for e in node.findall('./object'):
        print ('*' * (4*level), e.attrib['ident'])
        children = map_objects(e, level=level+1)
        ident = e.attrib['ident']
        map[ident] = children
    return map    
 
print (map_objects(tree))

- W

[DonKnacki]

Salut,

Si le sujet est de parcourir une hiérarchie d'éléments XML, pourquoi ne pas essayer de comprendre avec une structure beaucoup plus simple:

Bonjour et merci pour ta réponse et ton aide

J'utilise cette structure complexe de XML tout simplement parce qu'elle m'est imposée
De plus, j'aimerai continuer à utilise minidom par souci d'harmonisation avec le reste du code.

Cela ne m'a pas empêché de m'inspirer de ton code pour améliorer le mien et j'y suis presque :

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
def GetChildren(structure):   
        map = {} 
        objRef = ''
        for node in structure.childNodes:
            if node.nodeType == minidom.Node.ELEMENT_NODE and node.nodeName == "Objet":
                objRef = node.childNodes[1].firstChild.data.encode("mbcs")
            elif node.nodeType == minidom.Node.ELEMENT_NODE and node.nodeName == "CHILDREN":
                for child in node.childNodes:
                    if child.nodeType == minidom.Node.ELEMENT_NODE and child.nodeName == "Structure":                        
                        #childList.append(child.childNodes[1].childNodes[1].firstChild.data.encode("mbcs"))
                        children = GetChildren(child)
                        map[child.childNodes[1].childNodes[1].firstChild.data.encode("mbcs")] = children
        return map

Le seul problème est que je n'ai pas les premiers Objets (dans l'exemple Objet 1) . Ca me parait logique puisqu'on ajoute pas ObjRef dans le dictionnaire la première fois mais je ne vois pas comment faire

[wiztricks]

Salut,

J'utilise cette structure complexe de XML tout simplement parce qu'elle m'est imposée
De plus, j'aimerai continuer à utilise minidom par souci d'harmonisation avec le reste du code.

Je me contente de prendre le temps de mettre le projecteur sur vos incompréhensions.
Pour le reste, je pense que vous êtes assez grand pour adapter (pour peu que mes explications soient claires).

Le seul problème est que je n'ai pas les premiers Objets (dans l'exemple Objet 1) . Ca me parait logique puisqu'on ajoute pas ObjRef dans le dictionnaire la première fois mais je ne vois pas comment faire

Mon code fonctionne parce que l'arbre est écrit comme çà:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
XML = '''<document>
<object ident="objet 1">
    <object ident="objet 1.1"/>
    <object ident="objet 1.2">
        <object ident="objet 1.2.1"/>
    </object>
</object>
</document>
'''

Autrement dit le premier élément n'est pas un nœud.
Votre arbre est plutôt écrit comme çà:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
XML = '''<object ident="objet 1">
    <object ident="objet 1.1"/>
    <object ident="objet 1.2">
        <object ident="objet 1.2.1"/>
    </object>
</object>'''

Côté code le for e in node "plongeant" direct dans le s/arbre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def show_objects(node, level=0):
    for e in node.findall('./object'):
        print ('*' * (4*level), e.attrib['ident'])
        show_objects(e, level=level+1)

saute le premier nœud.

Dans ce cas, il faut effectuer les traitements "avant":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def show_objects(node, level=0):
    print ('*' * (4*level), node.attrib['ident'])
    for e in node.findall('./object'):
        show_objects(e, level=level+1)

Et vous voyez que c'est plus simple de "montrer" çà en quelques lignes bien choisies et vous laissez adapter votre code.
- W

[DonKnacki]

Merci pour votre aide et pour votre temps,
j'ai donc traiter le premier nœud avant et j’obtiens un résultat satisfaisant

Merci aussi pour les exemples de code qui m'ont faciliter la compréhension

[fatbob]

La récursivité (sujet intéressant et très puissant) est décrit dans les grandes largeurs ici :
http://recursivite.developpez.com/

[wiztricks]

La récursivité (sujet intéressant et très puissant) est décrit dans les grandes largeurs ici :
http://recursivite.developpez.com/

Super!
Dommage que les parcours d'arbres y soient absents et que les exemples soient écrit en une sorte de Pascal.
Je n'ai rien contre Pascal, c'est un langage fort vénérable.
Mais, pour le programmeur Python, c'est un peu comme le grec ou le latin: "désuet".
- W

[fatbob]

Certes.
D'un autre côté ce n'est pas bien compliqué à traduire :-) Ce qui compte, c'est de s'exercer aux principes. Une fois compris, j'imagine que le parcours d'arbre n'est pas sorcier.