python
diff --git a/‎tutorial/classes.po
Lines changed: 4 additions & 4 deletions b/‎tutorial/classes.po
Lines changed: 4 additions & 4 deletions
diff --git a/‎tutorial/floatingpoint.po
Lines changed: 18 additions & 18 deletions b/‎tutorial/floatingpoint.po
Lines changed: 18 additions & 18 deletions
diff --git a/‎tutorial/interactive.po
Lines changed: 3 additions & 3 deletions b/‎tutorial/interactive.po
Lines changed: 3 additions & 3 deletions
diff --git a/‎tutorial/introduction.po
Lines changed: 30 additions & 30 deletions b/‎tutorial/introduction.po
Lines changed: 30 additions & 30 deletions
@@ -1310,10 +1310,10 @@ msgid ""
 "data values and which statement was last executed).  An example shows that "
 "generators can be trivially easy to create::"
 msgstr ""
-"Les :term:`générateur`\\s sont des outils simples et puissants pour créer "
-"des itérateurs. Ils sont écrits comme des fonctions classiques mais "
-"utilisent l'instruction :keyword:`yield` lorsqu'ils veulent renvoyer des "
-"données. À chaque fois qu'il est appelé par :func:`next`, le générateur "
+"Les :term:`générateurs <generator>` sont des outils simples et puissants "
+"pour créer des itérateurs. Ils sont écrits comme des fonctions classiques "
+"mais utilisent l'instruction :keyword:`yield` lorsqu'ils veulent renvoyer "
+"des données. À chaque fois qu'il est appelé par :func:`next`, le générateur "
 "reprend son exécution là où il s'était arrêté (en conservant tout son "
 "contexte d'exécution). Un exemple montre très bien combien les générateurs "
 "sont simples à créer ::"
 
@@ -16,7 +16,7 @@ msgstr ""
 
 #: ../Doc/tutorial/floatingpoint.rst:9
 msgid "Floating Point Arithmetic:  Issues and Limitations"
-msgstr "Arithmétique en nombres à virgule flottante : problèmes et limites"
+msgstr "Arithmétique en nombres à virgule flottante : problèmes et limites"
 
 #: ../Doc/tutorial/floatingpoint.rst:14
 msgid ""
@@ -61,7 +61,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, ::"
@@ -196,7 +196,7 @@ msgid ""
 "simply rounding the *display* of the true machine value."
 msgstr ""
 "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 "
+"illusion : vous demandez simplement à Python d'arrondir la valeur stockée "
 "réellement dans la machine à *l'affichage*."
 
 #: ../Doc/tutorial/floatingpoint.rst:114
@@ -253,7 +253,7 @@ msgid ""
 "error."
 msgstr ""
 "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 "
+"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 "
@@ -342,7 +342,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 ""
@@ -407,12 +407,12 @@ 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 fraction "
+"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 précision\" pour représenter les *floats* de Python. Les \"IEEE-754 "
-"double précision\" utilisent 53 bits de précision donc, à 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. Pour réécrire ::"
@@ -427,7 +427,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 meilleure valeur possible pour *N* est 56 : ::"
+"2**53``), la meilleure valeur possible pour *N* est 56 ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:239
 msgid ""
@@ -436,23 +436,23 @@ 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 ""
 "Since the remainder is more than half of 10, the best approximation is "
 "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 ""
 "Therefore the best possible approximation to 1/10 in 754 double precision "
 "is::"
 msgstr ""
-"Par conséquent la meilleure approximation possible pour 1/10 en \"IEEE-754 "
-"double précision\" est celle au-dessus de 2\\*\\*56, soit ::"
+"Par conséquent la meilleure approximation possible pour 1/10 en « IEEE-754 "
+"double précision » est celle au-dessus de 2\\*\\*56, soit ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:256
 msgid ""
@@ -469,7 +469,7 @@ 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 "
 "haut, le quotient aurait été légèrement plus petit que 1/10. Mais dans aucun "
-"cas il ne vaut *exactement* 1/10 !"
+"cas il ne vaut *exactement* 1/10 !"
 
 #: ../Doc/tutorial/floatingpoint.rst:264
 msgid ""
@@ -478,15 +478,15 @@ msgid ""
 msgstr ""
 "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 nous multiplions cette fraction par 10\\*\\*30, nous pouvons observer les "
-"valeurs de ses 55 décimales de poids fort : ::"
+"valeurs de ses 55 décimales de poids fort ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:276
 msgid ""
@@ -499,7 +499,7 @@ msgstr ""
 "0,1000000000000000055511151231257827021181583404541015625. Au lieu "
 "d'afficher toutes les décimales, beaucoup de langages (dont les vieilles "
 "versions de Python) arrondissent le résultat à la 17\\ :sup:`e` décimale "
