Tutorial 'Floating Point Arithmetic' Review.

tutorial/floatingpoint.po

@@ -9,9 +9,9 @@ msgstr ""
 "Project-Id-Version: Python 3.6\n"
 "Report-Msgid-Bugs-To: \n"
 "POT-Creation-Date: 2017-04-02 22:11+0200\n"
-"PO-Revision-Date: 2018-02-15 00:58+0100\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
+"PO-Revision-Date: 2018-03-03 23:55+0100\n"
+"Last-Translator: Christophe Nanteuil <christophe.nanteuil@gmail.com>\n"
+"Language-Team: \n"
 "Language: fr\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
@@ -19,7 +19,7 @@ msgstr ""
 
 #: ../Doc/tutorial/floatingpoint.rst:9
 msgid "Floating Point Arithmetic:  Issues and Limitations"
-msgstr "Arithmétique en nombre à virgule flottante : problèmes et limites"
+msgstr "Arithmétique en nombres à virgule flottante : problèmes et limites"
 
 #: ../Doc/tutorial/floatingpoint.rst:14
 msgid ""
@@ -34,7 +34,7 @@ msgstr ""
 msgid ""
 "has value 1/10 + 2/100 + 5/1000, and in the same way the binary fraction ::"
 msgstr ""
-"a la valeur 1/10 + 2/100 + 5/1000, et de la même manière, la fraction "
+"a la valeur 1/10 + 2/100 + 5/1000 et, de la même manière, la fraction "
 "binaire : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:23
@@ -45,7 +45,7 @@ msgid ""
 msgstr ""
 "a la valeur 0/2 + 0/4 + 1/8. Ces deux fractions ont une valeur identique, la "
 "seule différence est que la première est une fraction décimale, la seconde "
-"binaire."
+"est une fraction binaire."
 
 #: ../Doc/tutorial/floatingpoint.rst:27
 msgid ""
@@ -54,10 +54,10 @@ msgid ""
 "point numbers you enter are only approximated by the binary floating-point "
 "numbers actually stored in the machine."
 msgstr ""
-"Malheureusement, la plupart des fractions décimales n'ont pas de "
+"Malheureusement, la plupart des fractions décimales ne peuvent pas avoir de "
 "représentation exacte en fractions binaires. Par conséquent, en général, les "
 "nombres à virgule flottante que vous donnez sont seulement approximés en "
-"fraction binaire pour être stocké dans la machine."
+"fractions binaires pour être stockés dans la machine."
 
 #: ../Doc/tutorial/floatingpoint.rst:32
 msgid ""
@@ -65,7 +65,7 @@ msgid ""
 "fraction 1/3.  You can approximate that as a base 10 fraction::"
 msgstr ""
 "Le problème est plus simple à aborder en base 10. Prenons par exemple, la "
-"fraction 1/3. Vous pouvez l'approximer en une fraction décimale::"
+"fraction 1/3. Vous pouvez l'approximer en une fraction décimale : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:37 ../Doc/tutorial/floatingpoint.rst:41
 msgid "or, better, ::"
@@ -77,9 +77,9 @@ msgid ""
 "result will never be exactly 1/3, but will be an increasingly better "
 "approximation of 1/3."
 msgstr ""
-"etc... Peu importe le nombre de décimales que vous écrirez, le résultat ne "
-"sera jamais exactement 1/3, mais une estimation s'en approchant toujours "
-"mieux."
+"etc. Peu importe le nombre de décimales que vous écrivez, le résultat ne "
+"vaut jamais exactement 1/3, mais c'est une estimation s'en approchant "
+"toujours mieux."
 
 #: ../Doc/tutorial/floatingpoint.rst:49
 msgid ""
@@ -88,7 +88,7 @@ msgid ""
 "base 2, 1/10 is the infinitely repeating fraction ::"
 msgstr ""
 "De la même manière, peu importe combien de décimales en base 2 vous "
-"utiliserez, la valeur décimale 0.1 ne peut être représentée exactement en "
+"utilisez, la valeur décimale 0.1 ne peut pas être représentée exactement en "
 "fraction binaire. En base 2, 1/10 est le nombre périodique suivant : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:55
