DESCRIPTION.

Tri et réordonne les items d'une liste.

SYNTAXE.

LST_Designation.sort ( fonction , reverse = sens )

LST_Designation ⇨ nom de la liste [ OBLIGATOIRE ]

.sort ( ) ⇨ appel de la méthode [ OBLIGATOIRE ]

fonction ⇨ fonction à exécuté sur item pour redéfinir son index [ optionnel ]

sens ⇨ indique si l'ordre est croissant ou décroissant [ optionnel ]

REMARQUES.

fonction peut être : une fonction, méthode, ou même un appelable, unique. C'est la valeur retournée, par le traitement de l'item par fonction, qui servira pour déterminer la nouvelle position de l'item dans la list ( ). fonction doit être écrite sans parenthèse ni argument. Si un ou des arguments doivent être notifiés pour le traitement des éléments, il faut utiliser un fonction anonyme, lambda. Quelque soit la valeur retournée par fonction, la valeur de l'élément de list ( ) change pas. fonction est un argument nommé key = fonction. 

sens est un booléen. S'il vaut False, valeur par défaut, les items seront classés par ordre croissant (du plus petit au plus grand). S'il vaut True, les items seront classés par ordre décroissant (du plus grand au plus petit). Attention cependant car la notion de plus petit / plus grand peut varier selon la nature des objets affectés aux items. sens est un argument nommé reverse = sens. 

LST_Designation doit être une liste existante et valide, même si elle ne possède aucun item (list ( ) vide).

Rappel : Le premier item d'une collection (list ( ), tuple ( ), ... ) se trouve à l'index 0.

EXEMPLES.

1. Utilisation sans clé de tri.

LST_Mississippi = [ "m" , "i" , "s" , "s" , "i" , "s" , "s" , "i" , "p" , "p" , "i" ]

LST_Mississippi.sort ( )

print ( LST_Mississippi ) retourne ['i', 'i', 'i', 'i', 'm', 'p', 'p', 's', 's', 's', 's']

LST_Mississippi.sort ( reverse = True )

print ( LST_Mississippi ) retourne ['s', 's', 's', 's', 'p', 'p', 'm', 'i', 'i', 'i', 'i']

print ( LST_Mississippi.sort ( ) ) retourne None

C'est l'évaluation (None, rien, vide) de LST_Mississippi.sort ( ) qui affichée car la méthode list ( ).sort ( ) ne retourne pas une nouvelle list ( ), mais modifie la list ( ) appelante.

print ( LST_Mississippi ) retourne ['i', 'i', 'i', 'i', 'm', 'p', 'p', 's', 's', 's', 's']

Mais la méthode sort ( ) a bien été appelé et exécuté.

2. Utilisation avec clé de tri retournant le même type d'objet.

LST_Mississippi = [ "M" , "i" , "S" , "s" , "I" , "s" , "s" , "I" , "P" , "p" , "i" ]

LST_Mississippi.sort ( )

print ( LST_Mississippi ) retourne ['I', 'I', 'M', 'P', 'S', 'i', 'i', 'p', 's', 's', 's'] 

Les majuscules sont placées par ordre alphabétiques en début de list ( ) puis les minuscules, par ordre alphabétique, en fin de list ( ).

LST_Mississippi.sort ( key = str.upper )

Les lettres seront toutes évaluées comme si elles étaient des majuscules. A noter aussi que la méthode appelée (str.upper ( )) est indiquée sans parenthèse ni argument.

print ( LST_Mississippi ) ['I', 'I', 'i', 'i', 'M', 'P', 'p', 'S', 's', 's', 's']

Les lettres sont placées dans l'ordre alphabétique, mais si des lettres sont présentes plusieurs fois, leur forme majuscule est placée d'abord. Même si les lettres minuscules ont été évaluées sous leur forme majuscule, leurs valeurs restent inchangées dans la list ( ).

3. Utilisation avec clé de tri retournant un type d'objet différent.

LST_Couleurs =  [ "noir" , "rouge" , "orange" , "or" , "magenta" , "purple" ]

LST_Couleurs.sort ( )

print ( LST_Couleurs ) retourne ['magenta', 'noir', 'or', 'orange', 'purple', 'rouge']

Les items sont maintenant rangés dans l'ordre numérique.

LST_Couleurs.sort ( key = len )

print ( LST_Couleurs ) retourne ['or', 'noir', 'rouge', 'orange', 'purple', 'magenta']

Chaque items appellent la méthode len ( ) qui retourne le nombre de lettres dans le nom de la couleur. Python va ordonner les items en fonction des valeurs retournées. Les items sont maintenant rangés selon le nombre de lettres qu'ils contiennent, Mais les noms reste inchangés dans la list ( ).

4. Utilisation avec des items de type objet collection.

LST_Points =  [ ( 4 , 8 , 2 ) , ( 3 , 7 , 8 ) , ( 9 , 7 ) , ( 1 , 5 , 4 , 7 ) , ( 4 , 5 , 7 ) ]

