Discussion :

[eljoj]

bonjour

Je veux récupérer des données à partir desquelles je veux organiser différents tris.

Mes données sont regroupées par 3 (nom_joueur, nouveau_score, ancienne_place),
le nom du joueur étant la clé (il est unique), ancienne_place étant la place avant le nouveau score, nouveau_score étant les nouveaux points obtenus.

J'aimerais faire une fonction nouvelle_place indiquant la place obtenue à partir de la place initiale et des points obtenus au nouveau score.

Il n'y a que 10 joueurs, il n'y a pas d’ex-æquo mais les scores peuvent être identiques.

Déjà, je ne sais pas sous quelle forme je peux récupérer ces données (liste? tuple? Dictionnaire? dictionnaire et tupple). Ne vaut-il pas mieux utiliser ancienne_place comme clé?

Cela s'organise ainsi : resultats = {(Robert :0 :1er), (Jeanne: 4:2eme), (Eric: 1: 3eme), (Isabelle:3:4eme), (Jean:3:5eme),( Mathilde :2;6eme), (Maeva:0:6eme), (Christian:2:6eme), (François, 1:7eme), (Hélène:0:8eme), (Paul:0:10ème)

1er tri:
Je pense qu'il faut d'abord trier ce qui ont 0 (Robert, Maeva, Hélène, Paul)
Comme Paul et Hélène ont eu "0", leur classement ne change pas Paul 10eme, Hélène 9eme
Robert, qui était 1er, mais qui a eu "0" passe 8eme

2eme tri : ceux qui ont eu 1
François devient à nouveau 7eme et Eric 6eme

3eme tri : ceux qui ont eu 2
Christian est 5eme, Mathilde 4eme

4eme tri: ceux qui ont eu 3
Jean devient 3eme Eric 2eme

5eme tri : ceux qui ont eu 4

Jeanne est 1ere

Qui peut m'aider?

[Sve@r]

Bonjour

Déjà, je ne sais pas sous quelle forme je peux récupérer ces données (liste? tuple? Dictionnaire? dictionnaire et tupple).

Ben ça il n'y a que toi qui peut le savoir. Le dictionnaire a des avantages mais a l'inconvénient principal de ne pas pouvoir prévoir l'ordre de restitution de ses infos. Donc en fait, chaque fois que tu voudras tes joueurs dans un ordre précis, il te faudra les retrier à ce moment là.

Ne vaut-il pas mieux utiliser ancienne_place comme clé?

Utiliser comme clef une valeur évolutive ??? Là à mon avis c'est clairement non.

1er tri: Je pense qu'il faut d'abord trier ce qui ont 0 (Robert, Maeva, Hélène, Paul)
2eme tri : ceux qui ont eu 1
3eme tri : ceux qui ont eu 2
4eme tri: ceux qui ont eu 3
5eme tri : ceux qui ont eu 4

Compliqué. Pourquoi ne pas commencer par attibuer aux joueurs les points gagnés ; puis ensuite trier une seule fois selon le score final ???

[eljoj]

Merci de votre réponse.

Donc déjà je garde mes joueurs comme clé.
En fait le classement ne dépend pas seulement de ce score là, il dépend à la fois du 1er classement et du score.
Si j'avais un seul critère, et surtout un nombre, je ne viendrais pas ici poser ma question.

[wiztricks]

Si j'avais un seul critère, et surtout un nombre, je ne viendrais pas ici poser ma question.

Quelque soit le nombre de critères, sélectionner les objets/éléments qui matchent c'est une boucle "for" et des tests. Ce ne sera peut être pas un code optimal mais il illustrera quand même ce que vous cherchez à faire (désolé mais pas facile de comprendre ce que vous cherchez à faire et les difficultés que cela vous pose).

- W

[eljoj]

bonjour et merci

Je cherche à faire ce que j'ai indiqué dans mon exemple, une mise en ordre à partir de 2 critères. Il n'y aura,à chaque fois, que 10 joueurs. Donc la rapidité n'est pas un problème.
Peut-être qu'en utilisant une liste et son index, et en enregistrant les joueurs dans l'ordre de leur ancienne_place je règle la question du 1er critère de classement?

[wiztricks]

Peut-être qu'en utilisant une liste et son index, et en enregistrant les joueurs dans l'ordre de leur ancienne_place je règle la question du 1er critère de classement?

Je ne comprends pas plus ce que vous cherchez à faire. Mais, il n'est pas difficile de faire une fonction qui retourne la liste de ceux qui ont eu:
5: elle ne contient qu'un élément ce sera le premier,
4: elle contiendra 2 éléments et le rang sera fonction de leur dernier classement,
3: ...
Avec Python, çà peut s'écrire en une seule ligne (voir le how-to sur le sort) mais si le but de l'exercice est de pratiquer listes, boucles, çà ne le fera pas... Et si vous ne postez pas les quelques lignes de code que vous avez écrit en décrivant ce qui vous bloque, on ne va pas pouvoir vous aider.