@@ -105,7 +105,7 @@ msgstr ""
 "virgule flottante sont approximés par une fraction binaire avec les 53 "
 "premiers bits comme numérateur et une puissance de deux au dénominateur. "
 "Dans le cas de 1/10, la fraction binaire est ``3602879701896397 / 2 ** 55`` "
-"qui est proche mais pas exactement 1/10."
+"qui est proche mais ne vaut pas exactement 1/10."
 
 #: ../Doc/tutorial/floatingpoint.rst:62
 msgid ""
@@ -115,9 +115,9 @@ msgid ""
 "if Python were to print the true decimal value of the binary approximation "
 "stored for 0.1, it would have to display ::"
 msgstr ""
-"Il est facile d'oublier que la valeur stockée est une approximation de la "
-"fraction décimale d'origine, du fait de la manière dont les flottants sont "
-"affichés dans l'interpréteur. Python n'affiche qu'une approximation décimale "
+"Du fait de la manière dont les flottants sont affichés par l'interpréteur, "
+"il est facile d'oublier que la valeur stockée est une approximation de la "
+"fraction décimale d'origine. Python n'affiche qu'une approximation décimale "
 "de la valeur stockée en binaire. Si Python devait afficher la vraie valeur "
 "décimale de l'approximation binaire stockée pour 0,1, il afficherait : ::"
 
@@ -126,17 +126,18 @@ msgid ""
 "That is more digits than most people find useful, so Python keeps the number "
 "of digits manageable by displaying a rounded value instead ::"
 msgstr ""
-"C'est bien plus de décimales que nécessaire, donc Python affiche une valeur "
-"arrondie afin d'améliorer la lisibilité : ::"
+"C'est bien plus de décimales que ce qu'attendent la plupart des "
+"utilisateurs, donc Python affiche une valeur arrondie afin d'améliorer la "
+"lisibilité : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:77
 msgid ""
 "Just remember, even though the printed result looks like the exact value of "
 "1/10, the actual stored value is the nearest representable binary fraction."
 msgstr ""
-"Il faut se rappeler, bien que la valeur affichée ressemble à la valeur "
-"exacte de 1/10, que la valeur stockée est la représentation la plus proche "
-"en fraction binaire."
+"Rappelez-vous simplement que, bien que la valeur affichée ressemble à la "
+"valeur exacte de 1/10, la valeur stockée est la représentation la plus "
+"proche en fraction binaire."
 
 #: ../Doc/tutorial/floatingpoint.rst:80
 msgid ""
@@ -149,9 +150,9 @@ msgid ""
 "while still preserving the invariant ``eval(repr(x)) == x``."
 msgstr ""
 "Il existe beaucoup de nombres décimaux qui partagent une même approximation "
-"en fraction binaire. Par exemple, ``0.1``, ``0.10000000000000001``, et "
+"en fraction binaire. Par exemple, ``0.1``, ``0.10000000000000001`` et "
 "``0.1000000000000000055511151231257827021181583404541015625`` ont tous pour "
-"approximation ``3602879701896397 / 2 ** 55``. Puisques toutes ces valeurs "
+"approximation ``3602879701896397 / 2 ** 55``. Puisque toutes ces valeurs "
 "décimales partagent la même approximation, chacune peut être affichée tout "
 "en respectant ``eval(repr(x)) == x``."
 
@@ -163,10 +164,10 @@ msgid ""
 "shortest of these and simply display ``0.1``."
 msgstr ""
 "Historiquement, le mode interactif de Python et la primitive :func:`repr` "
-"auraient choisi la version avec 17 décimales significatives, "
+"choisissaient la version avec 17 décimales significatives, "
 "``0.10000000000000001``. Python, depuis la version 3.1 (sur la majorité des "
 "systèmes) est maintenant capable de choisir la plus courte représentation et "
-"n'afficher que ``0.1``."
+"n'affiche que ``0.1``."
 
 #: ../Doc/tutorial/floatingpoint.rst:93
 msgid ""
@@ -176,12 +177,13 @@ msgid ""
 "arithmetic (although some languages may not *display* the difference by "
 "default, or in all output modes)."
 msgstr ""
