erreur sur une fonction

Version imprimable

Bonjour tout le monde ^^

(un petit bonjour en direct live de la réunion en espérant que ca vous apporte du soleil 8-))

voila j'ai un petit soucis sur une fonction en particulier sur ordonnerListe
voici le code :

Code:

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
 
class Contact :
 
    population=0
 
    def __init__(self,nom,prenom):
 
        self.nom=nom
        self.prenom=prenom
        Contact.population +=1
 
    def __del__ (self):
        Contact.population -=1
 
    def __str__ (self):
        return self.nom+' '+self.prenom
 
class ContactsListe :
 
    def __init__(self):
        self._liste=[]
 
    def __len__(self):
        return len(self._liste)
 
    def ajouterContact (self,nom,prenom):
 
        self._liste.append(Contact(nom,prenom))
        self.ordonnerListe()
 
    def enleverContact(self,indice):
        del self._liste[indice]
 
    def afficheContacts (self):
        if self._liste :
            print '-'*40
            for x in self._liste :
                print str(x)
            print '-'*40
        else :
            print "La liste de contacts est vide"
 
    def ordonnerListe (self):
        self._liste = sorted(self._liste, key=lambda Contact: Contact.nom)
        for x in range(len(self._liste)-1) :
            if self._liste[x].nom == self._liste[x+1].nom :
                debut=x
                fin=x
                while self._liste[x].nom == self._liste[x+1].nom :
                    fin=x+1
                    x+=1
                self._liste[debut:fin]=sorted(self._liste[debut:fin], key= lambda Contact: Contact.prenom)

en fait je veux que ordonnerListe ordonne par ordre alphabétique les noms et si certains noms sont identiques qu'il trie ces noms par ordre alphabétique des prénoms .....hors la il ne trie que les noms par ordre alphabetique et des que des noms sont identiques il ne trie pas par prénoms et je vois pas ou ça coince dans mon code ... si quelqu'un peut m'aider merci d'avance ;)

21/08/2010, 18h13
dividee

Il y a une solution simple. En Python, la comparaison de séquences (tuples, listes, etc.) est lexicographique: il compare le premier élément des deux séquences, s'ils sont égaux, il compare le second, etc.
Donc pour trier sur base du nom d'abord et du prénom ensuite, il suffit de trier sur base de (nom, prénom):

Code:

self._liste.sort(key=lambda Contact: (Contact.nom, Contact.prenom))
21/08/2010, 19h29
Debian python

merci dividee pour la solution ;) rapide et précise
Encore juste une petite interrogation : vois tu pourquoi mon code n'a-t-il pas fonctionné ? quelle était la ligne que python n'a pas compris...
C'est en comprenant ses erreurs qu'on avance ^^

Citation:

des que des noms sont identiques il ne trie pas par prénoms

Ce n’est pas ce que j’ai constaté avec le code suivant qui mime la partie rangement de ton code.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 li = [('glopo', 'jim'), ('somera', 'zoe'),('jyty', 'rene'), ('aplo', 'jean'), ('jyty', 'jo'), ('turumic', 'paul'), ('jyty', 'herve'), ('jyty', 'alix'), ('sol', 'vincent'), ('somera', 'adele'), ('wey', 'linpiao')] li.sort(key = lambda el: el[0]) print 'li =\n%r\n\n\nx %21s x+1 %14s li[x+1][0]==li[x][0]\n%s' % (li,' ',' ',72*'-') for x in range(len(li)-1) : print '\n%-2d %-8s %-12s %-2d %-8s %-13s %r'\ % (x,li[x][0],li[x][1],x+1,li[x+1][0],li[x+1][1],li[x+1][0]==li[x][0]) if li[x+1][0]==li[x][0]: debut,fin = x,x print 'debut,fin = %d , %d' % (debut,fin) while li[x][0]==li[x+1][0]: fin=x+1 x+=1 print 'fin,x = %d , %d \nli[%d:%d] :\n- avant rangement :\n %r'\ % (fin, x, debut, x, li[debut:x]) li[debut:x] = sorted(li[debut:x], key = lambda el: el[1]) print '- apres rangement :\n ' + repr(li[debut:x]) print '\nli = \n',li
Sur une liste de départ particulière que tu as prise, tu as peut être observé un résultat te faisant croire qu’il n’y avait pas du tout de mise en ordre effectué sur les prénoms. Mais ce n’est pas le cas, ton code effectue bien un rangement sur la base des prénoms aussi.