- W

[Sve@r]

Je cherche à faire ce que j'ai indiqué dans mon exemple, une mise en ordre à partir de 2 critères.

Ben si tu places tous tes joueurs dans une liste, tu peux alors écrire une fonction cmp(x, y) qui compare x et y (x et y étant sensés être deux joueurs de la liste) selon le premier critère et si ce critère ne permet pas de faire la différence, alors tu compares ensuite sur le second critère
Style

Code python :

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

1
2
3
4
5
6
7
def cmp(x, y):
    if x < y (selon le premier critère) return -1
    if x > y (selon le premier critère) return 1
    if x < y (selon le second critère) return -1
    if x > y (selon le second critère) return 1
    return 0
# cmp()

Ensuite tu appelles sorted() en lui passant ta liste de joueurs en premier paramètre et "cmp" en second paramètre. Ca te renverra une copie triée de cette liste en fonction de tes deux critères...

[BufferBob]

salut,

le classement (...) dépend à la fois du 1er classement et du score.

on est d'accord que le score importe plus que l'ancien classement ?

on pourrait simplement prendre la liste des scores, triée, et pour chaque score effectuer un second tri (qu'il soit nécessaire ou non, quand il n'y a qu'un seul enregistrement concerné) sur l'ancien classement, ça a du sens ?

ma sauce :

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
#
# ici j'ai choisi une liste de listes, ca ou autre chose...
#
resultats = [
   ['Robert', 0, 1],    ['Jeanne', 4, 2],    ['Eric', 1, 3],
   ['Isabelle', 3, 4],  ['Jean', 3, 5],      ['Mathilde', 2, 6],
   ['Maeva', 0, 6],     ['Christian', 2, 6], ['François', 1, 7],
   ['Hélène', 0, 8],    ['Paul', 0, 10]
]
 
#
# on met ces données en forme, c'est pas hyper nécéssaire mais ça permet de s'y retrouver un peu
# à la fin on a un truc du genre :
# db = [ {'nom': 'Robert', 'oldclass': 1, 'score': 0},
#        {'nom': 'Jeanne', 'oldclass': 2, 'score': 4},
#        {'nom': 'Eric', 'oldclass': 3, 'score': 1},   etc. ]
#
db = [dict(zip(['nom', 'score', 'oldclass'], i)) for i in resultats]
 
#
# on récupère la liste des scores, triées du plus élevé au plus bas :
#
scores_tries = sorted(set([i['score'] for i in db]), reverse = True)
 
#
# et enfin pour chaque scores identiques, on trie les enregistrements sur la base
# de leur ancien classement, on ajoute le tout au classement définitif
#
classement_final = []
for score in scores_tries:
   classement_final.extend(sorted([i for i in db if i['score'] == score], key=lambda x: x['oldclass']))

à la fin on obtient donc pour classement_final :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
[{'nom': 'Jeanne',      'oldclass': 2,  'score': 4},
 {'nom': 'Isabelle',    'oldclass': 4,  'score': 3},
 {'nom': 'Jean',        'oldclass': 5,  'score': 3},
 {'nom': 'Mathilde',    'oldclass': 6,  'score': 2},
 {'nom': 'Christian',   'oldclass': 6,  'score': 2},
 {'nom': 'Eric',        'oldclass': 3,  'score': 1},
 {'nom': 'François',    'oldclass': 7,  'score': 1},
 {'nom': 'Robert',      'oldclass': 1,  'score': 0},
 {'nom': 'Maeva',       'oldclass': 6,  'score': 0},
 {'nom': 'Hélène',      'oldclass': 8,  'score': 0},
 {'nom': 'Paul',        'oldclass': 10, 'score': 0}]

[wiztricks]

Salut,

En une seule ligne:

Code :

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

1
2
3
4
5
6
7
8
9
10
resultats = [
   ['Robert', 0, 1],    ['Jeanne', 4, 2],    ['Eric', 1, 3],
   ['Isabelle', 3, 4],  ['Jean', 3, 5],      ['Mathilde', 2, 6],
   ['Maeva', 0, 6],     ['Christian', 2, 6], ['François', 1, 7],
   ['Hélène', 0, 8],    ['Paul', 0, 10]
]
 
liste = sorted(resultats, key=lambda x: (x[1], 10 - x[2]), reverse=1)
for e in liste:
    print(e)

Il faut se souvenir que des séquences comme tuple, liste, ... sont "naturellement" ordonnés par leur ordre alphabétique i.e. on sait comparer (1, 2) à (1, 3) comme on sait comparer "ab" à "ac" (et on s'en sert depuis plus de 2000 ans...)

- W

[eljoj]

Merci à vous
ça marche et c'est exactement ce que je cherchais!

Eljoj