Relecture de tutorial/datastructures (#1753)

Co-authored-by: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com>

tutorial/datastructures.po

@@ -6,14 +6,14 @@ msgstr ""
 "Project-Id-Version: Python 3\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2021-05-19 22:36+0200\n"
-"PO-Revision-Date: 2020-09-30 14:26+0200\n"
-"Last-Translator: Jules Lasne <jules.lasne@gmail.com>\n"
+"PO-Revision-Date: 2021-08-07 11:51+0200\n"
+"Last-Translator: Antoine Wecxsteen\n"
 "Language-Team: FRENCH <traductions@lists.afpy.org>\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.4.1\n"
+"X-Generator: Poedit 2.3\n"
 
 #: tutorial/datastructures.rst:5
 msgid "Data Structures"
@@ -37,7 +37,7 @@ msgid ""
 "list objects:"
 msgstr ""
 "Le type liste dispose de méthodes supplémentaires. Voici toutes les méthodes "
-"des objets de type liste :"
+"des objets liste :"
 
 #: tutorial/datastructures.rst:22
 msgid ""
@@ -60,9 +60,9 @@ msgid ""
 "of the list, and ``a.insert(len(a), x)`` is equivalent to ``a.append(x)``."
 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."
-"insert(len(a), x)`` est équivalent à ``a.append(x)``."
+"position de l'élément 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.insert(len(a), "
+"x)`` est équivalent à ``a.append(x)``."
 
 #: tutorial/datastructures.rst:43
 msgid ""
@@ -145,10 +145,10 @@ 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 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."
+"Vous avez probablement remarqué que les méthodes qui ne font que modifier la "
+"liste, comme ``insert``, ``remove`` ou ``sort`, n'affichent pas de valeur de "
+"retour (elles renvoient ``None``) [1]_. C'est un principe respecté par "
+"toutes les structures de données muables en Python."
 
 #: tutorial/datastructures.rst:128
 msgid ""
@@ -158,9 +158,9 @@ msgid ""
 "types.  Also, there are some types that don't have a defined ordering "
 "relation.  For example, ``3+4j < 5+7j`` isn't a valid comparison."
 msgstr ""
-"Une autre chose que vous remarquerez peut-être est que toutes les données ne "
-"peuvent pas être ordonnées ou comparées. Par exemple, ``[None, 'hello', "
-"10]`` ne sera pas ordonné parce que les entiers ne peuvent pas être comparés "
+"Vous avez peut-être remarqué aussi que certaines données ne peuvent pas être "
+"ordonnées ni comparées. Par exemple, la liste ``[None, 'hello', 10]`` ne "
+"peut pas être ordonnée parce que les entiers ne peuvent pas être comparés "
 "aux chaînes de caractères et *None* ne peut pas être comparé à d'autres "
 "types. En outre, il existe certains types qui n'ont pas de relation d'ordre "
 "définie. Par exemple, ``3+4j < 5+7j`` n'est pas une comparaison valide."
@@ -200,22 +200,22 @@ msgstr ""
 "é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)."
+"suppressions en fin de liste sont rapides, les insertions ou les retraits en "
+"début de liste sont lents (car tous les autres éléments doivent être décalés "
+"d'une position)."
 
 #: tutorial/datastructures.rst:179
 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 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 ::"
+"Pour implémenter une file, utilisez plutôt la classe :class:`collections."
+"deque` qui a été conçue spécialement pour réaliser rapidement les opérations "
+"d'ajout et de retrait aux deux extrémités. Par exemple ::"
 
 #: tutorial/datastructures.rst:197
 msgid "List Comprehensions"
-msgstr "Compréhensions de listes"
+msgstr "Listes en compréhension"
 
 #: tutorial/datastructures.rst:199
 msgid ""
@@ -224,11 +224,11 @@ msgid ""
 "operations applied to each member of another sequence or iterable, or to "
 "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 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 "
-"éléments satisfaisant une condition spécifique."
+"Les listes en compréhension fournissent un moyen de construire des listes de "
+"manière très concise. Une application classique consiste à construire une "
+"liste dont les éléments sont les résultats d'une opération appliquée à "
+"chaque élément d'une autre séquence ; une autre consiste à créer une sous-"
+"séquence des éléments respectant une condition donnée."
 
 #: tutorial/datastructures.rst:204
 msgid "For example, assume we want to create a list of squares, like::"
@@ -251,7 +251,7 @@ msgstr "ou, de manière équivalente ::"
 
 #: tutorial/datastructures.rst:223
 msgid "which is more concise and readable."
-msgstr "qui est plus court et lisible."
+msgstr "ce qui est plus court et lisible."
 
 #: tutorial/datastructures.rst:225
 msgid ""
@@ -262,7 +262,7 @@ 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 à placer entre crochets une expression "
+"Une liste en compréhension 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` "
@@ -287,26 +287,26 @@ msgid ""
 "it must be parenthesized. ::"
 msgstr ""
 "Si l'expression est un *n*-uplet (c'est-à-dire ``(x, y)`` dans cet exemple), "
-"elle doit être entourée par des parenthèses ::"
+"elle doit être mise entre parenthèses ::"
 
 #: tutorial/datastructures.rst:280
 msgid ""
 "List comprehensions can contain complex expressions and nested functions::"
 msgstr ""
-"Les compréhensions de listes peuvent contenir des expressions complexes et "
+"Les listes en compréhension peuvent contenir des expressions complexes et "
 "des fonctions imbriquées ::"
 
 #: tutorial/datastructures.rst:287
 msgid "Nested List Comprehensions"
-msgstr "Compréhensions de listes imbriquées"
+msgstr "Listes en compréhensions imbriquées"
 
 #: tutorial/datastructures.rst:289
 msgid ""
 "The initial expression in a list comprehension can be any arbitrary "
 "expression, including another list comprehension."
 msgstr ""
-"La première expression dans une compréhension de liste peut être n'importe "
-"quelle expression, y compris une autre compréhension de liste."
+"La première expression dans une liste en compréhension peut être n'importe "
+"quelle expression, y compris une autre liste en compréhension."
 
 #: tutorial/datastructures.rst:292
 msgid ""
@@ -326,13 +326,13 @@ msgid ""
 "context of the :keyword:`for` that follows it, so this example is equivalent "
 "to::"
 msgstr ""
-"Comme nous l'avons vu dans la section précédente, la compréhension de liste "
+"Comme nous l'avons vu dans la section précédente, la liste en compréhension "
 "imbriquée est évaluée dans le contexte de l'instruction :keyword:`for` qui "
 "la suit, donc cet exemple est équivalent à ::"
 
 #: tutorial/datastructures.rst:317
 msgid "which, in turn, is the same as::"
-msgstr "lequel à son tour est équivalent à ::"
+msgstr "lequel est lui-même équivalent à ::"
 
 #: tutorial/datastructures.rst:330
 msgid ""
@@ -341,14 +341,14 @@ msgid ""
 msgstr ""
 "Dans des cas concrets, il est toujours préférable d'utiliser des fonctions "
 "natives plutôt que des instructions de contrôle de flux complexes. La "
-"fonction :func:`zip` ferait dans ce cas un excellent travail ::"
+"fonction :func:`zip` fait dans ce cas un excellent travail ::"
 
 #: tutorial/datastructures.rst:336
 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 l'astérisque "
-"de cette ligne."
+"Voir :ref:`tut-unpacking-arguments` pour plus de détails sur l'astérisque de "
+"cette ligne."
 
 #: tutorial/datastructures.rst:341
 msgid "The :keyword:`!del` statement"
@@ -381,11 +381,11 @@ msgid ""
 msgstr ""
 "À partir de là, référencer le nom ``a`` est une erreur (au moins jusqu'à ce "
 "qu'une autre valeur lui soit affectée). Vous trouverez d'autres utilisations "
-"de la fonction :keyword:`del` plus tard."
+"de la fonction :keyword:`del` dans la suite de ce tutoriel."
 
 #: tutorial/datastructures.rst:371
 msgid "Tuples and Sequences"
-msgstr "Tuples et séquences"
+msgstr "*n*-uplets et séquences"
 
 #: tutorial/datastructures.rst:373
 msgid ""
@@ -400,8 +400,7 @@ msgstr ""
 "Ce sont deux exemples de *séquences* (voir :ref:`typesseq`). Comme Python "
 "est un langage en constante évolution, d'autres types de séquences y seront "
 "peut-être ajoutés. Il existe également un autre type standard de séquence : "
-"le *tuple* (ou *n*-uplet, dénomination que nous utiliserons dans la suite de "
-"cette documentation)."
+"le *n*-uplet (*tuple* en anglais)."
 
 #: tutorial/datastructures.rst:379
 msgid ""
@@ -424,8 +423,8 @@ msgstr ""
 "correctement ; ils peuvent être saisis avec ou sans parenthèses, même si "
 "celles-ci sont souvent nécessaires (notamment lorsqu'un *n*-uplet fait "
 "partie d'une expression plus longue). Il n'est pas possible d'affecter de "
-"valeur à un élément d'un *n*-uplet ; par contre, il est possible de créer "
-"des *n*-uplets contenant des objets muables, comme des listes."
+"valeur à un élément d'un *n*-uplet ; par contre, il est en revanche possible "
+"de créer des *n*-uplets contenant des objets muables, comme des listes."
 
 #: tutorial/datastructures.rst:408
 msgid ""
@@ -438,13 +437,14 @@ msgid ""
 "iterating over the list."
 msgstr ""
 "Si les *n*-uplets peuvent sembler similaires aux listes, ils sont souvent "
-"utilisés dans des cas différents et pour des raisons différentes. Les n-"
-"uplets sont :term:`immuable`\\s et contiennent souvent des séquences "
-"hétérogènes d'éléments qui sont accédés par « dissociation » (*unpacking* en "
-"anglais, voir plus loin) ou par indice (ou même par attributs dans le cas "
-"des :func:`namedtuples <collections.namedtuple>`). Les listes sont souvent :"
-"term:`muable <muable>`\\s et contiennent des éléments généralement homogènes "
-"qui sont accédés par itération sur la liste."
+"utilisés dans des cas différents et pour des raisons différentes. Les *n*-"
+"uplets sont :term:`immuables <immuable>` et contiennent souvent des "
+"séquences hétérogènes d'éléments auxquelles on accède par "
+"« dissociation » (*unpacking* en anglais, voir plus loin) ou par indice (ou "
+"même par attribut dans le cas des :func:`namedtuples <collections."
+"namedtuple>`). Les listes sont souvent :term:`muables <muable>` et "
+"contiennent des éléments généralement homogènes auxquels on accède en "
+"itérant sur la liste."
 
 #: tutorial/datastructures.rst:416
 msgid ""
@@ -454,12 +454,12 @@ msgid ""
 "constructed by following a value with a comma (it is not sufficient to "
 "enclose a single value in parentheses). Ugly, but effective.  For example::"
 msgstr ""
-"Un problème spécifique est la construction de *n*-uplets ne contenant aucun "
-"ou un seul élément : la syntaxe a quelques tournures spécifiques pour s'en "
-"accommoder. Les *n*-uplets vides sont construits par une paire de "
-"parenthèses vides ; un *n*-uplet 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 ::"
+"La construction de *n*-uplets ne contenant aucun ou un seul élément est un "
+"cas particulier : la syntaxe a quelques tournures spécifiques pour le gérer. "
+"Un *n*-uplet vide se construit avec une paire de parenthèses vides ; un *n*-"
+"uplet avec un seul élément se construit en faisant suivre la valeur par une "
+"virgule (placer cette valeur entre parenthèses ne suffit pas). Pas très "
+"joli, mais efficace. Par exemple ::"
 
 #: tutorial/datastructures.rst:431
 msgid ""
@@ -467,10 +467,10 @@ msgid ""
 "packing*: the values ``12345``, ``54321`` and ``'hello!'`` are packed "
 "together in a tuple. The reverse operation is also possible::"
 msgstr ""
-"L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple d'un "
-"*d'agrégation de *n*-uplet* (*tuple packing* en anglais) : les valeurs "
-"``12345``, ``54321`` et ``hello !`` sont agrégées ensemble dans un *n*-"
-"uplet. L'opération inverse est aussi possible ::"
+"L'instruction ``t = 12345, 54321, 'hello !'`` est un exemple *d'agrégation "
+"de *n*-uplet* (*tuple packing* en anglais) : les valeurs ``12345``, "
+"``54321`` et ``hello !`` sont agrégées ensemble dans un *n*-uplet. "
+"L'opération inverse est aussi possible ::"
 
 #: tutorial/datastructures.rst:437
 msgid ""
@@ -480,7 +480,7 @@ msgid ""
 "in the sequence.  Note that multiple assignment is really just a combination "
 "of tuple packing and sequence unpacking."
 msgstr ""
-"Ceci est appelé, de façon plus ou moins appropriée, un *dissociation de "
+"Ceci est appelé, de façon plus ou moins appropriée, une *dissociation de "
 "séquence* (*sequence unpacking* en anglais) et fonctionne pour toute "
 "séquence placée à droite de l'expression. Cette dissociation requiert autant "
 "de variables dans la partie gauche qu'il y a d'éléments dans la séquence. "
@@ -500,9 +500,9 @@ msgid ""
 "difference."
 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 suppressions "
-"de doublons. Les ensembles savent également effectuer les opérations "
+"est une collection non ordonnée sans éléments en double. Un ensemble permet "
+"de réaliser des tests d'appartenance ou des suppressions de doublons de "
+"manière simple. Les ensembles savent également effectuer les opérations "
 "mathématiques telles que les unions, intersections, différences et "
 "différences symétriques."
 
@@ -513,9 +513,10 @@ 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 ensembles. Notez que pour créer un ensemble vide, ``{}`` ne fonctionne "
-"pas, cela crée un dictionnaire vide. Utilisez plutôt ``set()``."
+"On crée des ensembles en appelant avec des accolades ou avec la fonction :"
+"func:`set`. Notez que ``{}`` ne crée pas un ensemble vide, mais un "
+"dictionnaire (une structure de données dont nous allons parler dans la "
+"séquence suivante) vide ; utilisez ``set()`` pour ce cas."
 
 #: tutorial/datastructures.rst:458
 msgid "Here is a brief demonstration::"
@@ -526,8 +527,8 @@ msgid ""
 "Similarly to :ref:`list comprehensions <tut-listcomps>`, set comprehensions "
 "are also supported::"
 msgstr ""
-"Tout comme pour les :ref:`compréhensions de listes <tut-listcomps>`, il est "
-"possible d'écrire des compréhensions d'ensembles ::"
+"Tout comme pour les :ref:`listes en compréhension <tut-listcomps>`, il est "
+"possible d'écrire des ensembles en compréhension ::"
 
 #: tutorial/datastructures.rst:494
 msgid "Dictionaries"
@@ -568,13 +569,12 @@ msgid ""
 "of key:value pairs within the braces adds initial key:value pairs to the "
 "dictionary; this is also the way dictionaries are written on output."
 msgstr ""
-"Le plus simple est de considérer les dictionnaires comme des ensembles de "
-"paires *clé: valeur*, les clés devant être uniques (au sein d'un "
-"dictionnaire). Une paire d'accolades crée un dictionnaire vide : ``{}``. "
-"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."
+"Le plus simple est de voir un dictionnaire comme un ensemble de paires *clé-"
+"valeur* au sein duquel les clés doivent être uniques. Une paire d'accolades "
+"crée un dictionnaire vide : ``{}``. 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."
 
 #: tutorial/datastructures.rst:513
 msgid ""
@@ -620,8 +620,8 @@ msgid ""
 "In addition, dict comprehensions can be used to create dictionaries from "
 "arbitrary key and value expressions::"
 msgstr ""
-"De plus, il est possible de créer des dictionnaires par compréhension depuis "
-"un jeu de clef et valeurs ::"
+"De plus, il est possible de créer des dictionnaires en compréhension depuis "
+"un jeu de clés et valeurs ::"
 
 #: tutorial/datastructures.rst:557
 msgid ""
@@ -629,7 +629,7 @@ msgid ""
 "using keyword arguments::"
 msgstr ""
 "Lorsque les clés sont de simples chaînes de caractères, il est parfois plus "
-"facile de spécifier les paires en utilisant des paramètres nommés ::"
+"facile de définir les paires en utilisant des paramètres nommés ::"
 
 #: tutorial/datastructures.rst:567
 msgid "Looping Techniques"
@@ -640,8 +640,8 @@ msgid ""
 "When looping through dictionaries, the key and corresponding value can be "
 "retrieved at the same time using the :meth:`items` method. ::"
 msgstr ""
-"Lorsque vous faites une boucle sur un dictionnaire, les clés et leurs "
-"valeurs peuvent être récupérées en même temps en utilisant la méthode :meth:"
+"Lorsque vous faites une boucle sur un dictionnaire, la clé et la valeur "
+"associée peuvent être récupérées en même temps en utilisant la méthode :meth:"
 "`items` ::"
 
 #: tutorial/datastructures.rst:579
@@ -650,8 +650,8 @@ msgid ""
 "can be retrieved at the same time using the :func:`enumerate` function. ::"
 msgstr ""
 "Lorsque vous faites une boucle sur une séquence, la position et la valeur "
-"correspondante peuvent être récupérées en même temps en utilisant la "
-"fonction :func:`enumerate`. ::"
+"associée peuvent être récupérées en même temps en utilisant la fonction :"
+"func:`enumerate`. ::"
 
 #: tutorial/datastructures.rst:589
 msgid ""
@@ -687,18 +687,18 @@ msgid ""
 "order. ::"
 msgstr ""
 "L'utilisation de la fonction :func:`set` sur une séquence élimine les "
-"doublons. L'utilisation de la fonction :func:`sorted` en combinaison avec :"
-"func:`set` sur une séquence est une façon idiomatique de boucler sur les "
-"éléments uniques d'une séquence dans l'ordre. ::"
+"doublons. Combiner les fonctions :func:`sorted` et :func:`set` sur une "
+"séquence est la façon « canonique » d'itérer sur les éléments uniques d'une "
+"séquence dans l'ordre. ::"
 
 #: tutorial/datastructures.rst:640
 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 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. ::"
+"Il est parfois tentant de modifier une liste pendant que l'on itère dessus. "
+"Il est souvent plus simple et plus sûr de créer une nouvelle liste à la "
+"place. ::"
 
 #: tutorial/datastructures.rst:657
 msgid "More on Conditions"
@@ -713,7 +713,6 @@ msgstr ""
 "contenir n'importe quel opérateur, pas seulement des comparaisons."
 
 #: tutorial/datastructures.rst:662
-#, fuzzy
 msgid ""
 "The comparison operators ``in`` and ``not in`` check whether a value occurs "
 "(does not occur) in a sequence.  The operators ``is`` and ``is not`` compare "
@@ -722,8 +721,7 @@ msgid ""
 msgstr ""
 "Les opérateurs de comparaison ``in`` et ``not in`` testent si une valeur est "
 "présente ou non dans une séquence. Les opérateurs ``is`` et ``is not`` "
-"testent si deux objets sont vraiment le même objet ; ceci n'est important "
-"que pour des objets muables comme des listes. Tous les opérateurs de "
+"testent si deux objets sont vraiment le même objet. Tous les opérateurs de "
 "comparaison ont la même priorité, qui est plus faible que celle des "
 "opérateurs numériques."
 
@@ -732,8 +730,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 comparaisons peuvent être enchaînées. Par exemple, ``a < b == c`` teste "
-"si ``a`` est inférieur à ``b`` et si, de plus, ``b`` égale ``c``."
+"Les comparaisons peuvent être chaînées. Par exemple, ``a < b == c`` teste si "
+"``a`` est inférieur à ``b`` et si, de plus, ``b`` égale ``c``."
 
 #: tutorial/datastructures.rst:670
 msgid ""
@@ -750,8 +748,8 @@ msgstr ""
 "priorité inférieure à celle des opérateurs de comparaison ; entre eux, "
 "``not`` a la priorité la plus élevée et ``or`` la plus faible, de telle "
 "sorte que ``A and not B or C`` est équivalent à ``(A and (not B)) or C``. "
-"Comme toujours, des parenthèses peuvent être utilisées pour exprimer "
-"l'instruction désirée."
+"Comme d'habitude, les parenthèses permettent d'exprimer l'instruction "
+"désirée."
 
 #: tutorial/datastructures.rst:677
 msgid ""
@@ -834,8 +832,8 @@ 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és via leur valeur numérique, donc 0 égale 0,0, "
-"etc. Dans les autres cas, au lieu de donner un ordre imprévisible, "
+"types numériques sont comparés 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`."
 
 #: tutorial/datastructures.rst:731