Toutefois il y a une erreur dans ce rangement.

Quand une boucle
Code:

1 2 3 while li[x][0]==li[x+1][0]: fin=x+1 x+=1
est terminée,
fin est l’indice du dernier élément à prénom identique aux précédents, le prénom en fin+1 étant différent.
Or juste après, tu découpes self._liste[debut:fin]
Mais ce devrait être self._liste[debut:fin+1] pour englober ce dernier élément qui a l’indice fin

Il y a quelques autres choses encore:

1) avant cette boucle
Code:

1 2 3 while li[x][0]==li[x+1][0]: fin=x+1 x+=1
les objets fin et x partent avec la même valeur puisqu’il y a eu fin=x.
Puis ensuite, à chaque tour de la boucle, il y a
Code:

1 2 fin=x+1 x+=1
c’est à dire
Code:

1 2 fin=x+1 x=x+1
On voit bien que x et fin partant avec la même valeur et évoluant de la même façon sont toujours égaux.

L’utilisation d’un identifiant fin supplémentaire à x dans la boucle est inutile.

2) après li[debut:fin+1] = sorted(li[debut:fin+1], key = lambda el: el[1])
l’examen de la liste devrait recommencer à partir de l’indice fin+1 pour éviter de reranger la portion de liste ayant des noms identiques.

Au lieu de cela, la boucle for x in range(len(li)-1) :
relance un tour avec une valeur de x égale à debut+1

3) dans le code au dessus, remplace ('turumic', 'paul') par ('wey', 'paul') et ('sol', 'vincent') par ('wey', 'vincent') :
tu verras le problème lorsque la liste se termine par plusieurs noms identiques.

Voici une façon de corriger ton code:
Code:

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 li = [('glopo', 'jim'), ('somera', 'zoe'),('jyty', 'rene'), ('aplo', 'jean'), ('jyty', 'jo'), ('turumic', 'paul'), ('jyty', 'herve'), ('jyty', 'alix'), ('sol', 'vincent'), ('somera', 'adele'), ('wey', 'linpiao')] li.sort(key = lambda el: el[0]) print 'li =\n%r\n\n\nx %21s x+1 %14s li[x+1][0]==li[x][0]\n%s' % (li,' ',' ',72*'-') x = 0 while x<len(li)-1: print '\n%-2d %-8s %-12s %-2d %-8s %-13s %r'\ % (x,li[x][0],li[x][1],x+1,li[x+1][0],li[x+1][1],li[x+1][0]==li[x][0]) if li[x+1][0]==li[x][0]: print ' li['+str(x)+']==li['+str(x+1)+']' debut=x while li[x][0]==li[x+1][0]: x+=1 if x>=len(li)-1: break avant = li[debut:x+1] li[debut:x+1] = sorted(li[debut:x+1], key = lambda el: el[1]) print 'li[%d:%d] :\n- avant rangement :\n %r\n- apres rangement :\n %r\n'\ % (debut, x+1, avant, li[debut:x+1]) x+=1 print 'li =\n',li
Mais évidemment, c’est moins bien que
Code:

1 2 3 4 5 6 7 li = [('glo', 'jim'), ('som', 'andre'),('jyt', 'rene'), ('aplo', 'jean'), ('jyt', 'gerard'), ('wey', 'paul'), ('jyt', 'maurice'), ('jyt', 'herve'), ('wey', 'vincent'), ('som', 'adele'), ('wey', 'linpiao')] li.sort() print 'li =\n',li
:D
.