Discussion :

[hyuga33]

Bonjour,
je débute en python et lors d'un projet je bute sur un problème. J'ai une fonction pick_and_drop qui prend un élément d'une liste pour le mettre dans une autre et retourne une nouvelle liste. Or si je fais:
new = pick_and_drop(c)
après l'appel ma liste new est égale à c.
Voila la fonction:

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
def pick_and_drop(c):
    c1,c2 = [],[]
    c1 = c[0]
    c2 = c[1]
    n = randrange(1,3)
    if (n == 1) and (len(c1)>int(nb_sommet/2)-p):
        a = choice(c1)
        c2.append(a)
        c1.remove(a)
    elif (n == 2) and (len(c2)>int(nb_sommet/2)-p):
        a = choice(c2)
        c1.append(a)
        c2.remove(a)
    else:
        if (len(c1)>int(nb_sommet/2)-p):
            a = choice(c1)
            c2.append(a)
            c1.remove(a)
        else:
            a = choice(c2)
            c1.append(a)
            c2.remove(a)
    c1.sort()
    c2.sort()
    return c1,c2

[VinsS]

Utilise les balises code, parce que c'est illisible comme cela.

Mais aussi :

Code :

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

1
2
 
if (n == 1) and (len(c1)>int(nb_sommet/2)-p):

D'où sort le p ? Tu devrais avoir une erreur pour variable référencée avant assignement.

Enfin, si je lis bien.

vincent

[hyuga33]

p est un entier défini globalement dans le main. Il dépent juste des données(du nombre de sommets du graphe considéré).

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
def pick_and_drop(c):
    c1,c2 = [],[]
    c1 = c[0]
    c2 = c[1]
    n = randrange(1,3)
    if (n == 1) and (len(c1)>int(nb_sommet/2)-p):
        a = choice(c1)
        c2.append(a)
        c1.remove(a)
    elif (n == 2) and (len(c2)>int(nb_sommet/2)-p):
        a = choice(c2)
        c1.append(a)
        c2.remove(a)
    else:
        if (len(c1)>int(nb_sommet/2)-p):
            a = choice(c1)
            c2.append(a)
            c1.remove(a)
        else:
            a = choice(c2)
            c1.append(a)
            c2.remove(a)
    c1.sort()
    c2.sort()
    return c1,c2

[eyquem]

Je te suggère de regarder le résultat du code suivant, qui te permettra de saisir ce qui se passe quand tu fais

Code :

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

1
2
3
    c1,c2 = [],[]
    c1 = c[0]
    c2 = c[1]

et de conclure que la ligne c1,c2 = [],[]
est inutile:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
def pick_and_drop(c):
    c1,c2 = [],[]
    print 'dedans id(c1) =',id(c1),' id(c2) =',id(c2)
    c1 = c[0]
    c2 = c[1]
    print 'dedans id(c1) =',id(c1),' id(c2) =',id(c2)
 
c = [78,67,456,27]
print 'avant id(c[0]) =',id(c[0]),' id(c[1]) =',id(c[1])
pick_and_drop(c)
print 'apres id(c[0]) =',id(c[0]),' id(c[1]) =',id(c[1])

J’ai testé sur un code modifié parce que je n’ai pas tes donnees de départ. Chez moi, ça marche:

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
from random import randint,choice
 
c = [[1,3,45,34,22,11,66,88],[76,90,100,50]]
print 'c =',c
def pick_and_drop(c):
    c1,c2 = [],[]
    c1 = c[0] # listea
    c2 = c[1] # listeb
    n = randint(1,2)
    print 'n =',n,
    if (n == 1) and len(c1)>len(c2):
        a = choice(c1)
        print ', a de c1 =',a
        c2.append(a)
        c1.remove(a)
    elif (n == 2) and len(c2)>len(c1):
        a = choice(c2)
        print ', a de c2 =',a
        c1.append(a)
        c2.remove(a)
    else:
        if len(c1)>len(c2):
            a = choice(c1)
            print ', a de c1 =',a
            c2.append(a)
            c1.remove(a)
        else:
            a = choice(c2)
            print ', a de c2 =',a
            c1.append(a)
            c2.remove(a)
            c1.sort()
            c2.sort()
    return c1,c2
 
 
