Apply suggestions from code review

Co-Authored-By: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com>
python · christopheNan · Sep 30, 2019 · Sep 16, 2019 · Sep 16, 2019 · Sep 16, 2019
commit b165290bffd381de30f5e37c520f86de68e29e9a
diff --git a/library/heapq.po b/library/heapq.po
@@ -40,10 +40,10 @@ msgid ""
 "elements are considered to be infinite.  The interesting property of a heap "
 "is that its smallest element is always the root, ``heap[0]``."
 msgstr ""
-"Les tas sont des arbres binaires pour lesquels chaque la valeur portée par "
+"Les tas sont des arbres binaires pour lesquels chaque valeur portée par "
 "un nœud est inférieure ou égale à celle de ses deux fils. Cette "
 "implémentation utilise des tableaux pour lesquels ``tas[k] <= tas[2*k+1]`` "
-"et ``tas[k] <= tas[2*k+2]`` pour tout *k*, en commençant la numération à "
+"et ``tas[k] <= tas[2*k+2]`` pour tout *k*, en commençant la numérotation à "
 "zéro.  Pour contenter l'opérateur de comparaison, les éléments inexistants "
 "sont considérés comme porteur d'une valeur infinie. L'intérêt du tas est que "
 "son plus petit élément est toujours la racine, ``tas[0]``."
@@ -62,9 +62,9 @@ msgstr ""
 "(a) L'indiçage commence à zéro. Cela complexifie légèrement la relation "
 "entre l'indice d'un nœud et les indices de ses fils mais est alignée avec "
 "l'indiçage commençant à zéro que Python utilise. (b) La méthode *pop* "
-"retourne le plus petit élément et non le plus grand (appelé « tas-min » dans "
-"manuels scolaires; le  « tas-max » étant généralement plus courant car il "
-"permet le tri en place)."
+"renvoie le plus petit élément et non le plus grand (appelé « tas-min » dans "
+"les manuels scolaires ; le  « tas-max » étant généralement plus courant dans la littérature car il "
+"permet le classement sans tampon)."
 
 #: ../Doc/library/heapq.rst:33
 msgid ""
@@ -81,8 +81,8 @@ msgid ""
 "To create a heap, use a list initialized to ``[]``, or you can transform a "
 "populated list into a heap via function :func:`heapify`."
 msgstr ""
-"Pour créer un tas, utilisez une liste initialisée à ``[]``, ou bien utilisez "
-"une liste existante en tas à l'aide de la fonction :func:`heapify`."
+"Pour créer un tas, utilisez une liste initialisée à ``[]`` ou bien utilisez "
+"une liste existante et transformez la en tas à l'aide de la fonction :func:`heapify`."
 
 #: ../Doc/library/heapq.rst:40
 msgid "The following functions are provided:"
@@ -100,7 +100,7 @@ msgid ""
 "invariant.  If the heap is empty, :exc:`IndexError` is raised.  To access "
 "the smallest item without popping it, use ``heap[0]``."
 msgstr ""
-"Défile le tas et retourne le plus élément de *heap* en préservant "
+"Extraie le plus petit élément de *heap* en préservant "
 "l'invariant du tas. Si le tas est vide, une exception :exc:`IndexError` est "
 "levée. Pour accéder au plus petit élément sans le retirer, utilisez "
 "``heap[0]``."
@@ -111,21 +111,21 @@ msgid ""
 "*heap*.  The combined action runs more efficiently than :func:`heappush` "
 "followed by a separate call to :func:`heappop`."
 msgstr ""
-"Tasse l'élément *item* sur le tas, puis défile et renvoie le plus élément de "
+"Introduit l'élément *item* dans le tas, puis extraie le plus petit élément de "
 "*heap*. Cette action combinée est plus efficace que :func:`heappush` suivie "
 "par un appel séparé à :func:`heappop`."
 
 #: ../Doc/library/heapq.rst:64
 msgid "Transform list *x* into a heap, in-place, in linear time."
-msgstr "Transforme une liste *x* en un tas, en place et en temps linéaire."
+msgstr "Transforme une liste *x* en un tas, sans utiliser de tampon et en temps linéaire."
 
 #: ../Doc/library/heapq.rst:69
 msgid ""
 "Pop and return the smallest item from the *heap*, and also push the new "
 "*item*. The heap size doesn't change. If the heap is empty, :exc:"
 "`IndexError` is raised."
 msgstr ""
-"Défile et renvoie le plus petit élément de *heap* et introduit le nouvel "
+"Extraie le plus petit élément de *heap* et introduit le nouvel "
 "élément *item*. La taille du tas ne change pas. Si le tas est vide, une "
 "exception :exc:`IndexError` est levée."
 
@@ -164,9 +164,9 @@ msgid ""
 "timestamped entries from multiple log files).  Returns an :term:`iterator` "
 "over the sorted values."
 msgstr ""