-"significative : ::"
+"significative ::"
 
 #: ../Doc/tutorial/floatingpoint.rst:284
 msgid ""
 
@@ -51,7 +51,7 @@ msgid ""
 msgstr ""
 "La complétion de noms de variables et de modules est :ref:`automatiquement "
 "activée <rlcompleter-config>` au démarrage de l'interpréteur. Ainsi, la "
-"touche :kbd:`Tab` invoque la fonction de complétion ; la recherche "
+"touche :kbd:`Tab` invoque la fonction de complétion ; la recherche "
 "s'effectue dans les noms d'instructions Python, les noms des variables "
 "locales et les noms de modules disponibles. Pour les expressions pointées "
 "telles que ``string.a``, l'expression est évaluée jusqu'au dernier ``'.'`` "
@@ -82,7 +82,7 @@ msgstr ""
 "(l'analyseur sait si une indentation doit suivre) ; le mécanisme de "
 "complétion devrait utiliser la table de symboles de l'interpréteur. Une "
 "commande pour vérifier (ou même suggérer) les correspondances de "
-"parenthèses, de guillemets..., serait également utile."
+"parenthèses, de guillemets, etc., serait également utile."
 
 #: ../Doc/tutorial/interactive.rst:45
 msgid ""
@@ -93,7 +93,7 @@ msgid ""
 "interactive environment is bpython_."
 msgstr ""
 "Une alternative améliorée de l'interpréteur interactif est développée depuis "
-"maintenant quelques temps : IPython_. Il fournit la complétion, "
+"maintenant quelques temps : IPython_. Il fournit la complétion, "
 "l'exploration d'objets et une gestion avancée de l'historique. Il peut "
 "également être personnalisé en profondeur et embarqué dans d'autres "
 "applications. Un autre environnement interactif amélioré similaire est "
 
@@ -29,11 +29,11 @@ msgid ""
 "type a blank line; this is used to end a multi-line command."
 msgstr ""
 "Dans les exemples qui suivent, les entrées et sorties se distinguent par la "
-"présence ou l'absence d'invite (:term:`>>>` et :term:`...`) : pour "
+"présence ou l'absence d'invite (:term:`>>>` et :term:`...`) : pour "
 "reproduire les exemples, vous devez taper tout ce qui est après l'invite, au "
-"moment où celle-ci apparaît ; les lignes qui n'affichent pas d'invite sont "
+"moment où celle-ci apparaît ; les lignes qui n'affichent pas d'invite sont "
 "les sorties de l'interpréteur. Notez qu'une invite secondaire affichée seule "
-"sur une ligne dans un exemple indique que vous devez entrer une ligne vide ; "
+"sur une ligne dans un exemple indique que vous devez entrer une ligne vide ; "
 "ceci est utilisé pour terminer une commande multi-lignes."
 
 #: ../Doc/tutorial/introduction.rst:16
@@ -84,10 +84,10 @@ msgid ""
 "languages (for example, Pascal or C); parentheses (``()``) can be used for "
 "grouping. For example::"
 msgstr ""
-"L'interpréteur agit comme une simple calculatrice : vous pouvez lui entrer "
+"L'interpréteur agit comme une simple calculatrice : vous pouvez lui entrer "
 "une expression et il vous affiche la valeur. La syntaxe des expressions est "
-"simple : les opérateurs ``+``, ``-``, ``*`` et ``/`` fonctionnent comme dans "
-"la plupart des langages (par exemple, Pascal ou C) ; les parenthèses peuvent "
+"simple : les opérateurs ``+``, ``-``, ``*`` et ``/`` fonctionnent comme dans "
+"la plupart des langages (par exemple, Pascal ou C) ; les parenthèses peuvent "
 "être utilisées pour faire des regroupements. Par exemple ::"
 
 #: ../Doc/tutorial/introduction.rst:61
@@ -96,7 +96,7 @@ msgid ""
 "ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
 "`float`.  We will see more about numeric types later in the tutorial."
 msgstr ""
-"Les nombre entiers (comme ``2``, ``4``, ``20``) sont de type :class:`int`, "
+"Les nombres entiers (comme ``2``, ``4``, ``20``) sont de type :class:`int`, "
 "alors que les décimaux (comme ``5.0``, ``1.6``) sont de type :class:`float`. "
 "Vous trouvez plus de détails sur les types numériques plus loin dans ce "
 "tutoriel."
@@ -141,9 +141,9 @@ msgid ""
 "There is full support for floating point; operators with mixed type operands "
 "convert the integer operand to floating point::"
 msgstr ""
