Comment utiliser trié () et sort () dans Python – Real Python

By | mai 11, 2019

Expert Python

Tous les programmeurs devront écrire du code pour trier des éléments ou des données à un moment donné. Le tri peut être crucial pour l'expérience utilisateur dans votre application, qu'il s'agisse de la dernière activité d'un utilisateur par horodatage ou de placer une liste de destinataires dans un ordre alphabétique par nom de famille. La fonctionnalité de tri Python offre des fonctionnalités robustes pour le tri de base ou la personnalisation de la commande à un niveau granulaire.

Dans ce guide, vous apprendrez à trier divers types de données dans différentes structures de données, à personnaliser l’ordre et à utiliser deux méthodes de tri différentes en Python.

À la fin de ce tutoriel, vous saurez comment:

  • Implémentation du tri et du classement Python de base sur les structures de données
  • Différencier entre triés () et .Trier()
  • Personnaliser un ordre de tri complexe dans votre code en fonction d'exigences uniques

Pour ce tutoriel, vous aurez besoin d’une compréhension de base des listes et des tuples ainsi que des ensembles. Ces structures de données seront utilisées dans ce tutoriel et certaines opérations de base seront effectuées sur celles-ci. De plus, ce didacticiel utilise Python 3. Par conséquent, les exemples de résultats de ce didacticiel peuvent varier légèrement si vous utilisez Python 2.

Commande de valeurs avec triés ()

Pour débuter avec le tri Python, vous allez d'abord voir comment trier les données numériques et les données de chaîne.

Tri des numéros

Vous pouvez utiliser Python pour trier une liste en utilisant triés (). Dans cet exemple, une liste d’entiers est définie, puis triés () est appelé avec le Nombres variable comme argument:

>>>

