Discussion :

[Snains]

Bonjour à tous !

Je suis actuellement en train d'adapter l'algorithme A* dans Blender afin de pouvoir tracer des câbles entre deux points de références. Je rencontre cependant un problème des plus étrange : certaines de mes variables influent les unes sur les autres alors qu'elles ne le devraient pas. Voici un petit exemple pour comprendre le problème :

Code :

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

1
2
3
4
5
6
7
a=0
b=0
b=b+1
print (a)
>>0
print (b)
>>1

Ca c'est ce que j'obtiens, le résultat est tout à fait normal. Or dans mon cas spécifique, c'est comme si j'obtenais quelque chose comme ça :

Code :

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

1
2
3
4
5
6
7
a=0
b=0
b=b+1
print (a)
>>1
print (b)
>>1

Comme si changer la valeur de "b" influe également sur celle de "a", ce qui me parait totalement illogique. J'espère que ce petit exemple est parlant. Voici donc la partie de mon code qui me pose ce problème spécifique.

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
 
n=0    
for each in cable :
    startNode = cable[n][0].location
    endNode= cable[n][1].location
    currentNode = startNode
 
    if (currentNode != endNode):
        newPositionList = [(0,1), (0,-1), (1,0), (-1,0), (1,1), (1,-1), (-1,-1), (-1,1)]
        costList = []
        distanceArriveeList = []
        distanceDepartList = []
        cpt = 0
        for each in newPositionList :
 
            print (cpt)
            newNode= currentNode
 
            newNode[0] = newNode[0] + newPositionList[cpt][0]
            newNode[1] = newNode[1] + newPositionList[cpt][1]
            print(newNode)
            print ('currentNodeAfter=', currentNode)
            print ('startNode=', startNode)
 
            distanceDepart = math.sqrt((startNode[0]-newNode[0])**2 + (startNode[1]-newNode[1])**2)
            distanceDepartList.append (distanceDepart)
 
            distanceArrivee = math.sqrt((endNode[0]-newNode[0])**2 + (endNode[1]-newNode[1])**2)
            distanceArriveeList.append (distanceArrivee)
 
            cost = distanceDepart + distanceArrivee
            costList.append(cost)
 
            cpt=cpt+1
n=n+1

Dans ce cas, j'ai newNode qui prend la valeur de currentNode, qui prend lui même la valeur de startNode à l'initialisation de la boucle du pathfinding ( if (currentNode != endNode). Or il se trouve qu'après les lignes 19 et 20, newNode a changé la valeur de currentNode, qui a lui même changé la valeur de startNode, alors que les relations entre ces variables se font dans l'autre sens...
Ca fausse évidemment totalement la boucle, puisque newNode n'est pas réinitialisé à chaque passage dans (for each in newPositionList).

Bref, je suis totalement désappointé (c'est assez illogique de mon point de vue puisque c'est censé fonctionner dans l'autre sens) et j'ignore parfaitement d'où le problème peut venir. Si vous avez besoin du code dans son intégralité pour mieux saisir le problème, n'hésitez pas.

Je vous remercie d'avance, et vous souhaite de bonnes fêtes
Cdlt, Léo

[lg_53]

Je n'ai pas du tous lu votre code mais vu les symptomes que vous décrivez je suis quasiment sûr de la source de votre problème qui réside en fait en une méconnaissance d'une notion importante en python : les variables mutables et non mutables.

Un entier est une variable non mutable. Donc lorsque vous faites :

Code :

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

1
2
3
4
5
6
7
a=0
b=a   ### notez ici la différence par rapport au code présenté au départ
b=b+1
print (a)
>>0
print (b)
>>1

vous obtenez bien le résultat attendu.

Maintenant regardez :

Code :

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

1
2
3
4
5
6
7
a=[0]
b=a   ### notez ici la différence par rapport au code présenté au départ
b[0]=b[0]+1
print (a)
>>[1]         ##### OH ?!
print (b)
>>[1]

Donc ici voyez que modifier b, modifie également a. Pourquoi ? Parce qu'une liste est mutable. Elle ne se comporte pas comme un simple entier donc. Ainsi lorsque vous écrivez b=a si a est un non mutable, ca se passe comme vous voulez et b est une nouvelle variable qui possède la même valeur que a. Si a est un mutable alors python est fainéant : les mutables sont des objets complexes et pour économiser, python ne créér pas une nouvelle variable ! Vous obtenez une sorte de lien qui pointe sur une zone mémoire de votre ordinateur qui est strictement la même que celle de a. Vous avez donc juste défini un alias, mais l'objet qui est derrière, que vous le manipuliez avec le nom a ou le nom b, c'est le même objet.

Pour s'en rendre compte, vous pouvez faire afficher quelle est l'emplacement mémoire utilisé pour stocker les variables :

Code :

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

1
2
print(id(a))
print(id(b))

Faites le dans les 2 cas (mutables et non mutables) et observer que dans un cas vous avez 2 emplacements mémoire différents (donc 2 variables distinctes) et dans l'autre c'est le même emplacement mémoire qui est utilisé (donc en réalité une seule et unique variable sous jacente).

Pour forcer python à ne pas faire le fainéant et à vraiment créer une nouvelle variable avec à l'intérieur une copie des éléments, on peut faire ainsi :

Code :

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

1
2
from copy import deepcopy
b=deepcopy(a)

[Snains]

Le problème venait de là !
Merci énormément lg_53 ! Ca fait un moment que je cassais les dents dessus ! Ca résout ce problème, et même d'autres que je pensais liés, mais pas aussi directement.

Encore merci !