new = pick_and_drop(c)
print 'new =',new

Code :

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

1
2
3
c = [[1, 3, 45, 34, 22, 11, 66, 88], [76, 90, 100, 50]]
n = 2 , a de c1 = 45
new = ([1, 3, 34, 22, 11, 66, 88], [76, 90, 100, 50, 45])

Quel est le problème ?

[eyquem]

Je crois que j'ai compris.

En écrivant
c1 = c[0]
c2 = c[1]
tu colles deux étiquettes c1 et c2 sur les éléments de c. Dès lors toute instruction qui implique c1 et c2 commande une action qui concerne en fait c[0] et c[1]. Il faut croire que ça rend c[0] et c[1] comme des variables globales pour la fonction. En tous cas, l’objet c qui est pourtant externe à la fonction est tout de même modifié par les instructions internes à la fonction.

En définitive return [c1,c2] renvoit une liste contenant les valeurs modifiées de c et cette liste va s’inscrire dans l’objet new qui sera distinct de l’objet c. Mais pendant que la fonction a tourné, l’objet c a lui même été modifié de façon identique à ce qui se retrouve dans new.

Au final, new et c sont deux listes distinctes = deux objets différents (new is c est False), mais d’un point de vue logique, new et c sont identiques (c==new est True).



C’est peut être parce que tu as examiné new et c avec une comparaison new==c que le résultat True te donne à croire que new n’est pas différente de la liste de départ.

Mais si tu regardes les valeiurs dans new, tu devrais voir qu’elles sont différentes de celles de c.

Ou alors c’est encore autre chose que je n’ai pas compris.

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
from random import randint,choice
 
def pick_and_drop(c):
    c1,c2 = [],[]
    c1 = c[0]
    c2 = c[1]
    n = randint(1,2)
    print 'n =',n,
    if (n == 1) and len(c1)>len(c2):
        a = choice(c1)
        print ', a de c1 =',a
        c2.append(a)
        c1.remove(a)
    elif (n == 2) and len(c2)>len(c1):
        a = choice(c2)
        print ', a de c2 =',a
        c1.append(a)
        c2.remove(a)
    else:
        if len(c1)>len(c2):
            a = choice(c1)
            print ', a de c1 =',a
            c2.append(a)
            c1.remove(a)
        else:
            a = choice(c2)
            print ', a de c2 =',a
            c1.append(a)
            c2.remove(a)
            c1.sort()
            c2.sort()
    return [c1,c2]
 
c = [[1,3,45,34,22,11,66,88],[76,90,100,50]]
print 'c =',c
print 'id(c)   =',id(c)
print
new = pick_and_drop(c)
print '\nc   =',c
print 'new =',new
print 'id(c)   =',id(c)
print 'id(new) =',id(new)
print 'c == new  est : ',c==new
print 'c is new  est :',c is new

Code :

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

1
2
3
4
5
6
7
8
9
10
11
c = [[1, 3, 45, 34, 22, 11, 66, 88], [76, 90, 100, 50]]
id(c)   = 17488592
 
n = 2 , a de c1 = 1
 
c   = [[3, 45, 34, 22, 11, 66, 88], [76, 90, 100, 50, 1]]
new = [[3, 45, 34, 22, 11, 66, 88], [76, 90, 100, 50, 1]]
id(c)   = 17488592
id(new) = 17474984
c == new  est :  True
c is new  est : False

La correction consiste à faire de c1 et c2 des références d’objets véritablement distinct de c[0] et c[1] tout en ayant leurs valeurs:

Code :

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

1
2
3
4
5
6
7
def pick_and_drop(c):
    c1,c2 = [],[]
    c1.extend(c[0])
    c2.extend(c[1])
    n = randint(1,2)
    print 'n =',n,
    etc....

De ce fait l’objet liste c initial n’est pas modifié:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
c = [[1, 3, 45, 34, 22, 11, 66, 88], [76, 90, 100, 50]]
id(c)   = 17369888
 
n = 1 , a de c1 = 66
 
