Tutorial Datastructures Review.

2018-02-05 21:10:39 +01:00 · 2018-02-05 21:10:39 +01:00 · 4891ad70db
commit 4891ad70db
parent 4dd3e8fd0f
1 changed files with 122 additions and 122 deletions
--- a/tutorial/datastructures.po
+++ b/tutorial/datastructures.po
@ -8,14 +8,14 @@ msgstr ""
 "Project-Id-Version: Python 3.6\n" 
 "Report-Msgid-Bugs-To: \n" 
 "POT-Creation-Date: 2017-05-27 19:40+0200\n" 
-"PO-Revision-Date: 2017-10-27 17:34+0200\n" 
+"PO-Revision-Date: 2018-02-03 16:14+0100\n" 
 "Last-Translator: Julien Palard <julien@palard.fr>\n" 
 "Language-Team: \n" 
 "Language: fr\n" 
 "MIME-Version: 1.0\n" 
 "Content-Type: text/plain; charset=UTF-8\n" 
 "Content-Transfer-Encoding: 8bit\n" 
-"X-Generator: Poedit 2.0.4\n" 
+"X-Generator: Poedit 2.0.2\n" 
  
 #: ../Doc/tutorial/datastructures.rst:5 
 msgid "Data Structures" 
@ -26,7 +26,7 @@ msgid ""
 "This chapter describes some things you've learned about already in more " 
 "detail, and adds some new things as well." 
 msgstr "" 
-"Ce chapitre reprend plus en détail quelques point déjà décrits précédemment, " 
+"Ce chapitre reprend plus en détail quelques points déjà décrits précédemment " 
 "et introduit également de nouvelles notions." 
  
 #: ../Doc/tutorial/datastructures.rst:13 
@ -38,14 +38,14 @@ msgid ""
 "The list data type has some more methods. Here are all of the methods of " 
 "list objects:" 
 msgstr "" 
-"Le type liste dispose de méthodes supplémentaires. Voici la liste complète " 
-"des méthodes des objets de type liste :" 
+"Le type liste dispose de méthodes supplémentaires. Voici toutes les méthodes " 
+"des objets de type liste :" 
  
 #: ../Doc/tutorial/datastructures.rst:22 
 msgid "" 
 "Add an item to the end of the list. Equivalent to ``a[len(a):] = [x]``." 
 msgstr "" 
-"Ajoute un élément à la fin de la liste. Equivalent à ``a[len(a):] = [x]``." 
+"Ajoute un élément à la fin de la liste. Équivalent à ``a[len(a):] = [x]``." 
  
 #: ../Doc/tutorial/datastructures.rst:28 
 msgid "" 
@ -63,16 +63,16 @@ msgid ""
 msgstr "" 
 "Insère un élément à la position indiquée. Le premier argument est la " 
 "position de l'élément courant avant lequel l'insertion doit s'effectuer, " 
-"donc ``a.insert(0, x)`` insère l'élément en tête de la liste, et ``a." 
+"donc ``a.insert(0, x)`` insère l'élément en tête de la liste et ``a." 
 "insert(len(a), x)`` est équivalent à ``a.append(x)``." 
  
 #: ../Doc/tutorial/datastructures.rst:43 
 msgid "" 
-"Remove the first item from the list whose value is *x*. It is an error if " 
-"there is no such item." 
+"Remove the first item from the list whose value is equal to *x*. It is an " 
+"error if there is no such item." 
 msgstr "" 
-"Supprime de la liste le premier élément dont la valeur est *x*. Une " 
-"exception est levée s'il existe aucun élément avec cette valeur." 
+"Supprime de la liste le premier élément dont la valeur est égale à *x*. Une " 
+"exception est levée s'il n'existe aucun élément avec cette valeur." 
  
 #: ../Doc/tutorial/datastructures.rst:50 
 msgid "" 
@ -83,25 +83,24 @@ msgid ""
 "that position. You will see this notation frequently in the Python Library " 
 "Reference.)" 
 msgstr "" 