-"Fusionne plusieurs entrées triées en une unique sortie triée (par exemple, "
+"Fusionne plusieurs entrées ordonnées en une unique sortie ordonnée (par exemple, "
 "fusionne des entrées datées provenant de multiples journaux applicatifs). "
-"Renvoie un :term:`iterator` sur les valeurs triées."
+"Renvoie un :term:`iterator` sur les valeurs ordonnées."
 
 #: ../Doc/library/heapq.rst:92
 msgid ""
@@ -176,7 +176,7 @@ msgid ""
 msgstr ""
 "Similaire à ``sorted(itertools.chain(*iterables))`` mais renvoie un "
 "itérable, ne stocke pas toutes les données en mémoire en une fois et suppose "
-"que chaque flux d'entrée est déjà trié (en ordre croissant)."
+"que chaque flux d'entrée est déjà classé (en ordre croissant)."
 
 #: ../Doc/library/heapq.rst:96
 msgid ""
@@ -246,7 +246,7 @@ msgid ""
 "`max` functions.  If repeated usage of these functions is required, consider "
 "turning the iterable into an actual heap."
 msgstr ""
-"Les deux fonctions précédentes sont les plus efficaces pour des petits "
+"Les deux fonctions précédentes sont les plus efficaces pour des petites "
 "valeurs de *n*. Pour de grandes valeurs, il est préférable d'utiliser la "
 "fonction :func:`sorted`. En outre, lorsque ``n==1``, il est plus efficace "
 "d'utiliser les fonctions natives :func:`min` et :func:`max`. Si vous devez "
@@ -264,8 +264,8 @@ msgid ""
 "at a time::"
 msgstr ""
 "Un `tri par tas <https://fr.wikipedia.org/wiki/Tri_par_tas>`_ peut être "
-"implémenté en introduisant toutes les valeurs dans un tas puis en défilant "
-"les plus petits éléments un à la fois::"
+"implémenté en introduisant toutes les valeurs dans un tas puis en effectuant l'extraction "
+"des éléments un par un ::"
 
 #: ../Doc/library/heapq.rst:151
 msgid ""
@@ -280,7 +280,7 @@ msgid ""
 "Heap elements can be tuples.  This is useful for assigning comparison values "
 "(such as task priorities) alongside the main record being tracked::"
 msgstr ""
-"Les éléments d'un tas peuvent être des tuples. Ceci est pratique pour "
+"Les éléments d'un tas peuvent être des n-uplets. C'est pratique pour "
 "assigner des valeurs de comparaison (par exemple, des priorités de tâches) "
 "en plus de l'élément qui est suivi ::"
 
@@ -302,16 +302,16 @@ msgid ""
 "Sort stability:  how do you get two tasks with equal priorities to be "
 "returned in the order they were originally added?"
 msgstr ""
-"Stabilité du tri : comment s'assurer que deux tâches avec la même priorité "
+"Stabilité du classement : comment s'assurer que deux tâches avec la même priorité "
 "sont renvoyées dans l'ordre de leur ajout ?"
 
 #: ../Doc/library/heapq.rst:175
 msgid ""
 "Tuple comparison breaks for (priority, task) pairs if the priorities are "
 "equal and the tasks do not have a default comparison order."
 msgstr ""
-"La comparaison des tuples (priorité, tâche) échoue si les priorités sont "
-"identiques et que les tâches n'ont pas d'ordre de comparaison par défaut."
+"La comparaison des couples (priorité, tâche) échoue si les priorités sont "
+"identiques et que les tâches n'ont pas de relation d'ordre par défaut."
 
 #: ../Doc/library/heapq.rst:178
 msgid ""
@@ -342,7 +342,7 @@ msgstr ""
 "tâche. Le numéro d'ajout sert à briser les égalités de telle sorte que deux "
 "tâches avec la même priorité sont renvoyées dans l'ordre de leur insertion. "
 "Puisque deux tâches ne peuvent jamais avoir le même numéro d'ajout, la "
-"comparaison de tuples ne va jamais chercher à comparer des tâches entre "
+"comparaison des triplets ne va jamais chercher à comparer des tâches entre "
 "elles."
 
 #: ../Doc/library/heapq.rst:190
@@ -351,7 +351,7 @@ msgid ""
 "wrapper class that ignores the task item and only compares the priority "
 "field::"
 msgstr ""
-"Une autre solution au problème de non-comparabilité des tâches est de créer "
+"Une autre solution au fait que les tâches ne possèdent pas de relation d'ordre est de créer "
 "une classe d'encapsulation qui ignore l'élément tâche et ne compare que le "
 "champ priorité ::"
 
@@ -421,7 +421,7 @@ msgstr ""
 "ces tournois, nous n'avons pas besoin de produire l'historique du vainqueur. "
 "Afin d'occuper moins de mémoire, on remplace le vainqueur lors de sa "
 "promotion par un autre élément à un plus bas niveau. La règle devient alors "