c   = [[1, 3, 45, 34, 22, 11, 66, 88], [76, 90, 100, 50]]
new = [[1, 3, 45, 34, 22, 11, 88], [76, 90, 100, 50, 66]]
id(c)   = 17369888
id(new) = 17511208
c == new  est :  False
c is new  est : False

[hyuga33]

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# -*- coding: cp1252 -*-
# ==============================================================================
# METHODE RECUIT SIMULE
# ==============================================================================
"""ALGORITHME RECUIT SIMULE"""
__author__  = ""
__version__ = "1.0"
__date__    = " Avril 2010 "
__usage__   = " Mini-Projet."
# ------------------------------------------------------------------------------
from random import randrange, sample, choice, random, randint
from math import log, exp
# ------------------------------------------------------------------------------
def complementaire():
    """renvoie la classe complementaire de c1: c2"""
    c2 = []
    c1 = configinit()
    for i in range(1,nb_sommet+1):
        if not (i in c1):
             c2.append(i)
    c1.sort()
    c2.sort()
    return c1, c2   
# ------------------------------------------------------------------------------
def configinit():
    """construit la classe initiale c1"""
    nb2 = int(nb_sommet/2)
    c1 = []
    c1 = (sample(xrange(1,nb_sommet),nb2))
    return c1
# ------------------------------------------------------------------------------
def arete_inter(c):
    c1 = c[0]
    c2 = c[1]
    poids = 0
    for i in c1:
        for j in c2:
            if Adj[i-1][j-1] == 1:
                poids += 1
    return poids
# ------------------------------------------------------------------------------
def Temp_init(taux_acc):
    temp = range(100)
    for i in range(100):
        temp[i] = arete_inter(complementaire())
    temp.sort()
    somme = 0
    for i in range(20):
        somme += temp[-1-i]
    moy = somme/20
    t = moy/(log(1./taux_acc))
    return t
# ------------------------------------------------------------------------------
##def dec_temp(t,coef):
##    t = coef*t
##    return t
# ------------------------------------------------------------------------------
def pick_and_drop(c):
    c1,c2 = [],[]
    c1 = c[0]
    c2 = c[1]
    if (n == 1) and (len(c1)>int(nb_sommet/2)-p):
        a = choice(c1)
        c2.append(a)
        c1.remove(a)
    elif (n == 2) and (len(c2)>int(nb_sommet/2)-p):
        a = choice(c2)
        c1.append(a)
        c2.remove(a)
    else:
        if (len(c1)>int(nb_sommet/2)-p):
            a = choice(c1)
            c2.append(a)
            c1.remove(a)
        else:
            a = choice(c2)
            c1.append(a)
            c2.remove(a)
    c1.sort()
    c2.sort()
    return c1,c2