-"Enlève de la liste l'élément situé à la position indiquée, et le renvoie en " 
-"valeur de retour. Si aucune position n'est indiqué, ``a.pop()`` enlève et " 
+"Enlève de la liste l'élément situé à la position indiquée et le renvoie en " 
+"valeur de retour. Si aucune position n'est spécifiée, ``a.pop()`` enlève et " 
 "renvoie le dernier élément de la liste (les crochets autour du *i* dans la " 
-"signature de la méthode indiquent bien que ce paramètre est facultatif, et " 
-"non que vous devez placer des crochets dans votre code ! Vous retrouverez " 
-"cette notation fréquemment dans le Guide de Référence de la Bibliothèque " 
-"Python)." 
+"signature de la méthode indiquent que ce paramètre est facultatif et non que " 
+"vous devez placer des crochets dans votre code ! Vous retrouverez cette " 
+"notation fréquemment dans le Guide de Référence de la Bibliothèque Python)." 
  
 #: ../Doc/tutorial/datastructures.rst:60 
 msgid "Remove all items from the list. Equivalent to ``del a[:]``." 
-msgstr "Supprime tous les éléments de la liste, équivalent à ``del a[:]``." 
+msgstr "Supprime tous les éléments de la liste. Équivalent à ``del a[:]``." 
  
 #: ../Doc/tutorial/datastructures.rst:66 
 msgid "" 
-"Return zero-based index in the list of the first item whose value is *x*. " 
-"Raises a :exc:`ValueError` if there is no such item." 
+"Return zero-based index in the list of the first item whose value is equal " 
+"to *x*. Raises a :exc:`ValueError` if there is no such item." 
 msgstr "" 
-"Renvoie la position du premier élément de la liste ayant la valeur *x* (en " 
-"commençant par zéro). Une exception :exc:`ValueError` est levée si aucun " 
+"Renvoie la position du premier élément de la liste dont la valeur égale *x* " 
+"(en commençant par zéro). Une exception :exc:`ValueError` est levée si aucun " 
 "élément n'est trouvé." 
  
 #: ../Doc/tutorial/datastructures.rst:69 
@ -112,9 +111,9 @@ msgid ""
 "sequence rather than the *start* argument." 
 msgstr "" 
 "Les arguments optionnels *start* et *end* sont interprétés de la même " 
-"manière que dans la notation des tranches, et sont utilisés pour limiter la " 
+"manière que dans la notation des tranches et sont utilisés pour limiter la " 
 "recherche à une sous-séquence particulière. L'index renvoyé est calculé " 
-"relativement au début de la séquence complète, et non relativement à *start*." 
+"relativement au début de la séquence complète et non relativement à *start*." 
  
 #: ../Doc/tutorial/datastructures.rst:78 
 msgid "Return the number of times *x* appears in the list." 
@ -125,8 +124,8 @@ msgid ""
 "Sort the items of the list in place (the arguments can be used for sort " 
 "customization, see :func:`sorted` for their explanation)." 
 msgstr "" 
-"Trie les éléments sur place, (les arguments peuvent personaliser le tri, " 
-"voir :func:`sorted` pour leur explication)." 
+"Classe les éléments sur place (les arguments peuvent personnaliser le " 
+"classement, voir :func:`sorted` pour leur explication)." 
  
 #: ../Doc/tutorial/datastructures.rst:91 
 msgid "Reverse the elements of the list in place." 
@ -147,14 +146,14 @@ msgid ""
 "default ``None``. [1]_ This is a design principle for all mutable data " 
 "structures in Python." 
 msgstr "" 
-"Vous avez probablement remarqué que les méthodes tel que ``insert``, " 
-"``remove`` ou ``sort``, qui ne font que modifier la liste, ne renvoient pas " 
-"de valeur mais ``None``. [1]_ C'est un principe respecté par toutes les " 
-"structures de données variables en Python." 
+"Vous avez probablement remarqué que les méthodes telles que ``insert``, " 
+"``remove`` ou ``sort``, qui ne font que modifier la liste, n'affichent pas " 
+"de valeur de retour (elles renvoient ``None``) [1]_. C'est un principe " 
+"respecté par toutes les structures de données variables en Python." 
  
 #: ../Doc/tutorial/datastructures.rst:132 
 msgid "Using Lists as Stacks" 