LST_Points.sort ( ) retourne [(1, 5, 4, 7), (3, 7, 8), (4, 5, 7), (4, 8, 2), (9, 7)]

print ( LST_Points ) 

Si les items de la list ( ) sont des objets collections (list ( ), tuple ( ), ... ), sans fonction, Python les tri en comparant le premier élément de chaque item. Si plusieurs items ont le même premier élément, Python utilisera l'élément suivant pour le tri. Et ainsi de suite.

LST_Points.sort ( key = sum )

print ( LST_Points ) retourne [(4, 8, 2), (4, 5, 7), (9, 7), (1, 5, 4, 7), (3, 7, 8)]

Python a évalué la somme des éléments de chaque items de la list ( ) pour effectuer et restituer le tri de la list ( ).

5. Utilisation avec une clé de tri sur un élément des items d'objet collection.

LST_Dates =  [ ( 1994 , 8 , 2 ) , ( 1993 , 7 , 8 ) , ( 1992 , 8 , 7 ) , ( 1995 , 1 , 7 ) , ( 1994 , 5 , 17 ) ]

LST_Dates.sort ( )

print ( LST_Dates ) retourne [(1992, 8, 7), (1993, 7, 8), (1994, 5, 17), (1994, 8, 2), (1995, 1, 7)]

LST_Dates.sort ( key = lambda kdate : kdate [ 1 ] )

print ( LST_Dates ) retourne [(1995, 1, 7), (1994, 5, 17), (1993, 7, 8), (1992, 8, 7), (1994, 8, 2)]

LST_Dates.sort ( key = lambda kdate : kdate [ 2 ] )

print ( LST_Dates ) retourne [(1994, 8, 2), (1995, 1, 7), (1992, 8, 7), (1993, 7, 8), (1994, 5, 17)]

Si les items de la list ( ) sont des objets collections (list ( ), tuple ( ), ... ), grâce à fonction utilisant une fonction anonyme (lambda) on peut forcer Python a trier la liste en comparant, d'abord, un élément autre que le premier dans chaque item.

6. Utilisation d'une méthode utilisateur comme clé de tri.

Il est possible d'utiliser n'importe quel objet appelable avec l'argument key = fonction , même ceux créés pour les besoins du programme grâce à l'instruction def. Attention cependant à ne pas mettre de parenthèse après le nom de la méthode, qu'elle soit built-in, importée ou définie dans le programme. Python lui passe, automatiquement, chaque items de la liste à trier Par contre, celle-ci doit prévoir de recevoir ce paramètre dans sa définition.

def FNC_Terminaison ( event ) :

kconvertion = str ( event )

kterminaison = int ( kconvertion [ -1 ] )

print ( f"{ event } se termine par { kterminaison }." )

return kterminaison

LST_Premiers =  [ 2 , 3 , 5 , 7 , 11 , 13 , 17 , 19 , 23 , 29 , 31 , 37 , 41 , 47 ]

LST_Premiers.sort ( key = FNC_Terminaison )

print ( LST_Premiers ) 

retourne

2 se termine par 2.

3 se termine par 3.

5 se termine par 5.

7 se termine par 7.

11 se termine par 1.

13 se termine par 3.

17 se termine par 7.

19 se termine par 9.

23 se termine par 3.

29 se termine par 9.

31 se termine par 1.

37 se termine par 7.

41 se termine par 1.

47 se termine par 7.

[11, 31, 41, 2, 3, 13, 23, 5, 7, 17, 37, 47, 19, 29]

7. Utilisation d'une méthode avec attributs comme clé de tri.

L'instruction lambda permet aussi d'appeler une fonction personnalisée, en lui passant des attributs ou non, pour des traitements complexes et/ou spécialisés des items de la list ( ). La valeur retournée par la fonction utilisateur servira pour le tri des éléments de la liste. 

def FNC_Test ( Q ) :

kscore = 1

if len ( Q ) > 3 :

kmaximum = list ( Q )

kmaximum.sort ( reverse = True ) 

kscore = sum ( kscore [ : 3 ] )

elif len ( Q ) < 3 :

for kpoints in Q : kscore *= kpoints

else :

kscore = sum ( Q )

print ( f"{ Q } retourne { kscore }." )

return kscore

LST_Points =  [ ( 4 , 8 , 2 ) , ( 3 , 7 , 8 ) , ( 9 , 7 ) , ( 1 , 5 , 4 , 7 ) , ( 4 , 5 , 7 ) ]

LST_Points.sort ( key = lambda kpoints : FNC_Test ( kpoints ) )

print ( LST_Points ) 

retourne

(4, 8, 2) retourne 14.

(3, 7, 8) retourne 18.

(9, 7) retourne 63.

(1, 5, 4, 7) retourne 16.

(4, 5, 7) retourne 16.

[(4, 8, 2), (1, 5, 4, 7), (4, 5, 7), (3, 7, 8), (9, 7)]