Discussion :

[rambc]

Bonjour,
j'ai le code suivant :

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
#!/usr/bin/env python
#coding=utf-8
class Interval():
    def __init__(self, a, b):
        if a > b:
            self.min = b
            self.max = a
        else:
            self.min = a
            self.max = b
 
    def __str__(self):
        return '(' + str(self.min) + ';' + str(self.max) + ')'
 
I = Interval(3, -4)
J = Interval(-5, 7)
K = Interval(-2, 9)
 
intervalSorted =  [I, J, K] # ???
 
for i in intervalSorted:
    print str(i)

Je voudrais que les intervalles soient rangés suivant les valeurs croissantes des min. Autrement dit, je voudrais faire un tri suivant les valeurs de I.min, J.min et K.min.

Toute info. est la bienvenue.

[rambc]

Avant de me faire engueler par pacificator le violent , je mets la réponse adaptée de ce qui se trouve en fait ici : un autre post .

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
#!/usr/bin/env python
#coding=utf-8
class Interval():
    def __init__(self, a, b):
        if a > b:
            self.min = b
            self.max = a
        else:
            self.min = a
            self.max = b
 
    def __str__(self):
        return '(' + str(self.min) + ';' + str(self.max) + ')'
 
 
def cmpval(x,y):
    if x.min<y.min:
        return -1
    elif x.min==y.min:
        return 0
    else:
        return 1
 
I = Interval(3, -4)
J = Interval(-5, 7)
K = Interval(-2, 9)
 
intervalSorted =  [I, J, K]
intervalSorted.sort(cmpval)
 
for i in intervalSorted:
    print str(i)

[pacificator]

Avant de me faire engueler par pacificator le violent

Disons que la réponse était un peu .. fraîche ... mais pas violente, et il a trouvé sa réponse en cherchant sans que je le


En passant, tu peux faire directement

Code :

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

intervalSorted =  sorted([I, J, K], cmpval)

enfin c'est toi qui vois

Allez, viens faire un , ça ira mieux

[rambc]

En passant, tu peux faire directement

Code :

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

intervalSorted =  sorted([I, J, K], cmpval)

enfin c'est toi qui vois

Cette méthode crée une nouvelle liste et l'autre modifie la liste en cours. Il se trouve que pour mon projet j'ai besoin d'une nouvelle liste donc merci pour ta remarque.

Allez, viens faire un , ça ira mieux

pacificator aurait-il un coeur ?

[shadowsam]

Tient, en passant, il y a même plus efficace pour ce que tu cherches à faire:

Code :

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

1
2
 
intervalSorted = sorted([I, J, K], key=lambda x: x.min)

Cela évite d'évaluer plusieurs fois le même élément pour de multiple comparaisons.

[rambc]

Salut et merci pour cette solution très compacte. J'en reste bouche bé... En quoi elle est plus efficace si ce n'est pas trop long à expliquer.

J'imagine qu'il faut réserver l'utilisation d'une fonction de comparaisons pour des tests de rangement ad hoc comme par exemple s'il y a besoin de comparer à la fois les valeurs de x.min et/ou de x.max.

[shadowsam]

En fait l'utilisation de l'argument key au lien de cmp dans les fonction de tri permet de donner non pas la méthode de comparaison mais juste l'objet a comparer.

L'avantage principal de l'utilisation de key, c'est que il y aura un appel et un seul a la fonction key par objet dans la liste a comparer contrairement a l'utilisation de cmp.

On va faire un petit exemple, ca sera plus parlant.

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
 
L = [[4], [3], [2], [1]]
def comp(x, y):
    global indexations
    indexations += 2
    return cmp(x[0], y[0])
 
def key(x):
    global indexations
    indexations += 1
    return x[0]
 
# Methode 1:
indexations = 0
L1 = sorted(L, cmp=comp)
print "Methode 1, Nombre d'indexations: %d" %indexations
 
# Methode 2:
indexations = 0
L2 = sorted(L, key=key)
print "Methode 2, Nombre d'indexations: %d" %indexations

Le résultat:

Code :

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

1
2
3
 
#Methode 1, Nombre d'indexations: 6
#Methode 2, Nombre d'indexations: 4

On est d'accord, ca n'est pas énorme comme différence. si maintenant on change L en [[4], [3], [2], [1]]*2. donc juste ayant un L de 8 elements au lieu de 4.

Le résultat:

Code :

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

1
2
3
 
#Methode 1, Nombre d'indexations: 30
#Methode 2, Nombre d'indexations: 8

Voila l'avantage principal.

[rambc]

Voilà une réponse d'une grande clarté.

Merci.