-msgstr "Utiliser les listes comme des piles" 
+msgstr "Utilisation des listes comme des piles" 
  
 #: ../Doc/tutorial/datastructures.rst:137 
 msgid "" 
@ -166,14 +165,14 @@ msgid ""
 msgstr "" 
 "Les méthodes des listes rendent très facile leur utilisation comme des " 
 "piles, où le dernier élément ajouté est le premier récupéré (\"dernier " 
-"entré, premier sorti\", ou LIFO pour \"last-in, first-out\"). Pour ajouter " 
-"un élément sur la pile, utilisez la méthode :meth:`append`. Pour récupérer " 
-"l'objet au sommet de la pile, utilisez la méthode :meth:`pop`, sans " 
+"entré, premier sorti\" ou LIFO pour \"last-in, first-out\" en anglais). Pour " 
+"ajouter un élément sur la pile, utilisez la méthode :meth:`append`. Pour " 
+"récupérer l'objet au sommet de la pile, utilisez la méthode :meth:`pop` sans " 
 "indicateur de position. Par exemple : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:162 
 msgid "Using Lists as Queues" 
-msgstr "Utiliser les listes comme des files" 
+msgstr "Utilisation des listes comme des files" 
  
 #: ../Doc/tutorial/datastructures.rst:166 
 msgid "" 
@ -184,21 +183,21 @@ msgid ""
 "(because all of the other elements have to be shifted by one)." 
 msgstr "" 
 "Il est également possible d'utiliser une liste comme une file, où le premier " 
-"élément ajouté est le premier récupéré (\"premier entré, premier sorti\", ou " 
-"FIFO pour \"first-in, first-out\") ; touefois, les listes ne sont pas très " 
-"efficaces pour ce type de traitement. Alors que les ajouts et suppressions " 
-"en fin de liste sont rapides, les opérations d'insertions ou de retraits en " 
-"début de liste sont lentes (car tous les autres éléments doivent être " 
-"décalés d'une position)." 
+"élément ajouté est le premier récupéré (\"premier entré, premier sorti\" ou " 
+"FIFO pour \"first-in, first-out\") ; toutefois, les listes ne sont pas très " 
+"efficaces pour réaliser ce type de traitement. Alors que les ajouts et " 
+"suppressions en fin de liste sont rapides, les opérations d'insertions ou de " 
+"retraits en début de liste sont lentes (car tous les autres éléments doivent " 
+"être décalés d'une position)." 
  
 #: ../Doc/tutorial/datastructures.rst:172 
 msgid "" 
 "To implement a queue, use :class:`collections.deque` which was designed to " 
 "have fast appends and pops from both ends. For example::" 
 msgstr "" 
-"Pour implémenter une file, utilisez donc la classe :class:`collections." 
-"deque` qui a été conçue pour fournir des opérations d'ajouts et de retraits " 
-"rapides aux deux extrémités. Par exemple : ::" 
+"Pour implémenter une file, utilisez la classe :class:`collections.deque` qui " 
+"a été conçue pour réaliser rapidement les opérations d'ajouts et de retraits " 
+"aux deux extrémités. Par exemple : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:190 
 msgid "List Comprehensions" 
@ -212,9 +211,9 @@ msgid ""
 "create a subsequence of those elements that satisfy a certain condition." 
 msgstr "" 
 "Les compréhensions de listes fournissent un moyen de construire des listes " 
-"de manière très concice. Une application classique est la construction de " 
+"de manière très concise. Une application classique est la construction de " 
 "nouvelles listes où chaque élément est le résultat d'une opération appliquée " 
-"à chaque élément d'une autre séquence, ou de créer une sous-séquence des " 
+"à chaque élément d'une autre séquence ; ou de créer une sous-séquence des " 
 "éléments satisfaisant une condition spécifique." 
  
 #: ../Doc/tutorial/datastructures.rst:197 
@ -228,13 +227,13 @@ msgid ""
 "exists after the loop completes. We can calculate the list of squares " 
 "without any side effects using::" 
 msgstr "" 