# ==============================================================================                   
def main():
    global nb_sommet, Adj, taux_acc, coef, p, gel, equil_stat
    fichier = raw_input ("Quel fichier souhaitez-vous utiliser?")
    f = open(fichier,"r")
    donnees = f.read()
    nb = donnees.split()
    nb_sommet = int(nb[0])
    nb_arete = int(nb[1])
    print "Le nombre de sommet est ",nb_sommet, "Le nombre d'arêtes est ",nb_arete
    liste1=[]
    liste2=[]
    p=int(nb_sommet*0.01)+1
    for i in range(int(nb_arete)):
        liste1.append(nb[2+3*i])
        liste2.append(nb[3+3*i])
    Adj = [[0 for j in range(int(nb_sommet))] for i in range(int(nb_sommet))]
    for i in range(nb_arete):
        Adj[int(liste1[i])-1][int(liste2[i])-1]=1
        Adj[int(liste2[i])-1][int(liste1[i])-1]=1
 
    c = complementaire()
    print "Les classes sont:", c
    print "Le poids des arêtes inter classes est : ",arete_inter(c)
 
    taux_acc = raw_input("Donnez la valeur du taux acceptation si vous souhaitez?(par défaut il vaut 0.6)")
    if taux_acc == '':
        taux_acc = 0.6
    else:
        taux_acc = float(taux_acc)
 
    coef = raw_input("Donnez la valeur du coefficient de décroissance de la température si vous souhaitez?(par défaut il vaut 0.9)")
    if coef == '':
        coef = 0.9
    else:
        coef = float(coef)
    ## print dec_temp(Temp_init(taux_acc),coef)
 
    equil_stat = nb_sommet
 
    gel = raw_input("Donnez la valeur pour laquelle on estime que le système est gelé?(par défaut elle vaut 60)")
    if gel == '':
        gel = 60
    else:
        gel = int(gel)
 
    courante = c
    solution = courante
    poids = arete_inter(c)
    t = Temp_init(taux_acc)
    Ncourante = pick_and_drop(courante)
    print "avant",(courante,Ncourante)
    while gel>0:
        k = 0
        while k<equil_stat:
            k += 1
            Ncourante = pick_and_drop(courante)
            delta = arete_inter(Ncourante) - arete_inter(courante)           
            if delta<0:
                courante = Ncourante
                print arete_inter(Ncourante),arete_inter(solution)
                if arete_inter(Ncourante)<arete_inter(solution):
                    poids = arete_inter(Ncourante)
                    solution = Ncourante
                    print "le poids est ici:", poids
            else:
                a = random()
                if a<=exp(-delta/t):
                    courante = Ncourante
        t = t*coef
        gel -= 1
        i += 1
        print "le gel est",gel
        print "delta",delta
 
    print "la meilleure solution trouvée est:  " ,solution
    print "Le poids est: " ,poids
    print "Le nombre d'itération est: " ,i
 
if __name__ == "__main__":
    main()
 
# ============================================================================

voila mon code en entier. le probleme c'est que mon delta est toujours nul donc je pense que Ncourante est égale à courante alors que l'on est passé par la fonction pick_and_drop.
J'arrive pa à voir le problème.

[hyuga33]

J'ai essayé tes codes et ça marche mais le problème n'est pas résolue car avec ce code:

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
from random import randint,choice
 
c = [[1,3,45,34,22,11,66,88],[76,90,100,50]]
print 'c =',c
def pick_and_drop(c):
    c1,c2 = [],[]
    c1 = c[0] # listea
    c2 = c[1] # listeb
    n = randint(1,2)
    print 'n =',n,
    if (n == 1) and len(c1)>len(c2):
        a = choice(c1)
        print ', a de c1 =',a
        c2.append(a)
        c1.remove(a)
    elif (n == 2) and len(c2)>len(c1):
        a = choice(c2)
        print ', a de c2 =',a
        c1.append(a)
        c2.remove(a)
    else:
        if len(c1)>len(c2):
            a = choice(c1)
            print ', a de c1 =',a
            c2.append(a)
            c1.remove(a)
        else:
            a = choice(c2)
            print ', a de c2 =',a
            c1.append(a)
            c2.remove(a)
            c1.sort()
            c2.sort()
    return c1,c2
 
 
new = pick_and_drop(c)
print 'new =',new
print 'c =',c

Ici, c=new or ça ne devrais pas donc je reste perplexe

[hyuga33]

Apparement ça marche si je rajoute deux boucle pour construire une nouvelle liste mais j'augmente la compléxité..

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
from random import randint,choice
 
c = [[1,3,45,34,22,11,66,88],[76,90,100,50]]
print 'c =',c
def pick_and_drop(c):
    d1,d2 = [],[]
    c1,c2 = [],[]
    c1,c2 = c[0],c[1]
    print c1
    for i in range(len(c[0])):
        d1.append(c1[i])
    for i in range(len(c[1])):
        d2.append(c2[i])
 
    print 'dedans id(d1) =',id(d1),' id(d2) =',id(d2)
    n = randint(1,2)
    if (n == 1) and len(d1)>len(d2):
        a = choice(d1)
        print ', a de d1 =',a
        d2.append(a)
        d1.remove(a)
    elif (n == 2) and len(d2)>len(d1):
        a = choice(d2)
        print ', a de d2 =',a
        d1.append(a)
        d2.remove(a)
    else:
        if len(d1)>len(d2):
            a = choice(d1)
            print ', a de d1 =',a
            d2.append(a)
            d1.remove(a)
        else:
            a = choice(d2)
            print ', a de d2 =',a
            d1.append(a)
            d2.remove(a)
    d1.sort()
    d2.sort()
    return d1,d2
 
