[Python 3] Méthodes de tri

ARTICLE EN COURS DE CONSTRUCTION

### 2 - TRI - ###

### 2.1 TRI : tuple
aa = (8, 4, 6, 1, 9, 5, 2, 7, 0, 3)
### 2.1.1 TRI : tuple : sorted()
print("### 2.1.1 TRI : tuple : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.2 TRI : list à une dimension
aa = [8, 4, 6, 1, 9, 5, 2, 7, 0, 3]
### 2.2.1 TRI : list à une dimension : sorted()
print("### 2.2.1 TRI : list à une dimension : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.2.2 TRI : list à une dimension : sort()
print("### 2.2.2 TRI : list à une dimension : sort()")
aa.sort()
print(aa)
print()

### 2.3 TRI : list à plusieurs dimensions
aa = [
("h", "J", 2),
("j", "I", 8),
("a", "G", 4),
("g", "H", 3),
("i", "E", 6),
("b", "D", 5),
("c", "B", 0),
("d", "F", 7),
("f", "C", 1),
("e", "A", 9)
]
### 2.3.1 TRI : list à plusieurs dimensions : sorted()
print("### 2.3 TRI : list à plusieurs dimensions : sorted()")
sorted(aa)
print(aa)
print(sorted(aa))
print()

### 2.3.2 TRI : list à plusieurs dimensions : lambda
print("### 2.3 TRI : list à plusieurs dimensions : lambda")
xx = sorted(aa, key=lambda x: x[0])
print(*xx)
yy = sorted(aa, key=lambda x: x[1])
print(*yy)
zz = sorted(aa, key=lambda x: x[2])
print(*zz)
print()

### 2.3.3 TRI : list à plusieurs dimensions : itemgetter
aa = [
("abricot ", "catégorie 1 ", "prix 1"),
("pomme ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 2 ", "prix 3"),
("raisin ", "catégorie 1 ", "prix 3"),
("abricot ", "catégorie 2 ", "prix 2"),
("pomme ", "catégorie 1 ", "prix 1"),
("abricot ", "catégorie 2 ", "prix 2"),
("pomme ", "catégorie 1 ", "prix 1"),
("orange ", "catégorie 2 ", "prix 2")
]
from operator import itemgetter as ig
print("### 2.3 TRI : list à plusieurs dimensions : itemgetter")
zz = sorted(aa, key=ig(0,1,2))
print(*zz)
zz = sorted(aa, key=ig(1,0,2))

for i, j, k in zz:
print(i, j, k)

print()

### 2.4 TRI : dict
dico = {"Alain": 2, "Bernard": 3, "Christian": 4, "Dominique": 1}

### 2.4.1 TRI : dict : lambda
print("### 2.4.1 TRI : dict : lambda")
aa = dico.items()

zz = sorted(aa, key=lambda x: x[0])
print(*zz)
zz = sorted(aa, key=lambda x: x[1])
print(*zz)
print()

### 2.4.2 TRI : dict : itemgetter
from operator import itemgetter as ig
print("### 2.4.2 TRI : dict : itemgetter")

aa = dico.items()

zz = sorted(aa, key=ig(0))
print(*zz)
zz = sorted(aa, key=ig(1))
print(*zz)
print()

### 2.5 TRI : class
### 2.5.1 TRI : class : list (ou tuple) : attrgetter
class Fruits:
def __init__(self, aa, bb):
self.prod = aa
self.prix = bb

def __repr__(self):
return "\n{} : {}€".format(self.prod, self.prix)

fruits = [
Fruits("poires ", 3),
Fruits("pommes ", 2),
Fruits("oranges", 2),
Fruits("cerises", 4),
Fruits("abricot", 2)
]

from operator import attrgetter as ag
print("### 2.5.1 TRI : class : list (ou tuple) : attrgetter")
zz = sorted(fruits, key=ag("prod", "prix"))
print(*zz)

zz = sorted(fruits, key=ag("prix", "prod"))
print(*zz)
print()

### 2.5.2 TRI : class : dict : attrgetter
dico = {}
dico["poires"] = Fruits("poires ", 3)
dico["pommes"] = Fruits("pommes ", 2)
dico["oranges"] = Fruits("oranges ", 2)
dico["cerises"] = Fruits("cerises ", 4)
dico["abricots"] = Fruits("abricots", 2)

from operator import attrgetter as ag
print("### 2.5.2 TRI : class : dict : attrgetter")

zz = sorted(dico.values(), key=ag("prod", "prix"))
print(*zz)
zz = sorted(dico.values(), key=ag("prix", "prod"))
print(*zz)

[Python 3] Trier un « Dictionnaire »

Dans de nombreux langages informatiques, on retrouve le « Dictionnaire », cette variable un petit peu particulière qui regroupe l’association d’un ensemble de « clés » à leur « valeur », comme un dictionnaire est le regroupement d’un ensemble de mots associés à leur définition.

Je ne m’étendrai pas, ici, sur le fonctionnement du dictionnaire; je rappellerai néanmoins que dans un dictionnaire, chaque clé (le mot) est unique (mais plusieurs clés peuvent avoir la même valeur).

En Python, on remarquera que l’affichage du contenu d’un dictionnaire est aléatoire; ainsi, si j’établis mon dictionnaire dico de la façon suivante et que j’en demande l’affichage par une fonction print()

dico = {"zéro" : 0, "un" : 1, "deux" : 2, "trois" : 3, "quatre" : 4, "cinq" : 5}
print(dico)

Résultat : {‘un’: 1, ‘quatre’: 4, ‘deux’: 2, ‘zéro’: 0, ‘cinq’: 5, ‘trois’: 3}

je constate que, même si l’affichage n’est pas particulièrement attrayant, les éléments qui composent notre dictionnaire sont présentés de façon erratique.

N’ayant pas la possibilité de modifier l’ordre d’affichage dans un dictionnaire, nous allons contourner ce problème en enregistrant l’ensemble de notre dictionnaire dans une variable que nous appellerons ici mavar

mavar = dico.items()

Notons simplement que pour réussir notre opération, nous devons faire appel à la méthode items().
Ensuite, nous appliquons la méthode sorted() pour effectuer le tri et l’enregistrons dans une variable que nous appelons montri

montri = sorted(mavar, key=lambda x: x[1])

La méthode sorted() appelle tout d’abord l’objet que nous souhaitons trier, à savoir la variable mavar dans laquelle nous avons enregistré l’ensemble des binômes contenus dans notre dictionnaire.

Nous choisissons ensuite, avec la suite key=lambda x: x[1], la « clé » key de notre tri (à ne pas confondre avec les clés du dictionnaire), qui va définir le paramètre de tri (tri par clés du dictionnaire – zéro, un, deux etc… – auquel cas la valeur entre crochets sera x[0], ou par valeurs – 0, 1, 2 – avec x[1]).

A noter que si nous voulions notre affichage dans l’ordre descendant, nous aurions rajouté à notre méthode sorted() la commande reverse=True, comme ceci

montri = sorted(mavar, key=lambda x: x[1], reverse=True)

Pour info : il existe d’autres méthodes pour faire un tri en Python, notamment en faisant appel à la commande itemgetter de la bibliothèque operator.

Il ne nous reste plus qu’à afficher le résultat de notre tri, avec une « liste en intention », par exemple, alternative intéressante à la traditionnelle boucle en for

[print(j, i) for i, j in montri]

Quelques explications concernant cette ligne : rappelons que la variable montri est composée de binômes :
zéro, 0
un, 1
deux, 2…
i et j vont respectivement venir extraire les clés (zéro, un, deux, trois…) et les valeurs (0, 1, 2..).
Notre ligne de code demande donc d’afficher successivement chaque binôme j, i (print(j, i) nous avons inversé l’ordre d’affichage) par l’intermédiaire d’une boucle (for i, j) contenu dans notre objet montri.

Voici le code dans sa totalité :

dico = {"zéro" : 0, "un" : 1, "deux" : 2, "trois" : 3, "quatre" : 4, "cinq" : 5}
mavar = dico.items()
montri = sorted(mavar, key=lambda x: x[1])
[print(j, i) for i, j in montri]


0 zéro
1 un
2 deux
3 trois
4 quatre
5 cinq