-"Notez que cela créé (ou écrase) une variable nommée ``x`` qui existe " 
+"Notez que cela crée (ou remplace) une variable nommée ``x`` qui existe " 
 "toujours après l'exécution de la boucle. On peut calculer une liste de " 
-"carrés sans effet de bord, avec : ::" 
+"carrés sans effet de bord avec : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:212 
 msgid "or, equivalently::" 
-msgstr "ou : ::" 
+msgstr "ou, de manière équivalente : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:216 
 msgid "which is more concise and readable." 
@ -249,16 +248,16 @@ msgid ""
 "which follow it. For example, this listcomp combines the elements of two " 
 "lists if they are not equal::" 
 msgstr "" 
-"Une compréhension de liste consiste en crochets contenant une expression " 
-"suivie par une clause :keyword:`for`, puis par zéro ou plus clauses :keyword:" 
-"`for` ou :keyword:`if`. Le résultat sera une nouvelle liste résultat de " 
+"Une compréhension de liste consiste à placer entre crochets une expression " 
+"suivie par une clause :keyword:`for` puis par zéro ou plus clauses :keyword:" 
+"`for` ou :keyword:`if`. Le résultat est une nouvelle liste résultat de " 
 "l'évaluation de l'expression dans le contexte des clauses :keyword:`for` et :" 
 "keyword:`if` qui la suivent. Par exemple, cette compréhension de liste " 
 "combine les éléments de deux listes s'ils ne sont pas égaux : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:228 
 msgid "and it's equivalent to::" 
-msgstr "et c'est équivaent à : ::" 
+msgstr "et c'est équivalent à : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:239 
 msgid "" 
@ -273,7 +272,7 @@ msgid ""
 "If the expression is a tuple (e.g. the ``(x, y)`` in the previous example), " 
 "it must be parenthesized. ::" 
 msgstr "" 
-"Si l'expression est un tuple (c'est à dire ``(x, y)`` dans cet exemple), " 
+"Si l'expression est un tuple (c'est-à-dire ``(x, y)`` dans cet exemple), " 
 "elle doit être entourée par des parenthèses : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:273 
@ -305,8 +304,7 @@ msgstr ""
  
 #: ../Doc/tutorial/datastructures.rst:294 
 msgid "The following list comprehension will transpose rows and columns::" 
-msgstr "" 
-"Cette compréhension de liste va transposer les lignes et les colonnes : ::" 
+msgstr "Cette compréhension de liste transpose les lignes et les colonnes : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:299 
 msgid "" 
@ -314,13 +312,13 @@ msgid ""
 "context of the :keyword:`for` that follows it, so this example is equivalent " 
 "to::" 
 msgstr "" 
-"Comme on l'a vu dans la section précédente, la compréhension de liste " 
+"Comme nous l'avons vu dans la section précédente, la compréhension de liste " 
 "imbriquée est évaluée dans le contexte de l'instruction :keyword:`for` qui " 
 "la suit, donc cet exemple est équivalent à : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:310 
 msgid "which, in turn, is the same as::" 
-msgstr "lequel à son tour est équivalent à : ::" 
+msgstr "Lequel à son tour est équivalent à : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:323 
 msgid "" 
@ -335,7 +333,8 @@ msgstr ""
 msgid "" 
 "See :ref:`tut-unpacking-arguments` for details on the asterisk in this line." 
 msgstr "" 
-"Voyez :ref:`tut-unpacking-arguments` pour plus de détails sur cette ligne." 
+"Voyez :ref:`tut-unpacking-arguments` pour plus de détails sur l'astérisque " 
+"de cette ligne." 
  
 #: ../Doc/tutorial/datastructures.rst:334 
 msgid "The :keyword:`del` statement" 
@ -353,7 +352,7 @@ msgstr ""
 "au lieu de sa valeur : l'instruction :keyword:`del`. Elle diffère de la " 
 "méthode :meth:`pop` qui, elle, renvoie une valeur. L'instruction :keyword:" 
 "`del` peut également être utilisée pour supprimer des tranches d'une liste " 
-"ou la vider complètement (ce que nous avions fait auparavent en affectant " 
+"ou la vider complètement (ce que nous avions fait auparavant en affectant " 
 "une liste vide à la tranche). Par exemple : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:353 