-"Les nombres à virgule flottante sont tout à fait admis (NdT : Python utilise "
+"Les nombres à virgule flottante sont tout à fait admis (NdT : Python utilise "
 "le point *.* comme séparateur entre la partie entière et la partie décimale "
-"des nombres, c'est la convention anglo-saxonne) ; les opérateurs avec des "
+"des nombres, c'est la convention anglo-saxonne) ; les opérateurs avec des "
 "opérandes de types différents convertissent l'opérande de type entier en "
 "type virgule flottante ::"
 
@@ -238,7 +238,7 @@ msgid ""
 "end of the line.  The following example::"
 msgstr ""
 "Les chaînes de caractères peuvent s'étendre sur plusieurs lignes. Utilisez "
-"alors des triples guillemets, simples ou doubles : ``'''...'''`` ou ``"
+"alors des triples guillemets, simples ou doubles : ``'''...'''`` ou ``"
 "\"\"\"...\"\"\"``. Les retours à la ligne sont automatiquement inclus, mais "
 "on peut l'empêcher en ajoutant ``\\`` à la fin de la ligne. L'exemple "
 "suivant ::"
@@ -249,7 +249,7 @@ msgid ""
 "included):"
 msgstr ""
 "produit l'affichage suivant (notez que le premier retour à la ligne n'est "
-"pas inclus) :"
+"pas inclus) :"
 
 #: ../Doc/tutorial/introduction.rst:204
 msgid ""
@@ -264,7 +264,7 @@ msgid ""
 "Two or more *string literals* (i.e. the ones enclosed between quotes) next "
 "to each other are automatically concatenated. ::"
 msgstr ""
-"Plusieurs chaînes de caractères, écrites littéralement (c'est à dire entre "
+"Plusieurs chaînes de caractères, écrites littéralement (c'est-à-dire entre "
 "guillemets), côte à côte, sont automatiquement concaténées. ::"
 
 #: ../Doc/tutorial/introduction.rst:217
@@ -336,7 +336,7 @@ msgid ""
 "Slice indices have useful defaults; an omitted first index defaults to zero, "
 "an omitted second index defaults to the size of the string being sliced. ::"
 msgstr ""
-"Les valeurs par défaut des indices de tranches ont une utilité ; le premier "
+"Les valeurs par défaut des indices de tranches ont une utilité ; le premier "
 "indice vaut zéro par défaut (i.e. lorsqu'il est omis), le deuxième "
 "correspond par défaut à la taille de la chaîne de caractères ::"
 
@@ -359,8 +359,8 @@ msgid ""
 "from *i* to *j* consists of all characters between the edges labeled *i* and "
 "*j*, respectively."
 msgstr ""
-"La première ligne de nombres donne la position des indices 0...6 dans la "
-"chaîne ; la deuxième ligne donne l'indice négatif correspondant. La tranche "
+"La première ligne de nombres donne la position des indices 0…6 dans la "
+"chaîne ; la deuxième ligne donne l'indice négatif correspondant. La tranche "
 "de *i* à *j* est constituée de tous les caractères situés entre les bords "
 "libellés *i* et *j*, respectivement."
 
@@ -392,8 +392,8 @@ msgid ""
 "assigning to an indexed position in the string results in an error::"
 msgstr ""
 "Les chaînes de caractères, en Python, ne peuvent pas être modifiées. On dit "
-"qu'elles sont :term:`immuable`\\s. Affecter une nouvelle valeur à un indice "
-"dans une chaîne produit une erreur ::"
+"qu'elles sont :term:`immuables <immutable>`. Affecter une nouvelle valeur à "
+"un indice dans une chaîne produit une erreur ::"
 
 #: ../Doc/tutorial/introduction.rst:337
 msgid "If you need a different string, you should create a new one::"
@@ -414,7 +414,7 @@ msgid ""
 "Strings are examples of *sequence types*, and support the common operations "
 "supported by such types."
 msgstr ""
-"Les chaînes de caractères sont des exemples de *types séquences* ; elles "
+"Les chaînes de caractères sont des exemples de *types séquences* ; elles "
 "acceptent donc les opérations classiques prises en charge par ces types."
 
 #: ../Doc/tutorial/introduction.rst:359
@@ -470,8 +470,8 @@ msgid ""
 "items of different types, but usually the items all have the same type. ::"
 msgstr ""
 "Python connaît différents types de données *combinés*, utilisés pour "
-"regrouper plusieurs valeurs. La plus souple est la *liste*, qui peut être "
-"écrite comme une suite, placée entre crochets, de valeurs (éléments) séparés "
+"regrouper plusieurs valeurs. Le plus souple est la *liste*, qui peut être "
+"écrit comme une suite, placée entre crochets, de valeurs (éléments) séparées "
 "par des virgules. Les éléments d'une liste ne sont pas obligatoirement tous "
 "du même type, bien qu'à l'usage ce soit souvent le cas. ::"
 
