Discussion :

[____22]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
j={"id":"1","children":[{"id":"2","children": [{"id":"3","name":"3"}],"name":"2"},{"id":"4","name":"4"}],"name":"1"} 
 
def searchDict(obj, id):
    if obj['id']==id:
        print obj #{"id":"3","name":"3"}
        return obj.copy()
    else:
        if 'children' in obj:
            for child in obj['children']:
                searchDict(child, id)
 
jj = searchDict(j, "3")
print jj #  ----> None ?

bonjour comment recupérer {"id":"3","name":"3"} svp?

[fred1599]

Quand je vois un dico comme ça, je prend mon code, je le jette et je revois l'implémentation de mon algo

[____22]

Quand je vois un dico comme ça, je prend mon code, je le jette et je revois l'implémentation de mon algo

t'as raison c'est l'algo qui est mauvais

en fait j'aimerais un algo qui est capable de fusionner

par exemple

à

j={"id":"1","children":[{"id":"2","children": [{"id":"3","name":"3"}],"name":"2"},{"id":"4","name":"4"}],"name":"1"}

capable d'ajouter au bon endroit

{"id":"3","children": [{"id":"7","name":"7"}],"name":"3"}

je sais pas trop comment faire parceque j'aimerais parcourir le premier Dict, mais si la méthode est récursive je vais perdre la référence au Dict initial, et je vais ajouter mon second Dict à un autre Dict sans avoir modifier l'initial
je sais pas si c'est très clair

[fred1599]

Donne nous plutôt ce que tu as en entrée (par exemple une chaine, un nombre, etc...) et ce que tu veux en sortie.

Parce-que arriver à ce genre de résultat ci-dessous, c'est affreusement moche, à moins de ne pas avoir le choix

{"id":"3","children": [{"id":"7","name":"7"}],"name":"3"}

C'est toujours aussi affreux

[____22]

ok plus simplement, j'ai des Dict en forme d'arbre

root={"id":"1","children":[{"id":"2","children": [{"id":"3"}]},{"id":"4"}]}

temp = {"id":"3","children": [{"id":"12"}]}

je voudrais pouvoir faire

add(root,temp)

root -> {"id":"1","children":[{"id":"2","children": [{"id":"3","children": [{"id":"12"}]}]},{"id":"4"}]}

etc ..
add(root, {"id":"3","children": [{"id":"22"},{"id":"23"}]}
root -> {"id":"1","children":[{"id":"2","children": [{"id":"3","children": [{"id":"12"},{"id":"22"},{"id":"23"}]}]},{"id":"4"}]}

[____22]

ou plutot non

j'aimerais en fait pouvoir afficher

Code :

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

1
2
3
4
5
6
7
class Node:
    def __init__(self, name, parent=None, size=0 ):
        self.id = name
        self.size = size
        self.total_size = size
        self.parent = parent
        self.children = []

sur le format json précedent

j'ai un root = Node('1')
qui possède en children des Node('2', root) et Node('4', root)
et Node('2', root) a dans son children Node('3', ...)

comment ecrire une méthode printNode dans Node

pour avoir root.printNode() donnant

Code :

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

{"id":"1","children":[{"id":"2","children": [{"id":"3"}]},{"id":"4"}]}

[____22]

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
20
21
22
23
24
class Node:
    def __init__(self, name, parent=None, size=0 ):
        self.id = name
        self.size = size
        self.total_size = size
        self.parent = parent
        self.children = []
 
 
    def toDict(self):
        ret = {'id':self.id, 'children':[]}
        for child in self.children:
            ret['children'].append(child.toDict())
        return ret
 
root = Node('1')
node2=Node('2', root)
node4=Node('4', root)
root.children.append(node2)
root.children.append( node4)
node3 = Node('3', node2)
node2.children.append( node3)
 
print root.toDict()

[wiztricks]

Salut,

Pour votre propos regardez la construction de la méthode .dumps ci dessous.

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
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
class Tree(object):
 
    def __init__(self, parent=None):
        self._children = []
        if parent is None:
            self._root = self
            self._parent = None
        else:
            self._root = parent._root
            parent.insert(self)
 
    @property
    def is_root(self):
        return self._parent is None
 
    def insert(self, item):
        assert item._root is self._root, ''
        item._parent = self
        self._children.append(item)
 
    @staticmethod
    def move(item, to):
        assert not item.is_root, "can't detach root"
        item._parent._children.remove(item)
        to.insert(item)
 
class MyTree(Tree):
    def __init__(self, ident, parent=None):
        super(MyTree, self).__init__(parent)
        self._ident = ident
 
    def dumps(self):
        s = '{ "id":%s ' % self._ident
        if len(self._children):
            s += 'children: [ %s ]' % ', '.join([item.dumps() for item in self._children ])
        return s + '}'
 
CTree = MyTree
root = CTree(0)
n1 = CTree(1, parent=root)
n2 = CTree(2, parent=root)
n3 = CTree(3, parent=n2)
print root.dumps()
##---
CTree.move(n3, n1)
print root.dumps()

C'est juste pour dire qu'un arbre est plus qu'une collection de nœuds.
- W

[____22]

c'est pas mal merci
normalement ça donne pareil que si moi je fais

Code :

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

json.dumps(root.toDict())

[wiztricks]

Salut,

Maintenant qu'on a un "Tree", on peut remplacer "object" par dict...
Et ajouter au dict le nécessaire pour qu'il soit "tree".
Bon courage

-W

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
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
class TreeAsDict(dict):
 
    def __init__(self, parent=None):
        super(TreeAsDict, self).__init__()
        if parent is None:
            self._root = self
            self._parent = None
        else:
            self._root = parent._root
            parent.insert(self)
 
    @property
    def is_root(self):
        return self._parent is None
 
    def insert(self, item):
        assert item._root is self._root, ''
        item._parent = self
        if 'children' not in self:
            self['children'] = []
        self['children'].append(item)
 
    @staticmethod
    def move(item, to):
        assert not item.is_root, "can't detach root"
        item._parent['children'].remove(item)
        if len(item._parent['children']) == 0:
            del item._parent['children']
        to.insert(item)
 
class MyTree(TreeAsDict):
    def __init__(self, ident, parent=None):
        super(MyTree, self).__init__(parent)
        self['ident'] = ident
 
 
CTree = MyTree
root = CTree(0)
n1 = CTree(1, parent=root)
n2 = CTree(2, parent=root)
n3 = CTree(3, parent=n2)
print root
##---
CTree.move(n3, n1)
print root

[____22]

j'aurais pas nommé la classe Tree ou treeAsDict puisque c'est des nodes du tree

[wiztricks]

Salut,

j'aurais pas nommé la classe Tree ou treeAsDict puisque c'est des nodes du tree

Ce n'est pas pour rien qu'il y a une classe Tree qui s'occupe de la structure et une sous-classe MyTree qui définit le contenu des "nodes".
Cette dernière pourrait être nommée "node".

- W