@ -405,13 +404,13 @@ msgid ""
 "the individual items of a tuple, however it is possible to create tuples " 
 "which contain mutable objects, such as lists." 
 msgstr "" 
-"Comme vous pouvez le voir, à l'affichage les tuples sont toujours encadrés " 
-"par des parenthèses, de façon à ce que des tuples imbriqués soient " 
-"interprétés correctement ; ils peuvent être entrés avec ou sans parenthèses, " 
-"même si celles-ci sont souvent nécessaires (notamment lorsqu'un tuple fait " 
-"partie d'une expression plus longue). Il n'est pas possible d'affecter de " 
-"valeur à un élément d'un tuple ; par contre, il est possible de créer des " 
-"tuples contenant des objets muables, comme des listes." 
+"Comme vous pouvez le voir, les tuples sont toujours affichés entre " 
+"parenthèses, de façon à ce que des tuples imbriqués soient interprétés " 
+"correctement ; ils peuvent être entrés avec ou sans parenthèses, même si " 
+"celles-ci sont souvent nécessaires (notamment lorsqu'un tuple fait partie " 
+"d'une expression plus longue). Il n'est pas possible d'affecter de valeur à " 
+"un élément d'un tuple ; par contre, il est possible de créer des tuples " 
+"contenant des objets muables, comme des listes." 
  
 #: ../Doc/tutorial/datastructures.rst:401 
 msgid "" 
@ -428,7 +427,7 @@ msgstr ""
 "sont :term:`immuable`\\s et contiennent souvent des séquences hétérogènes " 
 "d'éléments qui sont accédés par \"déballage\" (voir plus loin) ou indexation " 
 "(ou même par attributs dans le cas des :func:`namedtuples <collections." 
-"namedtuple>`). Les listes sont souvent :term:`muable <muable>`, et " 
+"namedtuple>`). Les listes sont souvent :term:`muable <muable>` et " 
 "contiennent des éléments homogènes qui sont accédés par itération sur la " 
 "liste." 
  
@ -442,7 +441,7 @@ msgid ""
 msgstr "" 
 "Un problème spécifique est la construction de tuples ne contenant aucun ou " 
 "un seul élément : la syntaxe a quelques tournures spécifiques pour s'en " 
-"accomoder. Les tuples vides sont construits par une paire de parenthèses " 
+"accommoder. Les tuples vides sont construits par une paire de parenthèses " 
 "vides ; un tuple avec un seul élément est construit en faisant suivre la " 
 "valeur par une virgule (il n'est pas suffisant de placer cette valeur entre " 
 "parenthèses). Pas très joli, mais efficace. Par exemple : ::" 
@ -466,15 +465,15 @@ msgid ""
 "of tuple packing and sequence unpacking." 
 msgstr "" 
 "Ceci est appelé, de façon plus ou moins appropriée, un *déballage de " 
-"séquence* et fonctionne pour toute séquence placée à droite de l'expression. " 
-"Ce déballage requiert autant de variables dans la partie gauche qu'il y a " 
-"d'éléments dans la séquence. Notez également que cette affectation multiple " 
-"est juste une combinaison entre un emballage de tuple et un déballage de " 
-"séquence." 
+"séquence* (*sequence unpacking* en anglais) et fonctionne pour toute " 
+"séquence placée à droite de l'expression. Ce déballage requiert autant de " 
+"variables dans la partie gauche qu'il y a d'éléments dans la séquence. Notez " 
+"également que cette affectation multiple est juste une combinaison entre un " 
+"emballage de tuple et un déballage de séquence." 
  
 #: ../Doc/tutorial/datastructures.rst:440 
 msgid "Sets" 
-msgstr "Les ensembles" 
+msgstr "Ensembles" 
  
 #: ../Doc/tutorial/datastructures.rst:442 
 msgid "" 
@ -486,9 +485,10 @@ msgid ""
 msgstr "" 
 "Python fournit également un type de donnée pour les *ensembles*. Un ensemble " 
 "est une collection non ordonnée sans élément dupliqué. Des utilisations " 