-"Ce comportement est inhérent au comportement des nombres à virgule "
-"flottante : ce n'est pas un bug dans Python, et ce n'est pas non plus un bug "
-"dans votre code. Vous verrez le même type de comportement dans tous les "
-"autres langages utilisant le support matériel pour le calcul des nombres à "
-"virgules flottante (bien que certains langages ne rendent pas visible la "
-"différence par défaut, ou pas dans tous les modes d'affichage)."
+"Ce comportement est inhérent à la nature même de la représentation des "
+"nombres à virgule flottante dans la machine : ce n'est pas un bogue dans "
+"Python et ce n'est pas non plus un bogue dans votre code. Vous pouvez "
+"observer le même type de comportement dans tous les autres langages "
+"utilisant le support matériel pour le calcul des nombres à virgule flottante "
+"(bien que certains langages ne rendent pas visible la différence par défaut, "
+"ou pas dans tous les modes d'affichage)."
 
 #: ../Doc/tutorial/floatingpoint.rst:99
 msgid ""
@@ -197,8 +199,9 @@ msgid ""
 "It's important to realize that this is, in a real sense, an illusion: you're "
 "simply rounding the *display* of the true machine value."
 msgstr ""
-"Il est important de comprendre qu'en réalité, c'est une illusion : Python "
-"arrondit simplement, la vraie valeur stockée, à *l'affichage*."
+"Il est important de comprendre que tout cela n'est, au sens propre, qu'une "
+"illusion : vous demandez simplement à Python d'arrondir la valeur stockée "
+"réellement dans la machine à *l'affichage*."
 
 #: ../Doc/tutorial/floatingpoint.rst:114
 msgid ""
@@ -216,8 +219,8 @@ msgid ""
 msgstr ""
 "Aussi, puisque 0,1 ne peut pas être stocké avec une représentation plus "
 "proche de sa valeur exacte 1/10, comme 0,3 qui ne peut pas être plus proche "
-"de sa valeur exacte 3/10, arrondir avec la fonction :func:`round` n'aide en "
-"rien : ::"
+"de sa valeur exacte 3/10, arrondir au préalable avec la fonction :func:"
+"`round` n'aide en rien : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:127
 msgid ""
@@ -225,9 +228,9 @@ msgid ""
 "the :func:`round` function can be useful for post-rounding so that results "
 "with inexact values become comparable to one another::"
 msgstr ""
-"Bien que les nombres ne peuvent se rapprocher plus de la valeur qu'on attend "
-"qu'ils aient, la fonction :func:`round` peut être utile à posteriori pour "
-"arrondir deux valeurs inexactes et les rendre comparables : ::"
+"Bien que les nombres ne peuvent se rapprocher plus de la valeur qu’on attend "
+"qu’ils aient, la fonction :func:`round` peut être utile à postériori pour "
+"arrondir deux valeurs inexactes et pouvoir les comparer : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:134
 msgid ""
@@ -239,7 +242,7 @@ msgid ""
 msgstr ""
 "L'arithmétique des nombres binaires à virgule flottante réserve beaucoup de "
 "surprises de ce genre. Le problème avec \"0.1\" est expliqué en détails ci-"
-"desous, dans la section \"Représentation d'Erreur\". Voir `The Perils of "
+"dessous, dans la section \"Erreurs de représentation\". Voir `The Perils of "
 "Floating Point <http://www.lahey.com/float.htm>`_ pour une liste plus "
 "complète de ce genre de surprises."
 
@@ -253,14 +256,14 @@ msgid ""
 "decimal arithmetic and that every float operation can suffer a new rounding "
 "error."
 msgstr ""