c.sort()
print 'avant id(c[0]) =',id(c[0]),' id(c[1]) =',id(c[1])
new = pick_and_drop(c)
print 'apres id(c[0]) =',id(c[0]),' id(c[1]) =',id(c[1])
print 'new =',new
print 'c =', c

j'ai repris votre code

[eyquem]

donc je pense que Ncourante est égale à courante

Tout à fait.

Mais cela veut dire que ton affirmation «après l'appel ma liste new est égale à c» dans le premier message ne résultait pas d’une observation mais d’une déduction: d’où, après, la difficulté de comprendre le problème.



Pour ne pas rester sur une déduction, c’est facile de faire des vérifications:

Code :

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

1
2
3
4
5
6
7
8
9
10
    courante = c
    solution = courante
    poids = arete_inter(c)
    t = Temp_init(taux_acc)
    print 'courante =',courante
    Ncourante = pick_and_drop(courante)
    print 'courante =',courante
    print 'courante==Ncourante   est',courante==Ncourante
    print "avant",(courante,Ncourante)
    while gel>0:

Et à partir de là, une fois vérifié que courante et Ncourante ont les mêmes valeurs, et que c’est parce que courante est modifiée dans la fonction, on peut se lancer dans le débugage en remontant la piste.





La solution du problème est dans le message #5 ci-dessus.
Au moment où je le postais dans une première version, j’ai compris où était le vrai problème, c’est pour ça que je l’ai effacé et réécrit.







Puisqu’on est dans le sujet, quelques précisons supplémentaires:

Code :

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

c = complementaire()

crée un objet et une référence (étiquette) c lui est accrochée.

Code :

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

courante = c

accroche une deuxième étiquette courante au même objet. Aucun objet supplémentaire n’est créé

Code :

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

solution = courante

Une troisième étiquette est accrochée au même objet déjà référencé par c et courante. Toujours pas d’objet supplémentaire créé.

Code :

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

Ncourante = pick_and_drop(courante)

Un objet est créé (dans le même temps l’objet référencé par courante est modifié) et l’étiquette Ncourante lui est accrochée.

Il y a maintenant deux objets, le même (c’est à dire situé toujours au même endroit dans la mémoire, mais dont les bits ont subi une modification) objet référencé par c, courante et solution;
et l’objet référencé par Ncourante.



cf les deux paragraphes intitulés
Les autres langages ont des "variables"
et
Python a des "noms"
dans
http://www.biologeek.com/bonnes-prat...stuces-python/




Le truc central à piger c’est qu’en Python, une instruction

Code :

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

x = quelque chose

déclenche

• tantôt une création d’objet (allocation d’une zone mémoire et écriture dans cette zone mémoire pour représenter une valeur ou une structure de données) SUIVIE d’une affectation de référence x à l’objet créé,
  
• tantôt l’affectation de la référence x à un objet préalablement existant déjà référencé

par ’quelque chose’,

et ce en fonction de ce qu’est ’quelque chose’.

Et qu’il faut donc examiner attentivement les ’quelque chose’ et bien saisir ce qu’on déclenche par telle ou telle instruction.




Je crois avoir compris que dans (l/d)es autres langages, le processus se produit dans un autre ordre: délimitation d’une zone mémoire sans fixer de valeurs à ses bits , affectation d’un nom (à ce moment là on a une variable, c’est à dire une case mémoire) et ENSUITE on remplit la variable avec une valeur ou une structure de données. D’où le bazar lié à la déclaration des types, car la création de la case mémoire doit se faire de telle façon qu’elle puisse accueillir les valeurs qu’on y écrira par la suite.
Enfin bon, grosso modo , c’est ça, mais je ne suis pas un spécialiste. Ça doit être assez sommaire cette description. Cependant ce sommaire là me permet de me débrouiller pas mal.






Je vais regarder deux ou trois autres trucs dans ton code.