-"basiques concernent par exemple des tests d'appartenance ou des suppressons " 
-"de doublons. Les ensembles supportent également les opérations mathématiques " 
-"comme les unions, intersections, différences et différences symétriques." 
+"basiques concernent par exemple des tests d'appartenance ou des suppressions " 
+"de doublons. Les ensembles savent également effectuer les opérations " 
+"mathématiques telles que les unions, intersections, différences et " 
+"différences symétriques." 
  
 #: ../Doc/tutorial/datastructures.rst:447 
 msgid "" 
@ -497,9 +497,9 @@ msgid ""
 "creates an empty dictionary, a data structure that we discuss in the next " 
 "section." 
 msgstr "" 
-"Des accolades, ou la fonction :func:`set` peuvent être utilisés pour créer " 
+"Des accolades ou la fonction :func:`set` peuvent être utilisés pour créer " 
 "des ensembles. Notez que pour créer un ensemble vide, ``{}`` ne " 
-"fonctionne pas, cela créé un dictionnaire vide. Utilisez plutôt ``set()``." 
+"fonctionne pas, cela crée un dictionnaire vide. Utilisez plutôt ``set()``." 
  
 #: ../Doc/tutorial/datastructures.rst:451 
 msgid "Here is a brief demonstration::" 
@ -510,8 +510,8 @@ msgid ""
 "Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions " 
 "are also supported::" 
 msgstr "" 
-"Tout comme les :ref:`comprehensions de listes <tut-listcomps>`, il est " 
-"possibled'écrire des comprehensions d'ensembles : ::" 
+"Tout comme pour les :ref:`compréhensions de listes <tut-listcomps>`, il est " 
+"possible d'écrire des compréhensions d'ensembles : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:487 
 msgid "Dictionaries" 
@ -559,7 +559,7 @@ msgstr ""
 "Placer une liste de paires clé:valeur séparées par des virgules à " 
 "l'intérieur des accolades ajoute les valeurs correspondantes au " 
 "dictionnaire ; c'est également de cette façon que les dictionnaires sont " 
-"affichés en sortie." 
+"affichés." 
  
 #: ../Doc/tutorial/datastructures.rst:506 
 msgid "" 
@ -569,12 +569,12 @@ msgid ""
 "the old value associated with that key is forgotten. It is an error to " 
 "extract a value using a non-existent key." 
 msgstr "" 
-"Les principales opérations effectuées sur un dictionnaire consistent à " 
-"stocker une valeur pour une clé et à extraire la valeur correspondant à une " 
-"clé. Il est également possible de supprimer une paire clé:valeur avec " 
-"``del``. Si vous stockez une valeur pour une clé qui est déjà utilisée, " 
-"l'ancienne valeur associée à cette clé est perdue. Si vous tentez d'extraire " 
-"une valeur associée à une clé qui n'existe pas, une exception est levée." 
+"Les opérations classiques sur un dictionnaire consistent à stocker une " 
+"valeur pour une clé et à extraire la valeur correspondant à une clé. Il est " 
+"également possible de supprimer une paire clé:valeur avec ``del``. Si vous " 
+"stockez une valeur pour une clé qui est déjà utilisée, l'ancienne valeur " 
+"associée à cette clé est perdue. Si vous tentez d'extraire une valeur " 
+"associée à une clé qui n'existe pas, une exception est levée." 
  
 #: ../Doc/tutorial/datastructures.rst:512 
 msgid "" 
@ -584,8 +584,8 @@ msgid ""
 "dictionary, use the :keyword:`in` keyword." 
 msgstr "" 
 "Exécuter ``list(d.keys())`` sur un dictionnaire ``d`` renvoie une liste de " 
-"toutes lesclés utilisées dans le dictionnaire, dans un ordre arbitraire (si " 
-"vous voulez qu'elles soient triées, utilisez ``sorted(d.keys())``). [2]_ " 
+"toutes les clés utilisées dans le dictionnaire, dans un ordre arbitraire (si " 
+"vous voulez qu'elles soient classées, utilisez ``sorted(d.keys())``) [2]_. " 
 "Pour tester si une clé est dans le dictionnaire, utilisez le mot-clé :" 
 "keyword:`in`." 
  