-"qu'un nœud et les deux nœuds en-dessous lui contiennent trois éléments "
+"qu'un nœud et les deux nœuds qu'il chapeaute contiennent trois éléments "
 "différents, mais le nœud supérieur « gagne » contre les deux nœuds "
 "inférieurs."
 
@@ -436,13 +436,13 @@ msgid ""
 "items, you get an O(n log n) sort."
 msgstr ""
 "Si cet invariant de tas est vérifié à tout instant, alors l'élément à "
-"l'indice 0 est le vainqueur global. La façon algorithmique la plus simple de "
+"l'indice 0 est le vainqueur global. L'algorithme le plus simple de "
 "le retirer et de trouver le vainqueur « suivant » consiste à déplacer un "
 "perdant (par exemple le nœud 30 dans le diagramme ci-dessus) à la position "
 "0, puis à faire redescendre cette nouvelle racine dans l'arbre en échangeant "
 "sa valeur avec celle d'un de ses fils jusqu'à ce que l'invariant soit "
-"rétabli. Cette approche est logarithmique par rapport au nombre total "
-"d'éléments dans l'arbre. En itérant sur tous les éléments, le tri s'effectue "
+"rétabli. Cette approche a un coût logarithmique par rapport au nombre total "
+"d'éléments dans l'arbre. En itérant sur tous les éléments, le classement s'effectue "
 "en O(n log n) opérations."
 
 #: ../Doc/library/heapq.rst:275
@@ -456,9 +456,9 @@ msgid ""
 "easily go into the heap.  So, a heap is a good structure for implementing "
 "schedulers (this is what I used for my MIDI sequencer :-)."
 msgstr ""
-"Une propriété agréable de ce tri est qu'il possible d'insérer efficacement "
-"de nouveaux éléments en cours de tri, du moment que les éléments insérés ne "
-"sont pas « meilleurs » que le dernier élément 0 qui a été extrait. Ceci "
+"Une propriété agréable de cet algorithme est qu'il possible d'insérer efficacement "
+"de nouveaux éléments en cours de classement, du moment que les éléments insérés ne "
+"sont pas « meilleurs » que le dernier élément qui a été extrait. Ceci "
 "s'avère très utile dans des simulations où l'arbre contient la liste des "
 "événements arrivants et que la condition de « victoire » est le plus petit "
 "temps d'exécution planifié. Lorsqu'un événement programme l'exécution "
@@ -493,14 +493,14 @@ msgid ""
 "which are twice the size of the memory for random input, and much better for "
 "input fuzzily ordered."
 msgstr ""
-"Les tas sont également très utiles pour trier de gros disques. Vous savez "
-"probablement qu'un gros tri implique la production de séquences pré-triées "
+"Les tas sont également très utiles pour ordonner de gros disques. Vous savez "
+"probablement qu'un gros tri implique la production de séquences pré-classées "
 "(dont la taille est généralement liée à la quantité de mémoire CPU "
 "disponible), suivie par une passe de fusion qui est généralement organisée "
-"de façon très intelligente [#]_. Il est très important que le tri initial "
-"produise les séquences les plus possibles. Les tournois sont une bonne façon "
+"de façon très intelligente [#]_. Il est très important que le classement initial "
+"produise des séquences les plus longues possibles. Les tournois sont une bonne façon "
 "d'arriver à ce résultat. Si, en utilisant toute la mémoire disponible pour "
-"stocker un tournoi, vous replacez et faites percoler les éléments qui "
+"stocker un tournoi, vous remplacez et faites percoler les éléments qui "
 "s'avère acceptables pour la séquence courante, vous produirez des séquences "
 "d'une taille égale au double de la mémoire pour une entrée aléatoire et bien "
 "mieux pour une entrée approximativement triée."
@@ -549,10 +549,10 @@ msgid ""
 "Believe me, real good tape sorts were quite spectacular to watch! From all "
 "times, sorting has always been a Great Art! :-)"
 msgstr ""
-"Les algorithmes modernes de répartition de disque sont plus embêtants "
-"qu'intelligents en conséquence de la capacité des disques à réaliser des "
-"recherches avant. Sur les périphériques qui ne peuvent pas faire de "
-"recherche, comme les gros lecteurs à bandes, le besoin était différent et il "
+"Les algorithmes de répartition de charge pour les disques, courants de nos jours, sont plus embêtants "
+"qu'utiles, en raison de la capacité des disques à réaliser des "
+"accès aléatoires. Sur les périphériques qui ne peuvent faire que de la lecture séquentielle, "
+"comme les gros lecteurs à bandes, le besoin était différent et il "
 "fallait être malin pour s'assurer (bien à l'avance) que chaque mouvement de "
 "bande serait le plus efficace possible (c'est-à-dire participerait au mieux "
 "à l'« avancée » de la fusion). Certaines cassettes pouvaient même lire à "