-"Il est vrai qu'il n'existe pas de réponse simple, cependant ne vous méfiez "
-"pas trop des nombres à virtule flottante ! Les erreurs, en Python, dans les "
-"opérations de nombres à virgule flottante sont dues au matériel sous-jacent, "
-"et sur la plupart des machines ne sont pas plus importantes que 1 sur 2\\*"
-"\\*53 par opération. C'est plus que nécessaire pour la plupart des tâches, "
-"mais vous devez garder à l'esprit que ce ne sont pas des opérations "
-"décimales, et que chaque opération sur des nombres à virgule flottante peut "
-"souffrir d'une nouvelle erreur."
+"Même s'il est vrai qu'il n'existe pas de réponse simple, ce n'est pas la "
+"peine de vous méfier outre mesure des nombres à virgule flottante ! Les "
+"erreurs, en Python, dans les opérations de nombres à virgule flottante sont "
+"dues au matériel sous-jacent et, sur la plupart des machines, sont de "
+"l'ordre de 1 sur 2\\*\\*53 par opération. C'est plus que suffisant pour la "
+"plupart des tâches, mais vous devez garder à l'esprit que ce ne sont pas des "
+"opérations décimales et que chaque opération sur des nombres à virgule "
+"flottante peut souffrir d'une nouvelle erreur."
 
 #: ../Doc/tutorial/floatingpoint.rst:146
 msgid ""
@@ -271,7 +274,7 @@ msgid ""
 "`str.format` method's format specifiers in :ref:`formatstrings`."
 msgstr ""
 "Bien que des cas pathologiques existent, pour la plupart des cas "
-"d'utilisations courants vous obtiendrez le résultat attendu à la fin et en "
+"d'utilisations courants vous obtiendrez le résultat attendu à la fin en "
 "arrondissant simplement au nombre de décimales désirées à l'affichage avec :"
 "func:`str`. Pour un contrôle fin sur la manière dont les décimales sont "
 "affichées, consultez dans :ref:`formatstrings` les spécifications de "
@@ -284,7 +287,7 @@ msgid ""
 "applications and high-precision applications."
 msgstr ""
 "Pour les cas requérant une représentation décimale exacte, le module :mod:"
-"`decimal` peut être utile, il implémente l'arithmétique décimale et peut "
+"`decimal` peut être utile : il implémente l'arithmétique décimale et peut "
 "donc être un choix adapté pour des applications nécessitant une grande "
 "précision."
 
@@ -295,7 +298,7 @@ msgid ""
 "1/3 can be represented exactly)."
 msgstr ""
 "Une autre forme d'arithmétique exacte est implémentée dans le module :mod:"
-"`fractions` qui se base sur les nombre rationnels (donc 1/3 peut y être "
+"`fractions` qui se base sur les nombres rationnels (donc 1/3 peut y être "
 "représenté exactement)."
 
 #: ../Doc/tutorial/floatingpoint.rst:160
@@ -306,9 +309,9 @@ msgid ""
 "org>."
 msgstr ""
 "Si vous êtes un utilisateur intensif des opérations sur les nombres à "
-"virgule flottante, vous devriez regarder le paquet *Numerical Python* et une "
-"série d'autres paquets pour les opérations statistiques et mathématiques "
-"fournis par le projet SciPy. Voir <https://scipy.org>."
+"virgule flottante, nous vous conseillons de considérer le paquet *Numerical "
+"Python* ainsi que les paquets pour les opérations statistiques et "
+"mathématiques fournis par le projet SciPy. Consultez <https://scipy.org>."
 
 #: ../Doc/tutorial/floatingpoint.rst:164
 msgid ""
@@ -316,8 +319,8 @@ msgid ""
 "*do* want to know the exact value of a float.  The :meth:`float."
 "as_integer_ratio` method expresses the value of a float as a fraction::"
 msgstr ""
-"Python fournit des outils qui peuvent être utils dans les rares occasions ou "
-"vous voulez réellement connaître la valeur exacte d'un nombre à virgule "
+"Python fournit des outils qui peuvent être utiles dans les rares occasions "
+"où vous voulez réellement connaître la valeur exacte d'un nombre à virgule "
 "flottante. La méthode :meth:`float.as_integer_ratio` donne la valeur du "
 "nombre sous forme de fraction : ::"
 
@@ -327,7 +330,7 @@ msgid ""
 "value::"
 msgstr ""
 "Puisque le ratio est exact, il peut être utilisé pour recréer la valeur "
-"originale dans perte : ::"
+"originale sans perte : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:179
 msgid ""
@@ -343,7 +346,7 @@ msgid ""
 "value exactly::"
 msgstr ""
 "Cette représentation hexadécimale petit être utilisée pour reconstruire, "