>>> Nombres = [[[[6, 9, 3, 1]
>>> triés(Nombres)
[1, 3, 6, 9]
>>> Nombres
[6, 9, 3, 1]

La sortie de ce code est une nouvelle liste triée. Lorsque la variable d'origine est imprimée, les valeurs initiales restent inchangées.

Cet exemple montre quatre caractéristiques importantes de triés ():

  1. La fonction triés () n'a pas besoin d'être défini. C’est une fonction intégrée disponible dans une installation standard de Python.
  2. triés (), sans arguments ni paramètres supplémentaires, ordonne les valeurs dans Nombres dans un ordre croissant, signifiant le plus petit au plus grand.
  3. L'original Nombres la variable est inchangée car triés () fournit une sortie triée et ne modifie pas la valeur d'origine en place.
  4. Quand triés () est appelé, il fournit une liste ordonnée comme valeur de retour.

Ce dernier point signifie que triés () peut être utilisé sur une liste et la sortie peut immédiatement être affectée à une variable:

>>>

>>> Nombres = [[[[6, 9, 3, 1]
>>> numeros_sorted = triés(Nombres)
>>> numeros_sorted
[1, 3, 6, 9]
>>> Nombres
[6, 9, 3, 1]

Dans cet exemple, il y a maintenant une nouvelle variable numeros_sorted qui stockait la sortie de triés ().

Vous pouvez confirmer toutes ces observations en appelant Aidez-moi() sur triés (). Les arguments optionnels clé et sens inverse sera couvert plus tard dans le tutoriel:

>>>

>>> # Python 3
>>> Aidez-moi(triés)
Aide sur les fonctions intégrées triées dans les modules intégrés:

trié (itérable, /, *, clé = aucune, inversée = fausse)
                Retourne une nouvelle liste contenant tous les éléments de l'itérable par ordre croissant.

                Une fonction de touche personnalisée peut être fournie pour personnaliser l’ordre de tri et
                Le drapeau inversé peut être activé pour demander le résultat dans l'ordre décroissant.

triés () peut être utilisé sur des n-uplets et des ensembles très similaires:

>>>

>>> nombres_tuple = (6, 9, 3, 1)
>>> nombres_set = 5, 5, dix, 1, 0
>>> numbers_tuple_sorted = triés(nombres_tuple)
>>> numbers_set_sorted = triés(nombres_set)
>>> numbers_tuple_sorted
[1, 3, 6, 9]
>>> numbers_set_sorted
[0, 1, 5, 10]

Notez que même si l’entrée était un ensemble et un tuple, la sortie est une liste car triés () renvoie une nouvelle liste par définition. L'objet renvoyé peut être transtypé dans un nouveau type s'il doit correspondre au type d'entrée. Faites attention si vous essayez de remettre la liste résultante dans un ensemble, car un ensemble par définition n'est pas ordonné:

>>>

>>> nombres_tuple = (6, 9, 3, 1)
>>> nombres_set = 5, 5, dix, 1, 0
>>> numbers_tuple_sorted = triés(nombres_tuple)
>>> numbers_set_sorted = triés(nombres_set)
>>> numbers_tuple_sorted
[1, 3, 6, 9]
>>> numbers_set_sorted
[0, 1, 5, 10]
>>> tuple(numbers_tuple_sorted)
(1, 3, 6, 9)
>>> ensemble(numbers_set_sorted)
0, 1, 10, 5

le numbers_set_sorted valeur lors de la conversion en un ensemble n'est pas commandé, comme prévu. L'autre variable, numbers_tuple_sorted, a conservé l'ordre trié.

Tri des cordes

str les types sont similaires aux autres itérables, comme liste et tuple. L'exemple ci-dessous montre comment triés () itère à travers chaque caractère de la valeur qui lui est transmise et les ordonne dans la sortie:

>>>

>>> string_number_value = '34521'
>>> valeur de chaîne = 'J'aime trier'
>>> numéro_sordonné = triés(string_number_value)
>>> chaîne_triée = triés(valeur de chaîne)
>>> numéro_sordonné
['1', '2', '3', '4', '5']
>>> chaîne_triée
[' ', ' ', ' ', 'I', 'e', 'i', 'k', 'l', 'o', 'o', 'r', 's', 't', 't']

triés () traitera un str comme une liste et parcourir chaque élément. Dans un str, chaque élément signifie chaque caractère de la str. triés () ne traitera pas une phrase différemment et triera chaque caractère, espaces compris.

.Divisé() peut changer ce comportement et nettoyer la sortie, et .joindre() peut tout remettre en place. Nous couvrirons l'ordre spécifique de la sortie et pourquoi c'est ainsi sous peu:

>>>

>>> valeur de chaîne = 'J'aime trier'
>>> chaîne_triée = triés(valeur de chaîne.Divisé())
>>> chaîne_triée
['I', 'like', 'sort', 'to']
>>> ''.joindre(chaîne_triée)
'J'aime bien trier'

La phrase originale de cet exemple est convertie en une liste de mots au lieu de la laisser en tant que str. Cette liste est ensuite triée et combinée pour former un str encore au lieu d'une liste.

Limitations et pièges avec le tri Python

Il convient de noter certaines limitations et comportements étranges pouvant survenir lorsque vous utilisez Python pour trier des valeurs autres que des entiers.

Les listes avec des types de données non comparables ne peuvent pas être triés ()

Il existe des types de données qui ne peuvent pas être comparés les uns aux autres en utilisant simplement triés () parce qu'ils sont trop différents. Python renverra une erreur si vous essayez d'utiliser triés () sur une liste contenant des données non comparables. Dans cet exemple, un Aucun Et un int dans la même liste ne peuvent pas être triés en raison de leur incompatibilité:

>>>

>>> types_taxés = [[[[Aucun, 0]
>>> triés(types_taxés)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: '<' non pris en charge entre les instances de 'int' et 'NoneType'

Cette erreur montre pourquoi Python ne peut pas trier les valeurs qui lui sont attribuées. Il essaie de mettre les valeurs en ordre en utilisant l'opérateur less than (<) pour déterminer quelle valeur est inférieure dans l’ordre de tri. Vous pouvez répliquer cette erreur en comparant manuellement les deux valeurs:

>>>

>>> Aucun < 0
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: '<' non pris en charge entre les instances de 'NoneType' et 'int'

Le même Erreur-type est levé lorsque vous essayez de comparer deux valeurs non comparables sans utiliser triés ().

Si les valeurs dans la liste peuvent être comparées et ne jetteront pas un Erreur-type, alors la liste peut être triée. Cela évite de trier les valeurs itérables avec des valeurs intrinsèquement non ordonnables et de produire des résultats incohérents.

Par exemple, si le nombre 1 viens avant le mot Pomme? Cependant, si un itératif contient une combinaison d'entiers et de chaînes qui sont tous des nombres, ils peuvent être convertis en types de données comparables en utilisant une compréhension de liste:

>>>

>>> mixte_numéros = [[[[5, "1", 100, "34"]
>>> triés(mixte_numéros)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: '<' non pris en charge entre les instances de 'str' et 'int'
>>> # Liste compréhension pour convertir toutes les valeurs en nombres entiers
>>> [[[[int(X) pour X dans mixte_numéros]
[5, 1, 100, 34]
>>> triés([[[[int(X) pour X dans mixte_numéros])
[1, 5, 34, 100]

Chaque élément de mixte_numéros a int () appelé à convertir toute str valeurs à int valeurs. triés () est ensuite appelé et peut comparer avec succès chaque élément et fournir une sortie triée.

Python peut également convertir implicitement une valeur en un autre type. Dans l'exemple ci-dessous, l'évaluation de 1 <= 0 est une fausse déclaration, de sorte que le résultat de l'évaluation sera Faux. Le nombre 1 peut être converti en Vrai comme un bool tapez, tandis que 0 se convertit à Faux.

Bien que les éléments de la liste soient différents, ils peuvent tous être convertis en booléens (Vrai ou Faux) et comparés les uns aux autres en utilisant triés ():

>>>

>>> similar_values = [[[[Faux, 0, 1, 'UNE' == 'B', 1 <= 0]
>>> triés(similar_values)
[False, 0, False, False, 1]

'A' == 'B' et 1 <= 0 sont convertis en Faux et retourné dans la sortie ordonnée.

Cet exemple illustre un aspect important du tri: trier la stabilité. En Python, lorsque vous triez les valeurs égales, ils conservent leur ordre d'origine dans la sortie. Même si le 1 déplacées, toutes les autres valeurs sont égales pour conserver leur ordre d'origine les unes par rapport aux autres. Dans l'exemple ci-dessous, toutes les valeurs sont considérées comme égales et conserveront leur position d'origine:

>>>

>>> false_values = [[[[Faux, 0, 0, 1 == 2, 0, Faux, Faux]
>>> triés(false_values)
[False, 0, 0, False, 0, False, False]

Si vous inspectez la commande d'origine et la sortie triée, vous verrez que 1 == 2 est converti en Fauxet toutes les sorties triées sont dans l’ordre original.

Lorsque vous triez des chaînes, l’affaire est importante

triés () peut être utilisé sur une liste de chaînes pour trier les valeurs par ordre croissant, ce qui semble être l'alphabet par défaut:

>>>

>>> des noms = [[[["Harry", 'Suzy', 'Al', 'Marque']
>>> triés(des noms)
['Al', 'Harry', 'Mark', 'Suzy']

Cependant, Python utilise le point de code Unicode de la première lettre de chaque chaîne pour déterminer l'ordre de tri croissant. Cela signifie que triés () ne traitera pas les noms Al et Al le même. Cet exemple utilise ord () pour retourner le point de code Unicode de la première lettre de chaque chaîne:

>>>

>>> names_with_case = [[[['harry', 'Suzy', 'Al', 'Marque']
>>> triés(names_with_case)
['Mark', 'Suzy', 'al', 'harry']
>>> # Compréhension de liste pour le code Unicode Point de la première lettre de chaque mot
>>> [([([([(ord(prénom[[[[0]), prénom[[[[0]) pour prénom dans triés(names_with_case)]
[(77, 'M'), (83, 'S'), (97, 'a'), (104, 'h')]

prénom[0] renvoie le premier caractère de chaque élément de trié (name_with_case), et ord () fournit le point de code Unicode. Même si une vient avant M dans l'alphabet, le point de code pour M vient avant une, donc la sortie triée a M premier.

Si la première lettre est la même, alors triés () utilisera le deuxième caractère pour déterminer l'ordre et le troisième caractère s'il est identique, et ainsi de suite jusqu'à la fin de la chaîne:

>>>

>>> very_similar_strs = [[[['hhhhhd', 'hhhhha', 'hhhhhc','hhhhhb']
>>> triés(very_similar_strs)
['hhhhha', 'hhhhhb', 'hhhhhc', 'hhhhhd']

Chaque valeur de very_similar_strs est identique à l'exception du dernier caractère. triés () comparera les chaînes et, comme les cinq premiers caractères sont identiques, la sortie sera basée sur le sixième caractère.

Les chaînes contenant des valeurs identiques seront triées du plus court au plus long en raison du fait que les chaînes plus courtes n'ont pas d'éléments avec lesquels comparer les chaînes plus longues:

>>>

>>> longueurs_différentes = [[[['hhhh', 'hh', 'hhhhh','h']
>>> triés(longueurs_différentes)
['h', 'hh', 'hhhh', 'hhhhh']

La ficelle la plus courte, h, est commandé en premier avec le plus long, hhhhh, commandé en dernier.

En utilisant triés () Avec un sens inverse Argument

Comme le montre le Aidez-moi() documentation pour triés (), il existe un argument de mot-clé optionnel appelé sens inverse, qui modifiera le comportement de tri en fonction du booléen qui lui est attribué. Si sens inverse est assigné Vrai, alors le tri se fera par ordre décroissant:

>>>

>>> des noms = [[[["Harry", 'Suzy', 'Al', 'Marque']
>>> triés(des noms)
['Al', 'Harry', 'Mark', 'Suzy']
>>> triés(des noms, sens inverse=Vrai)
['Suzy', 'Mark', 'Harry', 'Al']

La logique de tri reste la même, ce qui signifie que les noms sont toujours triés par leur première lettre. Mais la sortie a été inversée avec le sens inverse mot clé défini sur Vrai.

Quand Faux est assigné, la commande restera ascendante. Tous les exemples précédents peuvent être utilisés pour voir le comportement de reverse en utilisant à la fois Vrai ou Faux:

>>>

>>> names_with_case = [[[['harry', 'Suzy', 'Al', 'Marque']
>>> triés(names_with_case, sens inverse=Vrai)
['harry', 'al', 'Suzy', 'Mark']
>>> similar_values = [[[[Faux, 1, 'UNE' == 'B', 1 <= 0]
>>> triés(similar_values, sens inverse=Vrai)
[1, False, False, False]
>>> Nombres = [[[[6, 9, 3, 1]
>>> triés(Nombres, sens inverse=Faux)
[1, 3, 6, 9]

triés () Avec un clé Argument

L’un des composants les plus puissants de triés () est l'argument mot clé appelé clé. Cet argument s'attend à ce qu'une fonction lui soit transmise et cette fonction sera utilisée pour chaque valeur de la liste en cours de tri afin de déterminer l'ordre résultant.

Pour illustrer un exemple de base, supposons que la commande d’une liste spécifique correspond à la longueur des chaînes de la liste, de la plus courte à la plus longue. La fonction pour retourner la longueur d'une chaîne, len (), sera utilisé avec le clé argument:

>>>

>>> mot = 'papier'
>>> len(mot)
5
>>> mots = [[[['banane', 'tarte', 'Washington', 'livre']
>>> triés(mots, clé=len)
['pie', 'book', 'banana', 'Washington']

L'ordre résultant est une liste avec un ordre de chaîne du plus court au plus long. La longueur de chaque élément de la liste est déterminée par len () et ensuite retourné dans l'ordre croissant.

Revenons au précédent exemple de tri par première lettre lorsque le cas est différent. clé peut être utilisé pour résoudre ce problème en convertissant la chaîne entière en minuscule:

>>>

>>> names_with_case = [[[['harry', 'Suzy', 'Al', 'Marque']
>>> triés(names_with_case)
['Mark', 'Suzy', 'al', 'harry']
>>> triés(names_with_case, clé=str.inférieur)
['al', 'harry', 'Mark', 'Suzy']

Les valeurs de sortie n'ont pas été converties en minuscules car clé ne manipule pas les données de la liste d'origine. Pendant le tri, la fonction passée à clé est appelé sur chaque élément pour déterminer l'ordre de tri, mais les valeurs d'origine seront dans la sortie.

Il y a deux limitations principales lorsque vous utilisez des fonctions avec le clé argument.

Tout d’abord, le nombre d’arguments requis dans la fonction passée à clé doit être un.

L'exemple ci-dessous montre la définition d'une fonction d'addition qui prend deux arguments. Lorsque cette fonction est utilisée dans clé sur une liste de nombres, il échoue car il manque un deuxième argument. Chaque fois ajouter() est appelé pendant le tri, il ne reçoit qu’un élément de la liste à la fois:

>>>

>>> def ajouter(X, y):
...     revenir X + y
... 
>>> valeurs_à_ajouter = [[[[1, 2, 3]
>>> triés(valeurs_à_ajouter, clé=ajouter)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
Erreur-type: add () manque 1 argument positionnel requis: 'y'

La deuxième limite est que la fonction utilisée avec clé doit être capable de gérer toutes les valeurs de l'itérable. Par exemple, vous avez une liste de nombres représentés sous forme de chaînes à utiliser dans triés (), et clé va essayer de les convertir en nombres en utilisant int. Si une valeur dans l'itérable ne peut pas être convertie en un entier, la fonction échouera:

>>>

>>> valeurs_à_diffuser = [[[['1', '2', '3', 'quatre']
>>> triés(valeurs_à_diffuser, clé=int)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
ValueError: Littéral invalide pour int () avec base 10: 'quatre'

Chaque valeur numérique en tant que str peut être converti en int, mais quatre peut pas. Cela provoque une ValueError être élevé et expliquer que quatre ne peut pas être converti en int parce que c'est invalide.

le clé la fonctionnalité est extrêmement puissante car presque toutes les fonctions, intégrées ou définies par l'utilisateur, peuvent être utilisées pour manipuler l'ordre de sortie.

Si l'exigence de commande consiste à ordonner une valeur itérable par la dernière lettre de chaque chaîne (et si la lettre est la même, utiliser la lettre suivante), une fonction peut alors être définie et utilisée dans le tri. L’exemple ci-dessous définit une fonction qui inverse la chaîne qui lui est transmise, puis cette fonction est utilisée comme argument de clé:

>>>

>>> def reverse_word(mot):
...     revenir mot[::[::[::[::-1]
...
>>> mots = [[[['banane', 'tarte', 'Washington', 'livre']
>>> triés(mots, clé=reverse_word)
['banana', 'pie', 'book', 'Washington']

le mot[::-1] La syntaxe slice est utilisée pour inverser une chaîne. Chaque élément aura reverse_word () appliquée, et l'ordre de tri sera basé sur les caractères du mot précédent.

Au lieu d’écrire une fonction autonome, vous pouvez utiliser un lambda fonction définie dans le clé argument.

UNE lambda est une fonction anonyme qui:

  1. Doit être défini en ligne
  2. N'a pas de nom
  3. Ne peut pas contenir de déclarations
  4. S'exécutera comme une fonction

Dans l'exemple ci-dessous, le clé est défini comme un lambda sans nom, l'argument pris par le lambda est X, et X[::-1] est l'opération qui sera effectuée sur l'argument:

>>>

>>> mots = [[[['banane', 'tarte', 'Washington', 'livre']
>>> triés(mots, clé=lambda X: X[::[::[::[::-1])
['banana', 'pie', 'book', 'Washington']

X[::-1] est appelé sur chaque élément et inverse le mot. Cette sortie inversée est ensuite utilisée pour le tri, mais les mots d'origine sont toujours renvoyés.

Si l'exigence change et que l'ordre doit également être inversé, alors le sens inverse le mot clé peut être utilisé à côté du clé argument:

>>>

>>> mots = [[[['banane', 'tarte', 'Washington', 'livre']
>>> triés(mots, clé=lambda X: X[::[::[::[::-1], sens inverse=Vrai)
['Washington', 'book', 'pie', 'banana']

lambda les fonctions sont également utiles lorsque vous devez trier classe objets basés sur une propriété. Si vous avez un groupe d’élèves et que vous devez les classer par ordre de note finale, décroissant, lambda peut être utilisé pour obtenir le qualité propriété de la classe:

>>>

>>> de collections importation nommétuple

>>> StudentFinal = nommétuple('StudentFinal', 'nom grade')
>>> facture = StudentFinal('Facture', 90)
>>> petit pâté = StudentFinal('Petit pâté', 94)
>>> bart = StudentFinal('Bart', 89)
>>> étudiants = [[[[facture, petit pâté, bart]
>>> triés(étudiants, clé=lambda X: getattr(X, 'qualité'), sens inverse=Vrai)
[StudentFinal(name='Patty', grade=94), StudentFinal(name='Bill', grade=90), StudentFinal(name='Bart', grade=89)]

Cet exemple utilise nommétuple produire des cours avec prénom et qualité les attributs. le lambda appels getattr () sur chaque élément et renvoie la valeur pour qualité.

sens inverse est réglé sur Vrai pour que la sortie ascendante soit retournée en descendant de sorte que les notes les plus élevées soient ordonnées en premier.

Les possibilités sont infinies quant à la façon dont la commande peut être effectuée lorsque vous exploitez à la fois le clé et sens inverse arguments de mot clé sur triés (). Le code peut être gardé propre et court lorsque vous utilisez une base lambda pour une petite fonction, ou vous pouvez écrire une nouvelle fonction, l'importer et l'utiliser dans l'argument clé.

Commande de valeurs avec .Trier()

Le très similaire nommé .Trier() diffère un peu de la triés () intégré Ils accomplissent plus ou moins la même chose, mais le Aidez-moi() documentation pour list.sort () met en évidence deux des différences les plus critiques entre .Trier() et triés ():

>>>

>>> # Python2
Aide sur method_descriptor:

Trier(...)
                L.sort (cmp = None, clé = None, reverse = False) - tri stable * IN PLACE *;
                cmp (x, y) -> -1, 0, 1

>>> # Python3
>>> Aidez-moi(liste.Trier)
Aide sur method_descriptor:

Trier(...)
                L.sort (clé = Aucun, inverse = Faux) -> Aucun - Tri stable * IN PLACE *

Tout d’abord, le tri est une méthode de liste classe et ne peut être utilisé qu'avec des listes. Ce n'est pas un construit avec un itérable qui lui est passé.

Seconde, .Trier() résultats Aucun et modifie les valeurs en place. Examinons l’impact de ces deux différences de code:

>>>

>>> valeurs_à_sortir = [[[[5, 2, 6, 1]
>>> # Essayez d’appeler .sort () comme trié ()
>>> Trier(valeurs_à_sortir)
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
NameError: le nom 'sort' n'est pas défini

>>> # Essayez d'utiliser .sort () sur un tuple
>>> tuple_val = (5, 1, 3, 5)
>>> tuple_val.Trier()
Traceback (dernier appel le plus récent):
  Fichier "", ligne 1, dans 
AttributeError: L'objet 'tuple' n'a pas d'attribut 'sort'

>>> # Trier la liste et attribuer à une nouvelle variable
>>> valeurs_classées = valeurs_à_sortir.Trier()
>>> impression(valeurs_classées)
Aucun

>>> # Imprimer la variable d'origine
>>> impression(valeurs_à_sortir)
[1, 2, 5, 6]

Il y a des différences assez dramatiques dans la façon dont .Trier() fonctionne par rapport à triés () dans cet exemple de code:

  1. Il n'y a pas de sortie ordonnée de .Trier(), donc l’affectation à une nouvelle variable ne fait que passer un Aucun type.
  2. le valeurs_à_sortir La liste a été modifiée sur place et la commande initiale n’est en aucun cas conservée.

Ces différences de comportement font .Trier() et triés () absolument pas interchangeables en code, et ils peuvent produire des résultats inattendus si l’on en utilise un de la mauvaise façon.

.Trier() a le même clé et sens inverse arguments de mot-clé facultatifs produisant la même fonctionnalité robuste que triés (). Ici, vous pouvez trier une liste de phrases par la deuxième lettre du troisième mot et renvoyer la liste en sens inverse:

>>>

>>> phrases = [[[['quand à Rome', 
...     'Plus ça change, plus c'est la même chose', 
...     'tout est juste dans l'amour et la guerre'
...     ]
>>> phrases.Trier(clé=lambda X: X.Divisé()[[[[2][[[[1], sens inverse=Vrai)
>>> phrases
['what goes around comes around', 'when in rome', 'all is fair in love and war']

Dans cet exemple, un lambda est utilisé pour faire ce qui suit:

  1. Diviser chaque phrase en une liste de mots
  2. Trouvez le troisième élément, ou le mot dans ce cas
  3. Trouvez la deuxième lettre dans ce mot

Quand utiliser triés () et quand utiliser .Trier()

Vous avez vu les différences entre triés () et .Trier(), mais quand utilisez-vous lequel?

Disons qu’une course de 5 km est à venir: le premier annuel 5k de Python. Les données de la course doivent être capturées et triées. Les données à saisir sont le numéro de dossard du coureur et le nombre de secondes qu'il a fallu pour terminer la course:

>>>

>>> de collections importation nommétuple

>>> Coureur = nommétuple('Coureur', 'durée du numéro de livre')

Lorsque les coureurs franchissent la ligne d'arrivée, chaque Coureur sera ajouté à une liste appelée coureurs. Dans les courses de 5 km, tous les coureurs ne franchissent pas la ligne de départ en même temps. La première personne à franchir la ligne d'arrivée risque donc de ne pas être la personne la plus rapide:

>>>

>>> coureurs = []
>>> coureurs.ajouter(Coureur('2528567', 1500))
>>> coureurs.ajouter(Coureur('7575234', 1420))
>>> coureurs.ajouter(Coureur('2666234', 1600))
>>> coureurs.ajouter(Coureur('2425234', 1490))
>>> coureurs.ajouter(Coureur('1235234', 1620))
>>> # Des milliers et des milliers d'entrées plus tard ...
>>> coureurs.ajouter(Coureur('2526674', 1906))

Chaque fois qu'un coureur franchit la ligne d'arrivée, son numéro de dossard et sa durée totale en secondes sont ajoutés à coureurs.

Maintenant, le programmeur consciencieux en charge de la gestion des données de résultats voit cette liste, il sait que les 5 premiers participants les plus rapides sont les gagnants des prix, et que les coureurs restants vont être classés par le temps le plus rapide.

Il n'y a pas d'exigences pour plusieurs types de tri selon divers attributs. La liste est de taille raisonnable. Il n'est pas question de stocker la liste quelque part. Il suffit de trier par durée et d'attraper les cinq participants avec la durée la plus basse:

>>>

>>> coureurs.Trier(clé=lambda X: getattr(X, 'durée'))
>>> top_five_runners = coureurs[:[:[:[:5]

Le programmeur choisit d'utiliser un lambda dans le clé argument pour obtenir le durée attribuer à chaque coureur et trier coureurs en place en utilisant .Trier(). Après coureurs est trié, les 5 premiers éléments sont stockés dans top_five_runners.

Mission accomplie! Le directeur de la course arrive et informe le programmeur que, puisque la version actuelle de Python est 3.7, ils ont décidé que chaque trente-septième personne ayant franchi la ligne d'arrivée recevrait un sac de sport gratuit.

À ce stade, le programmeur commence à transpirer car la liste des coureurs a été modifiée de manière irréversible. Il n’existe aucun moyen de récupérer la liste initiale des coureurs dans l’ordre dans lequel ils ont terminé et de retrouver toutes les trente-sept personnes.

Si vous travaillez avec des données importantes et qu’il est même possible que les données d’origine soient restaurées, .Trier() n'est pas la meilleure option. Si les données sont une copie, ou si ce sont des données de travail sans importance, ou si cela ne vous dérange pas de les perdre car elles peuvent être récupérées, alors .Trier() peut être une bonne option.

Alternativement, les coureurs auraient pu être triés en utilisant triés () et en utilisant le même lambda:

>>>

>>> runners_by_duration = triés(coureurs, clé=lambda X: getattr(X, 'durée'))
>>> top_five_runners = runners_by_duration[:[:[:[:5]

Dans ce scénario avec triés (), la liste originale des coureurs est toujours intacte et n’a pas été remplacée. La nécessité impromptue de trouver chaque trente-septième personne pour franchir la ligne d'arrivée peut être accomplie en interagissant avec les valeurs d'origine:

>>>

>>> tous_les_runners_eventures = coureurs[::[::[::[::37]

tous_les_runners_eventures est créé en utilisant une foulée dans la syntaxe de la liste slice sur coureurs, qui contient toujours l’ordre original dans lequel les coureurs ont franchi la ligne d’arrivée.

Comment trier en Python: Conclusion

.Trier() et triés () peut fournir exactement l'ordre de tri dont vous avez besoin si vous les utilisez correctement avec le sens inverse et clé arguments de mots clés optionnels.

Les deux ont des caractéristiques très différentes en ce qui concerne les modifications de sortie et en place, alors assurez-vous de penser à toute fonctionnalité d'application ou programme qui l'utilisera. .Trier() car il peut écraser irrévocablement les données.

Pour les pythonistes avides à la recherche d’un défi avec le tri, essayez d’utiliser des types de données plus complexes dans le tri: les iterables imbriqués. En outre, n'hésitez pas à plonger dans les implémentations de code Python open source pour les éléments intégrés et à en savoir plus sur l'algorithme de tri utilisé dans Python appelé Timsort.