Discussion :

[etienne.clopeau]

Bonjour,

est-il possible de créer des connexion entre objets?
en gros je veux pourvoir accéder à obj2 à partir de obj1.
et jeux veux pouvoir faire la même chose dans le sens inverse. Accéder à obj1 à partir de obj2

de plus, je voudrais que les connexion soient multiples.

___ obj1 __ obj4
/ | \ |
obj2 obj5 obj3

donc, obj3 doit pouvoir avoir accès à obj1 et obj4
obj1 doit pouvoir avoir acces a obj2 obj5 et obj3...

cela ressemble a une base de données, j'en suis bien conscient, mais j'aimerais que tout se face en mémoir. Pas de fichier...

Je suis pas sur d'avoir été bien clair.
Quelqu'un m'aurait-il compris et aurait-il un idée?

Merci d'avance.

[eyquem]

Bonjour,


Que veut dire “avoir accès“ ?

[etienne.clopeau]

Par avoir accès, j'enttend pouvoir faire ce genre de chose:
si obj1 est connécté à obj2 et obj3
commande envoyé
obj1.connecté[0] --> obj2
obj1.connecté[1] --> obj3
obj1.connecté --> [obj2,obj3]
obj3.connecté --> [obj1]

Ca te parle plus?

[wiztricks]

Bonsoir,

Python, c'est comme à la SNCF, tout est possible.
Par contre, il va falloir que vous réfléchissiez beaucoup avant de coder.

Le premier boulot est d'arrêter les connections que vous voulez réaliser entre vos objets.
Prenez les relations classiques, vous avez One2Many (1-*), Many2Many(*-*), One2One(1-1).

Ensuite il va falloir définir la navigation.
i.e. Si l'objet1 est relié One2Many avec des objets2
Est ce que vous voulez atteindre tous les objets2 à partir d'objet1.
Est ce qu'à partir d'un objet2, vous voulez remonter à objet1?
La navigation suppose l'utilisation de collections (list ou dict) dans lesquels répertorier les objets correspondants.

La grosse difficulté est que la structure générale de cela est un graphe.
Si vous n'êtes pas à l'aise avec ce type d'objets, commencez par des arbres.

Ce sont des structures hiérarchiques que vous trouvez partout: relation père-fils, répertoires et fichiers d'un système de fichiers.

Bon courage,
- W

[vincent.mbg]

Bonjour,

Voici un exemple avec des mêmes objets qui font référence entre eux.

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
 
# -*- coding: utf-8 -*-
class A( object ) : 
        def __init__( self, nom ) :
                self.nom  = nom
                self.a_cnt = []
 
        def connect( self, a ):
                self.a_cnt.append( a ) # Je me connect à a.
                a.a_cnt.append( self ) # a se connect à moi.
 
        def get_connect( self ) :
                return self.a_cnt
 
obj1 = A("obj 1")
obj2 = A("obj 2")
obj3 = A("obj 3")
 
obj1.connect( obj2 )
obj1.connect( obj3 )
 
print obj1.get_connect()
print obj2.get_connect()

Un problème qui peut se poser lors de référencements symétriques c'est si j'écris la méthode connect() comme ceci :

Code :

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

1
2
3
4
 
    def connect( self, a ):
        self.a_cnt.append( a ) # Je me connect à a.
        a.connect( self ) # création d'un appel sans fin.

Il suffit juste de tester si l'objet est déjà connecté.

Code :

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

1
2
3
4
5
 
        def connect( self, a ):
                if a not in self.a_cnt :
                        self.a_cnt.append( a ) # Je me connect à a.
                        a.connect( self ) # a se connect à moi.

[wiztricks]

Pour moi, un graphe n'est pas une base de donnée.
Exemple similaire à celui de vincent.mbg.

J'utilise un dict comme collection.
Et j'ai pris la peine d'orienter le graphe, pour que la traversée "a -> b -> c" ne boucle pas.

La fonction "traverse" parcours les liens issus du noeud donné en pré-ordre.
- W

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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
class Gnode(object):
    def __init__(self):
        self._linksTo = dict()
        self._linksFrom = dict()
 
    def addLinkTo(self, gnode):
        self._linksTo[id(gnode)] = gnode
        gnode.addLinkFrom(self)
 
    def addLinkFrom(self, gnode):
        self._linksFrom[id(gnode)] = gnode
 
 