@ -652,25 +652,26 @@ msgid ""
 "To loop over a sequence in reverse, first specify the sequence in a forward " 
 "direction and then call the :func:`reversed` function. ::" 
 msgstr "" 
-"Pour faire une boucle sur une séquence inversée, commencez par créer la " 
-"séquence dans son ordre normal, puis appliquez la fonction :func:" 
-"`reversed` ::" 
+"Pour faire une boucle en sens inverse sur une séquence, commencez par " 
+"spécifier la séquence dans son ordre normal, puis appliquez la fonction :" 
+"func:`reversed` ::" 
  
 #: ../Doc/tutorial/datastructures.rst:606 
 msgid "" 
 "To loop over a sequence in sorted order, use the :func:`sorted` function " 
 "which returns a new sorted list while leaving the source unaltered. ::" 
 msgstr "" 
-"Pour faire une boucle sur une séquence triée, utilisez la fonction :func:" 
-"`sorted`, qui renvoie une nouvelle liste triée sans altérer la source : ::" 
+"Pour faire une boucle selon un certain classement sur une séquence, utilisez " 
+"la fonction :func:`sorted`, elle renvoie une nouvelle liste classée sans " 
+"altérer la source : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:618 
 msgid "" 
 "It is sometimes tempting to change a list while you are looping over it; " 
 "however, it is often simpler and safer to create a new list instead. ::" 
 msgstr "" 
-"Il est parfois tentant de changer une liste pendant son itération, " 
-"cependant, c'est souvent plus simple et plus sûr de créer une nouvelle liste " 
+"Il est parfois tentant de modifier une liste pendant son itération. " 
+"Cependant, c'est souvent plus simple et plus sûr de créer une nouvelle liste " 
 "à la place. ::" 
  
 #: ../Doc/tutorial/datastructures.rst:635 
@ -705,9 +706,8 @@ msgid ""
 "Comparisons can be chained. For example, ``a < b == c`` tests whether ``a`` " 
 "is less than ``b`` and moreover ``b`` equals ``c``." 
 msgstr "" 
-"Les comparaison peuvent être enchaînées. Par exemple, ``a < b == c`` teste " 
-"si ``a`` est inférieur ou égal à ``b`` et par ailleurs si ``b`` est égal à " 
-"``c``." 
+"Les comparaisons peuvent être enchaînées. Par exemple, ``a < b == c`` teste " 
+"si ``a`` est inférieur ou égal à ``b`` et si, de plus, ``b`` égale ``c``." 
  
 #: ../Doc/tutorial/datastructures.rst:649 
 msgid "" 
@ -737,8 +737,8 @@ msgid ""
 "return value of a short-circuit operator is the last evaluated argument." 
 msgstr "" 
 "Les opérateurs booléens ``and`` et ``or`` sont appelés opérateurs *en " 
-"circuit court* : leurs arguments sont évalués de la gauche vers la droite, " 
-"et l'évaluation s'arrête dès que le résultat est déterminé. Par exemple, si " 
+"circuit court* : leurs arguments sont évalués de la gauche vers la droite et " 
+"l'évaluation s'arrête dès que le résultat est déterminé. Par exemple, si " 
 "``A`` et ``C`` sont vrais et ``B`` est faux, ``A and B and C`` n'évalue pas " 
 "l'expression ``C``. Lorsqu'elle est utilisée en tant que valeur et non en " 
 "tant que booléen, la valeur de retour d'un opérateur en circuit court est " 
@ -762,8 +762,8 @@ msgstr ""
 "Notez qu'en Python, à la différence du C, des affectations ne peuvent pas " 
 "intervenir à l'intérieur d'expressions. Les programmeurs C râleront peut-" 
 "être après cela, mais cela évite des erreurs fréquentes que l'on rencontre " 
-"en C, lorsque l'expression ``=`` est placée alors qu'une expression ``==`` " 
-"était attendue." 
+"en C, lorsque l'on tape ``=`` alors que l'on voulait faire un test avec " 
+"``==``." 
  
 #: ../Doc/tutorial/datastructures.rst:680 
 msgid "Comparing Sequences and Other Types" 