@@ -502,8 +502,8 @@ msgid ""
 "Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
 "type, i.e. it is possible to change their content::"
 msgstr ""
-"Mais à la différence des chaînes qui sont :term:`immuable`\\s, les listes "
-"sont :term:`muables <mutable>`\\s : il est possible de modifier leur "
+"Mais à la différence des chaînes qui sont :term:`immuables <immutable>`, les "
+"listes sont :term:`muables <mutable>` : il est possible de modifier leur "
 "contenu ::"
 
 #: ../Doc/tutorial/introduction.rst:418
@@ -563,7 +563,7 @@ msgid ""
 "all evaluated first before any of the assignments take place.  The right-"
 "hand side expressions are evaluated  from the left to the right."
 msgstr ""
-"La première ligne contient une *affectation multiple* : les variables ``a`` "
+"La première ligne contient une *affectation multiple* : les variables ``a`` "
 "et ``b`` se voient affecter simultanément leurs nouvelles valeurs 0 et 1. "
 "Cette méthode est encore utilisée à la dernière ligne, pour démontrer que "
 "les expressions sur la partie droite de l'affectation sont toutes évaluées "
@@ -581,13 +581,13 @@ msgid ""
 "than), ``>`` (greater than), ``==`` (equal to), ``<=`` (less than or equal "
 "to), ``>=`` (greater than or equal to) and ``!=`` (not equal to)."
 msgstr ""
-"La boucle :keyword:`while` s'exécute tant que la condition (ici : ``a < "
+"La boucle :keyword:`while` s'exécute tant que la condition (ici : ``a < "
 "10``) reste vraie. En Python, comme en C, tout entier différent de zéro est "
 "vrai et zéro est faux. La condition peut aussi être une chaîne de "
-"caractères, une liste, ou en fait toute séquence ; une séquence avec une "
+"caractères, une liste, ou en fait toute séquence ; une séquence avec une "
 "valeur non nulle est vraie, une séquence vide est fausse. Le test utilisé "
 "dans l'exemple est une simple comparaison. Les opérateurs de comparaison "
-"standards sont écrits comme en C : ``<`` (inférieur), ``>`` (supérieur), "
+"standards sont écrits comme en C : ``<`` (inférieur), ``>`` (supérieur), "
 "``==`` (égal), ``<=`` (inférieur ou égal), ``>=`` (supérieur ou égal) et ``!"
 "=`` (non égal)."
 
@@ -602,11 +602,11 @@ msgid ""
 "(since the parser cannot guess when you have typed the last line).  Note "
 "that each line within a basic block must be indented by the same amount."
 msgstr ""
-"Le *corps* de la boucle est *indenté* : l'indentation est la méthode "
+"Le *corps* de la boucle est *indenté* : l'indentation est la méthode "
 "utilisée par Python pour regrouper des instructions. En mode interactif, "
 "vous devez saisir une tabulation ou des espaces pour chaque ligne indentée. "
 "En pratique, vous aurez intérêt à utiliser un éditeur de texte pour les "
-"saisies plus compliquées ; tous les éditeurs de texte dignes de ce nom "
+"saisies plus compliquées ; tous les éditeurs de texte dignes de ce nom "
 "disposent d'une fonction d'auto-indentation. Lorsqu'une expression composée "
 "est saisie en mode interactif, elle doit être suivie d'une ligne vide pour "
 "indiquer qu'elle est terminée (car l'analyseur ne peut pas deviner que vous "
@@ -622,7 +622,7 @@ msgid ""
 "without quotes, and a space is inserted between items, so you can format "
 "things nicely, like this::"
 msgstr ""
-"La fonction :func:`print` écrit les valeur des paramètres qui lui sont "
+"La fonction :func:`print` écrit les valeurs des paramètres qui lui sont "
 "fournis. Ce n'est pas la même chose que d'écrire l'expression que vous "
 "voulez afficher (comme nous l'avons fait dans l'exemple de la calculatrice), "
 "en raison de la manière qu'a ``print`` de gérer les paramètres multiples, "
@@ -650,7 +650,7 @@ msgid ""
 msgstr ""
 "Puisque ``**`` est prioritaire sur ``-``, ``-3 ** 2`` est interprété ``-(3 "
 "** 2)`` et vaut donc ``-9``. Pour éviter cela et obtenir ``9``, utilisez des "
-"parenthèses : ``(-3) ** 2``."
+"parenthèses : ``(-3) ** 2``."
 
 #: ../Doc/tutorial/introduction.rst:543
 msgid ""