-"sans approximation, le *float* ::"
+"sans approximation, le *float* : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:191
 msgid ""
@@ -353,8 +356,8 @@ msgid ""
 "C99)."
 msgstr ""
 "Puisque cette représentation est exacte, elle est pratique pour échanger des "
-"valeurs entre différentes version de Python (indépendamment de la machine) "
-"ou d'autres langages qui comprennent ce format (tel que Java et C99)."
+"valeurs entre différentes versions de Python (indépendamment de la machine) "
+"ou d'autres langages qui comprennent ce format (tels que Java et C99)."
 
 #: ../Doc/tutorial/floatingpoint.rst:195
 msgid ""
@@ -364,11 +367,11 @@ msgid ""
 "so that the errors do not accumulate to the point where they affect the "
 "final total:"
 msgstr ""
-"Une autre fonction utile est :func:`math.fsum`, qui aide à diminuer les "
+"Une autre fonction utile est :func:`math.fsum`, elle aide à diminuer les "
 "pertes de précision lors des additions. Elle surveille les *décimales "
 "perdues* au fur et à mesure que les valeurs sont ajoutées au total. Cela "
-"peut faire une différence au niveau de la précision globale car cela empêche "
-"les erreurs de s'accumuler jusqu'au point ou le résultat final est affecté:"
+"peut faire une différence au niveau de la précision globale en empêchant les "
+"erreurs de s'accumuler jusqu'à affecter le résultat final :"
 
 #: ../Doc/tutorial/floatingpoint.rst:209
 msgid "Representation Error"
@@ -380,10 +383,10 @@ msgid ""
 "perform an exact analysis of cases like this yourself.  Basic familiarity "
 "with binary floating-point representation is assumed."
 msgstr ""
-"Cette section explique en détail l'exemple du \"0.1\", et montre comment "
-"vous pouvez effectuer une analyse exacte de ce type de cas par vous-même. Il "
-"est supposé que vous êtes déjà familier de la représentation binaire des "
-"nombres flottants."
+"Cette section explique en détail l'exemple du \"0.1\" et montre comment vous "
+"pouvez effectuer une analyse exacte de ce type de cas par vous-même. Nous "
+"supposons que la représentation binaire des nombres flottants vous est "
+"familière."
 
 #: ../Doc/tutorial/floatingpoint.rst:215
 msgid ""
@@ -393,10 +396,11 @@ msgid ""
 "Fortran, and many others) often won't display the exact decimal number you "
 "expect."
 msgstr ""
-"Le terme :dfn:`Representation error` signifie que la plupart des fractions "
-"décimales ne peuvent être représentées exactement en binaire. C'est la "
-"principale raison pour laquelle Python (ou Perl, C, C++, Java, Fortran, et "
-"beuacoup d'autres) n'affiche habituellement pas le résultat exact en décimal."
+"Le terme :dfn:`Erreur de représentation` (*representation error* en anglais) "
+"signifie que la plupart des fractions décimales ne peuvent être représentées "
+"exactement en binaire. C'est la principale raison pour laquelle Python (ou "
+"Perl, C, C++, Java, Fortran et beaucoup d'autres) n'affiche habituellement "
+"pas le résultat exact en décimal."
 
 #: ../Doc/tutorial/floatingpoint.rst:220
 msgid ""
@@ -407,15 +411,15 @@ msgid ""
 "strives to convert 0.1 to the closest fraction it can of the form *J*/2**\\ "
 "*N* where *J* is an integer containing exactly 53 bits.  Rewriting ::"
 msgstr ""
-"Pourquoi ? 1/10 n'est pas représentable de manière exacte en fractions "
-"binaires. Cependant, toutes les machines d'aujourd'hui (Juillet 2010) "
+"Pourquoi ? 1/10 n'est pas représentable de manière exacte en fraction "
+"binaire. Cependant, toutes les machines d'aujourd'hui (novembre 2000) "
 "suivent la norme IEEE-754 en ce qui concerne l'arithmétique des nombres à "