@ -786,17 +786,17 @@ msgid ""
 msgstr "" 
 "Des séquences peuvent être comparées avec d'autres séquences du même type. " 
 "La comparaison utilise un ordre *lexicographique* : les deux premiers " 
-"éléments de chaque séquence sont comparés, et s'ils diffèrent cela détermine " 
-"le résultat de la comparaison ; s'ils sont égaux, les deux éléments suivants " 
-"sont comparés à leur tour, et ainsi de suite jusqu'à ce que l'une des " 
-"séquences soit épuisée. Si deux éléments à comparer sont eux-mêmes des " 
-"séquences du même type, alors la comparaison lexicographique est effectuée " 
-"récursivement. Si tous les éléments des deux séquences sont égaux, les deux " 
-"séquences sont alors considérées comme égales. Si une séquence est une sous-" 
-"séquence de l'autre, la séquence la plus courte est celle dont la valeur est " 
-"inférieure. La comparaison lexicographique des chaînes de caractères utilise " 
-"le code Unicode des caractères. Voici quelques exemples de comparaisons " 
-"entre séquences de même type : ::" 
+"éléments de chaque séquence sont comparés et, s'ils diffèrent, cela " 
+"détermine le résultat de la comparaison ; s'ils sont égaux, les deux " 
+"éléments suivants sont comparés à leur tour et ainsi de suite jusqu'à ce que " 
+"l'une des séquences soit épuisée. Si deux éléments à comparer sont eux-mêmes " 
+"des séquences du même type, alors la comparaison lexicographique est " 
+"effectuée récursivement. Si tous les éléments des deux séquences sont égaux, " 
+"les deux séquences sont alors considérées comme égales. Si une séquence est " 
+"une sous-séquence de l'autre, la séquence la plus courte est celle dont la " 
+"valeur est inférieure. La comparaison lexicographique des chaînes de " 
+"caractères utilise le code Unicode des caractères. Voici quelques exemples " 
+"de comparaisons entre séquences de même type : ::" 
  
 #: ../Doc/tutorial/datastructures.rst:702 
 msgid "" 
@ -808,9 +808,9 @@ msgid ""
 msgstr "" 
 "Comparer des objets de type différents avec ``<`` ou ``>`` est autorisé si " 
 "les objets ont des méthodes de comparaison appropriées. Par exemple, les " 
-"types numériques sont comparées via leur valeur numérique, donc 0 est égal à " 
-"0,0, etc. Dans les autres cas, au lieu de donner un ordre imprévisible, " 
-"l'interpréteur lancera une exception :exc:`TypeError`." 
+"types numériques sont comparées via leur valeur numérique, donc 0 égale 0,0, " 
+"etc. Dans les autres cas, au lieu de donner un ordre imprévisible, " 
+"l'interpréteur lève une exception :exc:`TypeError`." 
  
 #: ../Doc/tutorial/datastructures.rst:710 
 msgid "Footnotes" 
@ -821,8 +821,8 @@ msgid ""
 "Other languages may return the mutated object, which allows method chaining, " 
 "such as ``d->insert(\"a\")->remove(\"b\")->sort();``." 
 msgstr "" 
-"D'autres langages pourraient renvoie l'objet modifié, qui permet de chaîner " 
-"les méthodes, tel que : ``d->insert(\"a\")->remove(\"b\")->sort();``." 
+"D'autres langages renvoient l'objet modifié, ce qui permet de chaîner les " 
+"méthodes comme ceci : ``d->insert(\"a\")->remove(\"b\")->sort();``." 
  
 #: ../Doc/tutorial/datastructures.rst:714 
 msgid "" 
@ -830,7 +830,7 @@ msgid ""
 "supports operations like membership test and iteration, but its contents are " 
 "not independent of the original dictionary -- it is only a *view*." 
 msgstr "" 
-"Appeler ``d.keys()`` renvoie un objet :dfn:`dictionary view`, qui gère les " 
+"Appeler ``d.keys()`` renvoie un objet :dfn:`dictionary view` qui gère les " 
 "opérations du type test d'appartenance (``in``) et l'itération. Mais son " 
 "contenu n'est pas indépendant du dictionnaire d'origine, c'est une simple " 
 "*vue*."