class Test(Gnode):
 
    def __init__(self, name):
        Gnode.__init__(self)
        self.name = name
 
    def __str__(self):
        return self.name
 
def traverse(g):
    print g
    for x in g._linksTo.itervalues():
        traverse(x)
 
a = Test("a")
b = Test("b")
c = Test("c")
a.addLinkTo(b)
b.addLinkTo(c)
traverse(a)

[etienne.clopeau]

Merci pour vos réponses.

J'ai cependant fait une bétise en voulant simplifier le problème qui n'est plus tout à fait le même.

donc je vous transmet mon code qui pose problème:

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
class VALS():
    """
    table de valeur
    """
    def __init__(self, vals):
        self.vals = vals
 
 
class VAR():
    """
    Classe variable, mermettant de stocker 
    l'origine, le nom et l'unité de la variable
    """
    def __init__(self, name, unit='', comment=''):
        self.name = name
        self.unit = unit
        self.comment = comment
        self.connected_zones = dict()  #dictionnaire liant les zones avec les vals
 
    def __str__(self):
        return u' Nom de la variable: '+ self.name + '\n' + \
               u'| Unitée            : '+ self.unit + '\n' + \
               u'| Commentaire       : '+ self.comment + '\n' #+ \
 
 
 
class ZONE ():
    """
    Classe zone liée à plusieurs variables
    """
    def __init__(self, name, comment = None):
        self.name = name
        self.comment = comment
        self.connected_vars = dict()
 
    def __str__(self):
        return self.name
 
class DATASET():
    """
    la Classe dataset permet de gérer des zones
    recherche de variables...
    """
 
    def __init__(self):
        """
        création d'un tableau de zones
        """
        self.vals_db=[]
        self.zones=[]
        self.vars=[]
 
 
    def add_zone(self, zone):
        if self.search_zone(zone):
#            print u'cette zone existe déjà. !!!!'
            #print self.search_zone(zone):
        else:
            self.zones.append(zone)
        return self.zones[-1]
 
    def add_var(self, var):
        if self.search_var(var):
#            print u'cette variable existe déjà. !!!!'
            #print self.search_zone(zone):
        else:
            self.vars.append(var)
        return self.vars[-1]
 
    def add_vals(self, vals, zone, var):
#        print u"début add_vals"
        zone = self.add_zone(zone)
        var = self.add_var(var)
 
        self.vals_db.append(vals)
        if var not in zone.connected_vars:
            zone.connected_vars[var]=vals
        else:
            print u'un tableau de valeur est déjà associé à cette zone et cette variable'
            print u"écrasement de l'ancien tableau"
        if zone not in var.connected_zones:
            var.connected_zones[zone]=vals
        else:
            print u"une erreur c'est produite"
 
    def search_zone(self,zone):
        for z in self.zones:
            if zone.name == z.name:
                #print 'cette zone existe '
                return z
        return None
 
    def search_var(self,var):
        for v in self.vars:
            if var.name == v.name:
                #print 'cette zone existe '
                return v
        return None
 
#       
D = DATASET()
Z1=ZONE("Z1")
Z2=ZONE("Z2")
V1=VAR("V1")
V2=VAR("V2")
V3=VAR("V3")
VALs_z1_v1=[1,2,3]
D.add_vals(VALs_z1_v1,Z1,V1)
print 'ok1'
VALs_z1_v2=[4,5,6]
D.add_vals(VALs_z1_v2,Z1,V2)
print 'ok2'
VALS_z2_v2=[1,2]
D.add_vals(VALS_z2_v2,Z2,V2)
print 'ok3'
VALS_z2_v3=[3,4]
D.add_vals(VALS_z2_v3,Z2,V3)
 
D.vars[0].connected_zones[Z1] #renvoie [1, 2, 3]
D.zones[0].connected_vars[V1] #même chose puisque même objet vals
 
D.zones[0].connected_vars[V1]=[1,2,3,4,5,6]
D.zones[0].connected_vars[V1] #renvoie [1,2,3,4,5,6]
D.vars[0].connected_zones[Z1] #renvoie [1, 2, 3]    !!!

normalement je voulait obtenir la même chose avec les deux dernière lignes de code : [1,2,3,4,5,6]...

Je ne comprend pas bien mon erreur.
Et peut être que je m'y prend mal...