-"virgule flottante. et la plupart des plateformes utilisent un \"IEEE-754 "
-"double precision\" pour représenter les floats de Python. Les \"IEEE-754 "
-"double precision\" utilisent 53 bits de précision, donc a la lecture "
+"virgule flottante et la plupart des plateformes utilisent un \"IEEE-754 "
+"double précision\" pour représenter les floats de Python. Les \"IEEE-754 "
+"double précision\" utilisent 53 bits de précision donc, à la lecture, "
 "l'ordinateur essaie de convertir 0,1 dans la fraction la plus proche "
 "possible de la forme *J*/2**\\ *N* avec *J* un nombre entier d'exactement 53 "
-"bits. Réecrire : ::"
+"bits. Pour réécrire : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:229
 msgid "as ::"
@@ -427,7 +431,7 @@ msgid ""
 "2**53``), the best value for *N* is 56::"
 msgstr ""
 "en se rappelant que *J* fait exactement 53 bits (donc ``>= 2**52`` mais ``< "
-"2**53``), la meilleur valeur possible pour *N* est 56::"
+"2**53``), la meilleure valeur possible pour *N* est 56 : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:239
 msgid ""
@@ -436,7 +440,7 @@ msgid ""
 msgstr ""
 "Donc 56 est la seule valeur possible pour *N* qui laisse exactement 53 bits "
 "pour *J*. La meilleure valeur possible pour *J* est donc ce quotient, "
-"arrondi::"
+"arrondi : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:246
 msgid ""
@@ -444,7 +448,7 @@ msgid ""
 "obtained by rounding up::"
 msgstr ""
 "Puisque la retenue est plus grande que la moitié de 10, la meilleure "
-"approximation est obtenue en arrondissant par le haut:"
+"approximation est obtenue en arrondissant par le haut : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:252
 msgid ""
@@ -452,7 +456,7 @@ msgid ""
 "is::"
 msgstr ""
 "Par conséquent la meilleure approximation possible pour 1/10 en \"IEEE-754 "
-"double precision\" est cette au desus de 2\\*\\*56, soit : ::"
+"double précision\" est celle au-dessus de 2\\*\\*56, soit : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:256
 msgid ""
@@ -467,7 +471,7 @@ msgid ""
 "smaller than 1/10.  But in no case can it be *exactly* 1/10!"
 msgstr ""
 "Notez que puisque l'arrondi a été fait vers le haut, le résultat est en "
-"réalité légèrement plus grand que 1/10; si nous n'avions pas arrondi par le "
+"réalité légèrement plus grand que 1/10 ; si nous n'avions pas arrondi par le "
 "haut, le quotient aurait été légèrement plus petit que 1/10. Mais dans aucun "
 "cas il ne vaut *exactement* 1/10 !"
 
@@ -476,17 +480,17 @@ msgid ""
 "So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
 "given above, the best 754 double approximation it can get::"
 msgstr ""
-"Donc l'ordinateur ne \"voit\" jamais 1/10: ce qu'il voit est la fraction "
+"Donc l'ordinateur ne \"voit\" jamais 1/10 : ce qu'il voit est la fraction "
 "exacte donnée ci-dessus, la meilleure approximation utilisant les nombres à "
-"virgule flottante double précision de l'\"IEEE-754\""
+"virgule flottante double précision de l'\"IEEE-754\" : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:270
 msgid ""
 "If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
 "decimal digits::"
 msgstr ""
-"Si on multiplie cette fraction par 10\\*\\*30, on peut observer les valeurs "
-"de ses 55 décimales de poid fort::"
+"Si nous multiplions cette fraction par 10\\*\\*30, nous pouvons observer les "
+"valeurs de ses 55 décimales de poids fort : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:276
 msgid ""
@@ -495,11 +499,11 @@ msgid ""
 "displaying the full decimal value, many languages (including older versions "
 "of Python), round the result to 17 significant digits::"
 msgstr ""
-"la valeur stockée dans l'ordinateur est donc égale à "
+"La valeur stockée dans l'ordinateur est donc égale à "
 "0,1000000000000000055511151231257827021181583404541015625. Au lieu "
 "d'afficher toutes les décimales, beaucoup de langages (dont les vieilles "
-"version de Python) arrondissent le résultat à la 17eme décimale "
-"significative."
+"versions de Python) arrondissent le résultat à la 17eme décimale "
+"significative : ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:284
 msgid ""