Merge branch '3.6' into tutowhatnow

2018-02-17 21:19:57 +01:00 · 2018-02-17 21:19:57 +01:00 · d1bef68c54
commit d1bef68c54
parent dd6421f7b9 f302fcb215
68 changed files with 911 additions and 911 deletions
--- a/tutorial/appendix.po
+++ b/tutorial/appendix.po
@ -9,7 +9,7 @@ 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: YEAR-MO-DA HO:MI+ZONE\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" 
 "Language: fr\n" 
@ -170,7 +170,7 @@ msgstr ""
  
 #: ../Doc/tutorial/appendix.rst:102 
 msgid "The Customization Modules" 
-msgstr "Les modules de Personnalisation" 
+msgstr "Les modules de personnalisation" 
  
 #: ../Doc/tutorial/appendix.rst:104 
 msgid "" 
--- a/tutorial/classes.po
+++ b/tutorial/classes.po
--- a/tutorial/errors.po
+++ b/tutorial/errors.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-05-16 22:24+0200\n" 
+"PO-Revision-Date: 2018-02-10 15:24+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 1.8.11\n" 
+"X-Generator: Poedit 2.0.2\n" 
  
 #: ../Doc/tutorial/errors.rst:5 
 msgid "Errors and Exceptions" 
@ -27,10 +27,10 @@ msgid ""
 "tried out the examples you have probably seen some. There are (at least) " 
 "two distinguishable kinds of errors: *syntax errors* and *exceptions*." 
 msgstr "" 
-"Jusqu'à maintenant, les messages d'erreurs ont seulement été mentionnés, " 
-"mais si vous avez essayé les exemples vous avez certainement vu plus que " 
-"cela. En fait, il y a au moins deux types d'erreurs à distinguer : les " 
-"*erreurs de syntaxe* et les *exceptions*." 
+"Jusqu'ici, les messages d'erreurs ont seulement été mentionnés. Mais si vous " 
+"avez essayé les exemples vous avez certainement vu plus que cela. En fait, " 
+"il y a au moins deux types d'erreurs à distinguer : les *erreurs de syntaxe* " 
+"et les *exceptions*." 
  
 #: ../Doc/tutorial/errors.rst:15 
 msgid "Syntax Errors" 
@ -54,12 +54,12 @@ msgid ""
 "colon (``':'``) is missing before it. File name and line number are printed " 
 "so you know where to look in case the input came from a script." 
 msgstr "" 
-"L'analyseur répère la ligne incriminée et affiche une petite 'flèche' " 
+"L'analyseur indique la ligne incriminée et affiche une petite 'flèche' " 
 "pointant vers le premier endroit de la ligne où l'erreur a été détectée. " 
 "L'erreur est causée (ou, au moins, a été détectée comme telle) par le " 
 "symbole placé *avant* la flèche. Dans cet exemple la flèche est sur la " 
-"fonction :func:`print` car il manque deux points (``':'``) justeavant. Le " 
-"nom de fichier et le numéro de ligne sont affichés pour vous permettre de " 
+"fonction :func:`print` car il manque deux points (``':'``) juste avant. Le " 
+"nom du fichier et le numéro de ligne sont affichés pour vous permettre de " 
 "localiser facilement l'erreur lorsque le code provient d'un script." 
  
 #: ../Doc/tutorial/errors.rst:37 
@ -77,8 +77,8 @@ msgid ""
 msgstr "" 
 "Même si une instruction ou une expression est syntaxiquement correcte, elle " 
 "peut générer une erreur lors de son exécution. Les erreurs détectées durant " 
-"l'exécution son appelées des *exceptions* et ne sont pas toujours fatales : " 
-"vous apprendrez bientôt comment les traîter dans vos programmes. La plupart " 
+"l'exécution sont appelées des *exceptions* et ne sont pas toujours fatales : " 
+"nous apprendrons bientôt comment les traiter dans vos programmes. La plupart " 
 "des exceptions toutefois ne sont pas prises en charge par les programmes, ce " 
 "qui génère des messages d'erreurs comme celui-ci : ::" 
  
@ -93,12 +93,12 @@ msgid ""
 "convention). Standard exception names are built-in identifiers (not reserved " 
 "keywords)." 
 msgstr "" 
-"La dernière ligne du message d'erreur indique la cause de l'erreur. Les " 
-"exceptions peuvent être de différents types, et ce type est indiqué dans le " 
+"La dernière ligne du message d'erreur indique ce qui s'est passé. Les " 
+"exceptions peuvent être de différents types et ce type est indiqué dans le " 
 "message : les types indiqués dans l'exemple sont :exc:`ZeroDivisionError`, :" 
 "exc:`NameError` et :exc:`TypeError`. Le texte affiché comme type de " 
 "l'exception est le nom de l'exception native qui a été déclenchée. Ceci est " 
-"vrai pour toutes les exceptions natives, mais n'est pas une obligation pour " 
+"vrai pour toutes les exceptions natives mais n'est pas une obligation pour " 
 "les exceptions définies par l'utilisateur (même si c'est une convention bien " 
 "pratique). Les noms des exceptions standards sont des identifiants natifs " 
 "(pas des mots réservés)." 
@ -109,7 +109,7 @@ msgid ""
 "caused it." 
 msgstr "" 
 "Le reste de la ligne fournit plus de détails en fonction du type de " 
-"l'exception et de ce qui l'a causé." 
+"l'exception et de ce qui l'a causée." 
  
 #: ../Doc/tutorial/errors.rst:69 
 msgid "" 
@ -118,17 +118,18 @@ msgid ""
 "a stack traceback listing source lines; however, it will not display lines " 
 "read from standard input." 
 msgstr "" 
-"La partie précédente du message d'erreur montre le contexte dans lequel " 
-"s'est produite l'exception, sous la forme d'une trace de pile d'exécution. " 
-"En général, celle-ci contient les lignes du code source ; toutefois, les " 
-"lignes lues à partir de l'entrée standard ne seront pas affichées." 
+"La partie précédente dans le message d'erreur indique le contexte dans " 
+"lequel s'est produite l'exception, sous la forme d'une trace de pile " 
+"d'exécution. En général, celle-ci contient les lignes du code source ; " 
+"toutefois, les lignes lues à partir de l'entrée standard ne sont pas " 
+"affichées." 
  
 #: ../Doc/tutorial/errors.rst:74 
 msgid "" 
 ":ref:`bltin-exceptions` lists the built-in exceptions and their meanings." 
 msgstr "" 
-"Vous trouverez dans :ref:`bltin-exceptions` la liste des exceptions natives " 
-"et leur signification." 
+"Vous trouvez la liste des exceptions natives et leur signification dans :ref:" 
+"`bltin-exceptions`." 
  
 #: ../Doc/tutorial/errors.rst:80 
 msgid "Handling Exceptions" 
@ -147,29 +148,29 @@ msgstr ""
 "exceptions. Regardez l'exemple suivant, qui demande une saisie à " 
 "l'utilisateur jusqu'à ce qu'un entier valide ait été entré, mais permet à " 
 "l'utilisateur d'interrompre le programme (en utilisant :kbd:`Control-C` ou " 
-"un autre raccourci que le système supporte) ; notez qu'une interruption " 
+"un autre raccourci que le système accepte) ; notez qu'une interruption " 
 "générée par l'utilisateur est signalée en levant l'exception :exc:" 
 "`KeyboardInterrupt`." 
  
 #: ../Doc/tutorial/errors.rst:96 
 msgid "The :keyword:`try` statement works as follows." 
-msgstr "L'instruction :keyword:`try` fonctionne comme ceci." 
+msgstr "L'instruction :keyword:`try` fonctionne comme ceci :" 
  
 #: ../Doc/tutorial/errors.rst:98 
 msgid "" 
 "First, the *try clause* (the statement(s) between the :keyword:`try` and :" 
 "keyword:`except` keywords) is executed." 
 msgstr "" 
-"Premièrement, la *clause try* (instruction(s) placée(s) entre les mots-clés :" 
-"keyword:`try` et :keyword:`except`) est exécutée." 
+"premièrement, la *clause try* (instruction(s) placée(s) entre les mots-clés :" 
+"keyword:`try` et :keyword:`except`) est exécutée ;" 
  
 #: ../Doc/tutorial/errors.rst:101 
 msgid "" 
 "If no exception occurs, the *except clause* is skipped and execution of the :" 
 "keyword:`try` statement is finished." 
 msgstr "" 
-"Si aucune exception n'intervient, la *clause except* est sautée et " 
-"l'exécution de l'instruction :keyword:`try` est terminée." 
+"si aucune exception n'intervient, la clause ``except`` est sautée et " 
+"l'exécution de l'instruction :keyword:`try` est terminée ;" 
  
 #: ../Doc/tutorial/errors.rst:104 
 msgid "" 
@ -178,11 +179,11 @@ msgid ""
 "keyword:`except` keyword, the except clause is executed, and then execution " 
 "continues after the :keyword:`try` statement." 
 msgstr "" 
-"Si une exception intervient pendant l'exécution de la clause 'try', le reste " 
-"de cette clause est sauté. Si son type correspond à un nom d'exception " 
-"indiqué après le mot-clé :keyword:`except`, la clause 'except' " 
+"si une exception intervient pendant l'exécution de la clause ``try``, le reste " 
+"de cette clause est sauté. Si le type d'exception levée correspond à un nom " 
+"indiqué après le mot-clé :keyword:`except`, la clause ``except`` " 
 "correspondante est exécutée, puis l'exécution continue après l'instruction :" 
-"keyword:`try`." 
+"keyword:`try` ;" 
  
 #: ../Doc/tutorial/errors.rst:109 
 msgid "" 
@ -191,8 +192,8 @@ msgid ""
 "handler is found, it is an *unhandled exception* and execution stops with a " 
 "message as shown above." 
 msgstr "" 
-"Si une exception intervient qui ne corresponde à aucune exception mentionnée " 
-"dans la clause 'except', elle est transmise à l'instruction :keyword:`try` " 
+"si une exception intervient et ne correspond à aucune exception mentionnée " 
+"dans la clause ``except``, elle est transmise à l'instruction :keyword:`try` " 
 "de niveau supérieur ; si aucun gestionnaire d'exception n'est trouvé, il " 
 "s'agit d'une *exception non gérée* et l'exécution s'arrête avec un message " 
 "comme indiqué ci-dessus." 
@ -205,13 +206,13 @@ msgid ""
 "not in other handlers of the same :keyword:`try` statement. An except " 
 "clause may name multiple exceptions as a parenthesized tuple, for example::" 
 msgstr "" 
-"Une instruction :keyword:`try` peut comporter plusieurs clauses except, pour " 
-"permettre la prise en charge de différentes exceptions. Mais un seul " 
+"Une instruction :keyword:`try` peut comporter plusieurs clauses ``except`` " 
+"pour permettre la prise en charge de différentes exceptions. Mais un seul " 
 "gestionnaire, au plus, sera exécuté. Les gestionnaires ne prennent en charge " 
-"que les exceptions qui interviennent dans la clause try correspondante, pas " 
-"dans d'autres gestionnaires de la même instruction :keyword:`try`. Mais une " 
-"même clause except peut citer plusieurs exceptions sous la forme d'un tuple " 
-"entre parenthèses, comme dans cet exemple : ::" 
+"que les exceptions qui interviennent dans la clause `try` correspondante, " 
+"pas dans d'autres gestionnaires de la même instruction :keyword:`try`. Mais " 
+"une même clause ``except`` peut citer plusieurs exceptions sous la forme d'un " 
+"tuple entre parenthèses, comme dans cet exemple : ::" 
  
 #: ../Doc/tutorial/errors.rst:123 
 msgid "" 
@ -221,18 +222,18 @@ msgid ""
 "class). For example, the following code will print B, C, D in that order::" 
 msgstr "" 
 "Une classe dans une clause :keyword:`except` est compatible avec une " 
-"exception si elle est de la même classe ou d'une de ses classes dérivées " 
-"(mais l'inverse n'est pas vrai --- une clause except spécifiant une classe " 
-"dérivée n'est pas compatible avec une classe de base.) Par exemple, le code " 
-"suivant affichera B, C et D dans cet ordre : ::" 
+"exception si elle est de la même classe ou d'une de ses classes dérivées. " 
+"Mais l'inverse n'est pas vrai, une clause ``except`` spécifiant une classe " 
+"dérivée n'est pas compatible avec une classe de base. Par exemple, le code " 
+"suivant affiche B, C et D dans cet ordre : ::" 
  
 #: ../Doc/tutorial/errors.rst:147 
 msgid "" 
 "Note that if the except clauses were reversed (with ``except B`` first), it " 
 "would have printed B, B, B --- the first matching except clause is triggered." 
 msgstr "" 
-"Notez que si les clauses except avaient été inversées (avec ``except B`` en " 
-"premier), il aurait affiché B, B, B --- la première clause except " 
+"Notez que si les clauses ``except`` avaient été inversées (avec ``except B`` " 
+"en premier), il aurait affiché B, B, B --- la première clause ``except`` " 
 "correspondante étant déclenchée." 
  
 #: ../Doc/tutorial/errors.rst:150 
@ -243,12 +244,12 @@ msgid ""
 "message and then re-raise the exception (allowing a caller to handle the " 
 "exception as well)::" 
 msgstr "" 
-"La dernière clause except peut omettre le(s) nom(s) d'exception(s), pour " 
-"servir de joker. C'est toutefois à utiliser avec beaucoup de précautions, " 
-"car il est très facile de masquer une vraie erreur de programmation par ce " 
-"biais. Elle peut aussi être utilisée pour afficher un message d'erreur avant " 
-"de re-lever l'exception (en permettant à un appelant de prendre également en " 
-"charge l'exception) ::" 
+"La dernière clause ``except`` peut omettre le(s) nom(s) d'exception(s) et " 
+"joue alors le rôle de joker. C'est toutefois à utiliser avec beaucoup de " 
+"précautions car il est facile de masquer une vraie erreur de programmation " 
+"par ce biais. Elle peut aussi être utilisée pour afficher un message " 
+"d'erreur avant de propager l'exception (en permettant à un appelant de gérer " 
+"également l'exception) ::" 
  
 #: ../Doc/tutorial/errors.rst:169 
 msgid "" 
@ -257,10 +258,11 @@ msgid ""
 "for code that must be executed if the try clause does not raise an " 
 "exception. For example::" 
 msgstr "" 
-"L'instruction :keyword:`try` ... :keyword:`except` a également une *clause " 
-"else* optionnelle qui, lorsqu'elle est présente, doit suivre toutes les " 
-"clauses except. Elle est utile pour du code qui doit être exécuté " 
-"lorsqu'aucune exception n'a été levée par la clause try. Par exemple : ::" 
+"L'instruction :keyword:`try` ... :keyword:`except` accepte également une " 
+"*clause else* optionnelle qui, lorsqu'elle est présente, doit se placer " 
+"après toutes les clauses ``except``. Elle est utile pour du code qui doit " 
+"être exécuté lorsqu'aucune exception n'a été levée par la clause try. Par " 
+"exemple : ::" 
  
 #: ../Doc/tutorial/errors.rst:183 
 msgid "" 
@ -269,8 +271,8 @@ msgid ""
 "exception that wasn't raised by the code being protected by the :keyword:" 
 "`try` ... :keyword:`except` statement." 
 msgstr "" 
-"Il vaut mieux utiliser la clause :keyword:`else`, plutôt que d'ajouter du " 
-"code à la clause :keyword:`try`, car cela évite de capturer accidentellement " 
+"Il vaut mieux utiliser la clause :keyword:`else` plutôt que d'ajouter du " 
+"code à la clause :keyword:`try` car cela évite de capturer accidentellement " 
 "une exception qui n'a pas été levée par le code initialement protégé par " 
 "l'instruction :keyword:`try` ... :keyword:`except`." 
  
@ -281,8 +283,8 @@ msgid ""
 "exception type." 
 msgstr "" 
 "Quand une exception intervient, une valeur peut lui être associée, que l'on " 
-"appelle également *l'argument* de l'exception. La présence de cet argument " 
-"et son type dépendent du type de l'exception." 
+"appelle *l'argument* de l'exception. La présence de cet argument et son type " 
+"dépendent du type de l'exception." 
  
 #: ../Doc/tutorial/errors.rst:192 
 msgid "" 
@ -293,13 +295,13 @@ msgid ""
 "reference ``.args``. One may also instantiate an exception first before " 
 "raising it and add any attributes to it as desired. ::" 
 msgstr "" 
-"La clause except peut spécifier un nom de variable après le nom de " 
+"La clause ``except`` peut spécifier un nom de variable après le nom de " 
 "l'exception. Cette variable est liée à une instance d'exception avec les " 
 "arguments stockés dans ``instance.args``. Pour plus de commodité, l'instance " 
 "de l'exception définit la méthode :meth:`__str__` afin que les arguments " 
 "puissent être affichés directement sans avoir à référencer ``.args``. Il est " 
-"possible de construire une exception, y ajouter ses attributs, puis la " 
-"lancer plus tard. ::" 
+"possible de construire une exception, y ajouter ses attributs, puis la lever " 
+"plus tard. ::" 
  
 #: ../Doc/tutorial/errors.rst:216 
 msgid "" 
@ -342,8 +344,9 @@ msgid ""
 msgstr "" 
 "Le seul argument à :keyword:`raise` indique l'exception à déclencher. Cela " 
 "peut être soit une instance d'exception, soit une classe d'exception (une " 
-"classe dérivée de :class:`Exception`). Si une classe est donnée, elle sera " 
-"implicitement instanciée via l'appel de son constructeur, sans arguments : ::" 
+"classe dérivée de :class:`Exception`). Si une classe est donnée, elle est " 
+"implicitement instanciée *via* l'appel de son constructeur, sans " 
+"argument : ::" 
  
 #: ../Doc/tutorial/errors.rst:254 
 msgid "" 
@ -351,9 +354,9 @@ msgid ""
 "handle it, a simpler form of the :keyword:`raise` statement allows you to re-" 
 "raise the exception::" 
 msgstr "" 
-"Si vous devez savoir qu'une exception a été levée mais sans intention de la " 
-"prendre en charge, une forme plus simple de l'instruction :keyword:`raise` " 
-"permet de re-déclencher l'exception : ::" 
+"Si vous avez besoin de savoir si une exception a été levée mais que vous " 
+"n'avez pas intention de la gérer, une forme plus simple de l'instruction :" 
+"keyword:`raise` permet de propager l'exception : ::" 
  
 #: ../Doc/tutorial/errors.rst:273 
 msgid "User-defined Exceptions" 
@ -382,12 +385,12 @@ msgid ""
 "error conditions::" 
 msgstr "" 
 "Les classes d'exceptions peuvent être définies pour faire tout ce qu'une " 
-"autre classe peut faire. Mais elles sont le plus souvent assez simples, " 
+"autre classe peut faire. Elles sont le plus souvent gardées assez simples, " 
 "n'offrant que les attributs permettant aux gestionnaires de ces exceptions " 
 "d'extraire les informations relatives à l'erreur qui s'est produite. Lorsque " 
 "l'on crée un module qui peut déclencher plusieurs types d'erreurs distincts, " 
 "une pratique courante est de créer une classe de base pour l'ensemble des " 
-"exceptions définies dans ce module, et de créer des sous-classes spécifiques " 
+"exceptions définies dans ce module et de créer des sous-classes spécifiques " 
 "d'exceptions pour les différentes conditions d'erreurs : ::" 
  
 #: ../Doc/tutorial/errors.rst:317 
@ -396,7 +399,7 @@ msgid ""
 "naming of the standard exceptions." 
 msgstr "" 
 "La plupart des exceptions sont définies avec des noms qui se terminent par " 
-"\"Error\", comme pour les exceptions standards." 
+"\"Error\", comme les exceptions standards." 
  
 #: ../Doc/tutorial/errors.rst:320 
 msgid "" 
@ -404,10 +407,10 @@ msgid ""
 "occur in functions they define. More information on classes is presented in " 
 "chapter :ref:`tut-classes`." 
 msgstr "" 
-"La plupart des modules standards définissent leurs propres exceptions pour " 
-"décrire les erreurs que l'on peut rencontrer dans les fonctions qu'ils " 
-"définissent. Plus d'informations sur les classes sont présentées dans le " 
-"chapitre :ref:`tut-classes`." 
+"Beaucoup de modules standards définissent leurs propres exceptions pour " 
+"signaler les erreurs possibles dans les fonctions qu'ils définissent. Plus " 
+"d'informations sur les classes sont présentées dans le chapitre :ref:`tut-" 
+"classes`." 
  
 #: ../Doc/tutorial/errors.rst:328 
 msgid "Defining Clean-up Actions" 
@ -436,15 +439,15 @@ msgid ""
 "more complicated example::" 
 msgstr "" 
 "Une *clause finally* est toujours exécutée avant de quitter l'instruction :" 
-"keyword:`try`, qu'une exception ait été déclenchée ou non. Quand " 
-"uneexception a été déclenchée dans la clause :keyword:`try` et n'a pas été " 
-"prise en charge par une clause :keyword:`except` (ou si elle a été " 
-"déclenchée dans une clause :keyword:`except` ou :keyword:`else`), elle est " 
-"re-déclenchée après l'exécution de la clause :keyword:`finally`. La clause :" 
-"keyword:`finally` est également exécutée \"à la sortie\" quand " 
-"n'importequelle autre clause de l'instruction :keyword:`try` est abandonnée " 
-"par une instruction :keyword:`break`, :keyword:`continue` ou :keyword:" 
-"`return`. Voici un exemple plus compliqué : ::" 
+"keyword:`try`, qu'une exception ait été levée ou non. Quand une exception a " 
+"été levée dans la clause :keyword:`try` et n'a pas été prise en charge par " 
+"une clause :keyword:`except` (ou si elle a été levée dans une clause :" 
+"keyword:`except` ou :keyword:`else`), elle est propagée après l'exécution de " 
+"la clause :keyword:`finally`. La clause :keyword:`finally` est également " 
+"exécutée \"à la sortie\" quand n'importe quelle autre clause de " 
+"l'instruction :keyword:`try` est abandonnée par une instruction :keyword:" 
+"`break`, :keyword:`continue` ou :keyword:`return`. Voici un exemple plus " 
+"compliqué : ::" 
  
 #: ../Doc/tutorial/errors.rst:377 
 msgid "" 
@ -454,10 +457,10 @@ msgid ""
 "clause has been executed." 
 msgstr "" 
 "Comme vous pouvez le voir, la clause :keyword:`finally` est exécutée dans " 
-"tous les cas. L'exception de type :exc:`TypeError` déclenchée en divisant " 
-"deux chaînes de caractères n'est pas prise en charge par la clause :keyword:" 
-"`except` et est donc re-déclenchée après que la clause :keyword:`finally` " 
-"ait été exécutée." 
+"tous les cas. L'exception de type :exc:`TypeError`, déclenchée en divisant " 
+"deux chaînes de caractères, n'est pas prise en charge par la clause :keyword:" 
+"`except` et est donc propagée après que la clause :keyword:`finally` a été " 
+"exécutée." 
  
 #: ../Doc/tutorial/errors.rst:382 
 msgid "" 
@ -465,9 +468,9 @@ msgid ""
 "releasing external resources (such as files or network connections), " 
 "regardless of whether the use of the resource was successful." 
 msgstr "" 
-"Dans les vraies applicatons, la clause :keyword:`finally` est notamment " 
+"Dans les vraies applications, la clause :keyword:`finally` est notamment " 
 "utile pour libérer des ressources externes (telles que des fichiers ou des " 
-"connections réseau), que l'utilisation de ces ressources ait réussi ou non." 
+"connexions réseau), quelle qu'ait été l'utilisation de ces ressources." 
  
 #: ../Doc/tutorial/errors.rst:390 
 msgid "Predefined Clean-up Actions" 
@ -496,7 +499,7 @@ msgid ""
 "correctly. ::" 
 msgstr "" 
 "Le problème avec ce code est qu'il laisse le fichier ouvert pendant une " 
-"durée indéterminée après que le code ait fini de s'exécuter. Ce n'est pas un " 
+"durée indéterminée après que le code a fini de s'exécuter. Ce n'est pas un " 
 "problème avec des scripts simples, mais peut l'être au sein d'applications " 
 "plus conséquentes. L'instruction :keyword:`with` permet d'utiliser certains " 
 "objets comme des fichiers d'une façon qui assure qu'ils seront toujours " 
@ -509,7 +512,7 @@ msgid ""
 "files, provide predefined clean-up actions will indicate this in their " 
 "documentation." 
 msgstr "" 
-"Dès que l'instruction est exécutée, le fichier *f* est toujours fermé, même " 
-"si un problème est survenu pendant l'exécution de ces lignes. D'autres " 
+"Après l'exécution du bloc, le fichier *f* est toujours fermé, " 
+"même si un problème est survenu pendant l'exécution de ces lignes. D'autres " 
 "objets qui, comme pour les fichiers, fournissent des actions de nettoyage " 
 "prédéfinies l'indiquent dans leur documentation." 
--- a/tutorial/floatingpoint.po
+++ b/tutorial/floatingpoint.po
@ -9,7 +9,7 @@ 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: YEAR-MO-DA HO:MI+ZONE\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" 
 "Language: fr\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 nombre à virgule flottante : problèmes et limites" 
  
 #: ../Doc/tutorial/floatingpoint.rst:14 
 msgid "" 
--- a/tutorial/inputoutput.po
+++ b/tutorial/inputoutput.po
@ -8,7 +8,7 @@ msgstr ""
 "Project-Id-Version: Python 3.6\n" 
 "Report-Msgid-Bugs-To: \n" 
 "POT-Creation-Date: 2017-08-10 00:20+0200\n" 
-"PO-Revision-Date: 2017-09-22 10:13+0200\n" 
+"PO-Revision-Date: 2018-02-09 23:13+0100\n" 
 "Last-Translator: \n" 
 "Language-Team: \n" 
 "Language: fr\n" 
@ -28,9 +28,9 @@ msgid ""
 "chapter will discuss some of the possibilities." 
 msgstr "" 
 "Il existe bien des moyens de présenter les sorties d'un programmes ; les " 
-"données peuvent être imprimées sous une forme lisible par un être humain, ou " 
+"données peuvent être affichées sous une forme lisible par un être humain ou " 
 "sauvegardées dans un fichier pour une utilisation future. Ce chapitre " 
-"présentera donc diverses possibilités." 
+"présente quelques possibilités." 
  
 #: ../Doc/tutorial/inputoutput.rst:15 
 msgid "Fancier Output Formatting" 
@ -43,11 +43,11 @@ msgid ""
 "method of file objects; the standard output file can be referenced as ``sys." 
 "stdout``. See the Library Reference for more information on this.)" 
 msgstr "" 
-"Jusque là, nous avons rencontré deux moyens d'écrire des données : les " 
-"*déclarations d'expressions* et la fonction :func:`print`. (Une troisième " 
-"méthode consiste à utiliser la méthode :meth:`write` des fichiers, le " 
-"fichier de sortie standard peut être référence en tant que ``sys.stdout``. " 
-"Voyez le Guide de Référence de la Bibliothèque Standard pour en savoir plus.)" 
+"Jusqu'ici, nous avons rencontré deux moyens d'écrire des données : les " 
+"*déclarations d'expressions* et la fonction :func:`print`. Une troisième " 
+"méthode consiste à utiliser la méthode :meth:`write` des fichiers, avec le " 
+"fichier de sortie standard référencé en tant que ``sys.stdout``. Voyez le " 
+"Guide de Référence de la Bibliothèque Standard pour en savoir plus." 
  
 #: ../Doc/tutorial/inputoutput.rst:22 
 msgid "" 
@ -61,14 +61,13 @@ msgid ""
 "<f-strings>`, or the :meth:`str.format` method." 
 msgstr "" 
 "Souvent, vous voudrez plus de contrôle sur le formatage de votre sortie que " 
-"simplement afficher des valeurs séparées par des espaces. Il y a deux façons " 
-"de formatter votre sortie. La première est de le faire vous-même, en " 
-"utilisant des opérations slicing et de concaténation vous pouvez créer " 
-"toutes les dispositions que vous imaginez ; le type ``string`` a des " 
-"méthodes qui effectuent des opérations utiles pour aligner des chaines à une " 
-"certaine largeur de colonne, qui seront discutées sous peu. La seconde est " 
-"d'utiliser des :ref:`littéraux de chaine formatés <f-strings>` ou la " 
-"méthode :meth:`str.format`." 
+"des valeurs simplement séparées par des espaces. Il existe deux façons de " 
+"mettre en forme votre sortie. La première est de le faire vous-même : en " 
+"découpant et concaténant les chaînes, vous pouvez tout mettre en page comme " 
+"vous l'imaginez ; le type ``string`` possède des méthodes pour aligner des " 
+"chaines à une certaine largeur de colonne, nous voyons ceci un peu plus " 
+"loin. La deuxième consiste à utiliser des :ref:`littéraux de chaine formatés " 
+"<f-strings>` ou la méthode :meth:`str.format`." 
  
 #: ../Doc/tutorial/inputoutput.rst:31 
 msgid "" 
@ -76,8 +75,7 @@ msgid ""
 "offers yet another way to substitute values into strings." 
 msgstr "" 
 "Le module :mod:`string` contient une classe :class:`~string.Template` qui " 
-"offre encore une autre façon de remplacer des valeurs au sein de chaînes de " 
-"caractères." 
+"permet aussi de remplacer des valeurs au sein de chaînes de caractères." 
  
 #: ../Doc/tutorial/inputoutput.rst:34 
 msgid "" 
@ -101,16 +99,16 @@ msgid ""
 "structures like lists and dictionaries, have the same representation using " 
 "either function. Strings, in particular, have two distinct representations." 
 msgstr "" 
-"La fonction :func:`str` est destinée à renvoyer des représentations de " 
-"valeurs qui soient lisibles par un être humain, alors que la fonction :func:" 
-"`repr` est destinée à générer des représentations qui puissent être lues par " 
-"l'interpréteur (ou forceront une :exc:`SyntaxError` s'il n'existe aucune " 
+"La fonction :func:`str` est destinée à représenter les valeurs sous une " 
+"forme lisible par un être humain, alors que la fonction :func:`repr` est " 
+"destinée à générer des représentations qui puissent être lues par " 
+"l'interpréteur (ou qui lèvera une :exc:`SyntaxError` s'il n'existe aucune " 
 "syntaxe équivalente). Pour les objets qui n'ont pas de représentation " 
-"humaine spécifique, :func:`str` renverra la même valeur que :func:`repr`. " 
+"humaine spécifique, :func:`str` renvoie la même valeur que :func:`repr`. " 
 "Beaucoup de valeurs, comme les nombres ou les structures telles que les " 
 "listes ou les dictionnaires, ont la même représentation en utilisant les " 
-"deux fonctions. Les chaînes de caractères et les nombres à virgule " 
-"flottante, en revanche, ont deux représentations distinctes." 
+"deux fonctions. Les chaînes de caractères, en particulier, ont deux " 
+"représentations distinctes." 
  
 #: ../Doc/tutorial/inputoutput.rst:47 
 msgid "Some examples::" 
@ -125,9 +123,9 @@ msgid ""
 "(Note that in the first example, one space between each column was added by " 
 "the way :func:`print` works: it always adds spaces between its arguments.)" 
 msgstr "" 
-"(Notez que dans ce premier exemple, un espace entre chaque colonne a été " 
-"ajouté par la façon dont fonctionne :func:`print`, qui ajoute toujours des " 
-"espaces entre ses paramètres.)" 
+"Notez que dans ce premier exemple, une espace a été ajoutée entre chaque " 
+"colonne . C'est le comportement de :func:`print`, elle ajoute toujours des " 
+"espaces entre ses paramètres." 
  
 #: ../Doc/tutorial/inputoutput.rst:105 
 msgid "" 
@ -141,14 +139,14 @@ msgid ""
 "(If you really want truncation you can always add a slice operation, as in " 
 "``x.ljust(n)[:n]``.)" 
 msgstr "" 
-"Cet exemple démontre l'utilisation de la méthode :meth:`str.rjust` des " 
-"chaînes de caractères, qui fait une justification à droite d'une chaîne dans " 
-"un champ d'une largeur donnée en ajoutant des espaces sur la gauche. Il " 
-"existe des méthodes similaires :meth:`str.ljust` et :meth:`str.center`. Ces " 
-"méthodes n'écrivent rien, elles renvoient simplement une nouvelle chaîne. Si " 
-"la chaîne passée en paramètre est trop longue, elle n'est pas tronquée mais " 
-"renvoyée sans modification ; ce qui peut déranger votre mise en page mais " 
-"est souvent préférable à l'alternative, qui pourrait mentir sur une valeur " 
+"Cet exemple illustre l'utilisation de la méthode :meth:`str.rjust` des " 
+"chaînes de caractères ; elle justifie à droite une chaîne dans un champ " 
+"d'une largeur donnée en ajoutant des espaces sur la gauche. Il existe des " 
+"méthodes similaires :meth:`str.ljust` et :meth:`str.center`. Ces méthodes " 
+"n'écrivent rien, elles renvoient simplement une nouvelle chaîne. Si la " 
+"chaîne passée en paramètre est trop longue, elle n'est pas tronquée mais " 
+"renvoyée sans modification ; cela peut chambouler votre mise en page mais " 
+"c'est souvent préférable à l'alternative, qui pourrait mentir sur une valeur " 
 "(et si vous voulez vraiment tronquer vos valeurs, vous pouvez toujours " 
 "utiliser une tranche, comme dans ``x.ljust(n)[:n]``)." 
  
@ -164,7 +162,7 @@ msgstr ""
 #: ../Doc/tutorial/inputoutput.rst:125 
 msgid "Basic usage of the :meth:`str.format` method looks like this::" 
 msgstr "" 
-"L'utilisation de base de la méthode :meth:`str.format` ressemble à cela : ::" 
+"L'utilisation de base de la méthode :meth:`str.format` ressemble à ceci : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:130 
 msgid "" 
@ -173,7 +171,7 @@ msgid ""
 "brackets can be used to refer to the position of the object passed into the :" 
 "meth:`str.format` method. ::" 
 msgstr "" 
-"Les accolades et les caractères qu'ils contiennent (appelés les champs de " 
+"Les accolades et les caractères à l'intérieur (appelés les champs de " 
 "formatage) sont remplacés par les objets passés en paramètres à la méthode :" 
 "meth:`str.format`. Un nombre entre accolades se réfère à la position de " 
 "l'objet passé à la méthode :meth:`str.format`. ::" 
@ -198,7 +196,7 @@ msgid ""
 "formatted::" 
 msgstr "" 
 "``'!a'`` (appliquer :func:`ascii`), ``'!s'`` (appliquer :func:`str`) et ``'!" 
-"r'`` (appliquer :func:`repr`)peuvent être utilisées pour convertir les " 
+"r'`` (appliquer :func:`repr`) peuvent être utilisées pour convertir les " 
 "valeurs avant leur formatage : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:162 
@ -207,10 +205,10 @@ msgid ""
 "allows greater control over how the value is formatted. The following " 
 "example rounds Pi to three places after the decimal." 
 msgstr "" 
-"Des caractères ``':'`` suivis d'une spécification de formatage peuvent " 
-"suivre le nom du champ. Ceci offre un niveau de contrôle plus fin sur la " 
-"façon dont les valeurs sont formatées. L'exemple suivant arrondit Pi à trois " 
-"décimales : ::" 
+"Un caractère ``':'`` suivi d'une spécification de formatage peuvent suivre " 
+"le nom du champ. Ceci offre un niveau de contrôle plus fin sur la façon dont " 
+"les valeurs sont formatées. L'exemple suivant arrondit Pi à trois chiffres " 
+"après la virgule (NdT : qui, en notation anglo-saxonne, est un point)." 
  
 #: ../Doc/tutorial/inputoutput.rst:170 
 msgid "" 
@ -227,19 +225,18 @@ msgid ""
 "instead of by position. This can be done by simply passing the dict and " 
 "using square brackets ``'[]'`` to access the keys ::" 
 msgstr "" 
-"Si vous avez vraiment une longue chaîne de formatage que vous ne voulez pas " 
-"découper, ce serait bien de pouvoir référencer les variables à formater par " 
-"leur nom plutôt que par leur position. Cela peut être fait simplement en " 
-"passant un dictionnaire et en utilisant des crochets ``'[]'`` pour accéder " 
-"aux clés : ::" 
+"Si vous avez une chaîne de formatage vraiment longue que vous ne voulez pas " 
+"découper, il est possible de référencer les variables à formater par leur " 
+"nom plutôt que par leur position. Utilisez simplement un dictionnaire et la " 
+"notation entre crochets ``'[]'`` pour accéder aux clés : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:191 
 msgid "" 
 "This could also be done by passing the table as keyword arguments with the " 
 "'**' notation. ::" 
 msgstr "" 
-"On pourrait également faire ça en passant le tableau comme des arguments " 
-"nommés en utilisant la notation '**' ::" 
+"vous pouvez obtenir le même résultat en passant le tableau comme des " 
+"arguments nommés en utilisant la notation '**' ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:198 
 msgid "" 
@ -247,15 +244,15 @@ msgid ""
 "`vars`, which returns a dictionary containing all local variables." 
 msgstr "" 
 "C'est particulièrement utile en combinaison avec la fonction native :func:" 
-"`vars`, qui renvoie un dictionnaire contenant toutes les variables locales." 
+"`vars` qui renvoie un dictionnaire contenant toutes les variables locales." 
  
 #: ../Doc/tutorial/inputoutput.rst:201 
 msgid "" 
 "For a complete overview of string formatting with :meth:`str.format`, see :" 
 "ref:`formatstrings`." 
 msgstr "" 
-"Pour avoir une vue complète du formatage des chaînes de caractères avec la " 
-"méthode :meth:`str.format`, voyez : :ref:`formatstrings`." 
+"Pour avoir une description complète du formatage des chaînes de caractères " 
+"avec la méthode :meth:`str.format`, lisez : :ref:`formatstrings`." 
  
 #: ../Doc/tutorial/inputoutput.rst:206 
 msgid "Old string formatting" 
@ -269,15 +266,15 @@ msgid ""
 "formatting operation. For example::" 
 msgstr "" 
 "L'opérateur ``%`` peut aussi être utilisé pour formater des chaînes. Il " 
-"interprète l'argument de gauche un peu comme une chaîne de formatage d'une " 
-"fonction :c:func:`sprintf` à appliquer à l'argument de droite, et renvoie la " 
-"chaîne résultant de cette opération de formatage. Par exemple : ::" 
+"interprète l'argument de gauche pratiquement comme une chaîne de formatage " 
+"de la fonction :c:func:`sprintf` à appliquer à l'argument de droite, et il " 
+"renvoie la chaîne résultant de cette opération de formatage. Par exemple : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:217 
 msgid "" 
 "More information can be found in the :ref:`old-string-formatting` section." 
 msgstr "" 
-"Vous trouverez plus d'informations dans la section :ref:`old-string-" 
+"Vous trouvez plus d'informations dans la section :ref:`old-string-" 
 "formatting`." 
  
 #: ../Doc/tutorial/inputoutput.rst:223 
@ -289,8 +286,8 @@ msgid ""
 ":func:`open` returns a :term:`file object`, and is most commonly used with " 
 "two arguments: ``open(filename, mode)``." 
 msgstr "" 
-":func:`open` renvoie un :term:`objet fichier`, et est le plus souvent " 
-"utilisé avecdeux arguments : ``open(filename, mode)``." 
+"La fonction :func:`open` renvoie un :term:`objet fichier` et est le plus " 
+"souvent utilisée avec deux arguments : ``open(nomfichier, mode)``." 
  
 #: ../Doc/tutorial/inputoutput.rst:241 
 msgid "" 
@ -303,14 +300,14 @@ msgid ""
 "reading and writing. The *mode* argument is optional; ``'r'`` will be " 
 "assumed if it's omitted." 
 msgstr "" 
-"Le premier argument est une chaîne contenant le nom du fichier. Le second " 
+"Le premier argument est une chaîne contenant le nom du fichier. Le deuxième " 
 "argument est une autre chaîne contenant quelques caractères décrivant la " 
-"façon dont le fichier sera utilisé. *mode* peut être ``'r'`` quand le " 
-"fichier ne sera accédé qu'en lecture, ``'w'`` en écriture seulement (un " 
-"fichier existant portant le même nom sera alors écrasé), et ``'a'`` ouvre le " 
-"fichier en mode ajout (toute donnée écrite dans le fichier est " 
-"automatiquement ajoutée à la fin). ``'r+'`` ouvre le fichier en mode lecture/" 
-"écriture. L'argument *mode* est optionnel ; sa valeur par défaut est ``'r'``." 
+"façon dont le fichier est utilisé. *mode* peut être ``'r'`` quand le fichier " 
+"n'est accédé qu'en lecture, ``'w'`` en écriture seulement (un fichier " 
+"existant portant le même nom sera alors écrasé) et ``'a'`` ouvre le fichier " 
+"en mode ajout (toute donnée écrite dans le fichier est automatiquement " 
+"ajoutée à la fin). ``'r+'`` ouvre le fichier en mode lecture/écriture. " 
+"L'argument *mode* est optionnel, sa valeur par défaut est ``'r'``." 
  
 #: ../Doc/tutorial/inputoutput.rst:250 
 msgid "" 
@ -321,14 +318,14 @@ msgid ""
 "`binary mode`: now the data is read and written in the form of bytes " 
 "objects. This mode should be used for all files that don't contain text." 
 msgstr "" 
-"Normalement, les fichiers sont ouverts en :dfn:`mode texte`, c'est à dire " 
+"Normalement, les fichiers sont ouverts en :dfn:`mode texte`, c'est-à-dire " 
 "que vous lisez et écrivez des chaînes de caractères depuis et dans ce " 
-"fichier, qui y sont encodées avec un encodage donné. Si aucun encodage n'est " 
-"spécifié, l'encodage par défaut dépendra de la plateforme (voir :func:" 
-"`open`). ``'b'`` collé à la fin du mode indique que le fichier doit être " 
-"ouvert en :dfn:`mode binaire` c'est à dire que les données sont lues et " 
-"écrites sous formes d'octets. Ce mode est à utiliser pour les fichiers " 
-"contenant autre chose que du texte." 
+"fichier, suivant un encodage donné. Si aucun encodage n'est spécifié, " 
+"l'encodage par défaut dépend de la plateforme (voir :func:`open`). ``'b'`` " 
+"collé à la fin du mode indique que le fichier doit être ouvert en :dfn:`mode " 
+"binaire` c'est-à-dire que les données sont lues et écrites sous formes " 
+"d'octets (type *bytes*). Ce mode est à utiliser pour les fichiers contenant " 
+"autre chose que du texte." 
  
 #: ../Doc/tutorial/inputoutput.rst:257 
 msgid "" 
@ -342,12 +339,13 @@ msgid ""
 msgstr "" 
 "En mode texte, le comportement par défaut, à la lecture, est de convertir " 
 "les fin de lignes spécifiques à la plateforme (``\\n`` sur Unix, ``\\r\\n`` " 
-"sur windows etc...) en simples ``\\n``. Lors de l'écriture, le comprennent " 
-"par défaut est d'appliquer l'opération contraire : les ``\\n`` sont " 
-"convertis dans leur équivalent sur la plateforme courante. Ces modifications " 
+"sur windows etc...) en simples ``\\n``. Lors de l'écriture, le comportement " 
+"par défaut est d'appliquer l'opération inverse : les ``\\n`` sont convertis " 
+"dans leur équivalent sur la plateforme courante. Ces modifications " 
 "effectuées automatiquement sont normales pour du texte mais détérioreraient " 
-"des données binaires comme un fichier :file:`JPEG` ou :file:`EXE`. Soyez " 
-"particulièrement attentifs à ouvrir ces fichiers binaires en mode binaire." 
+"des données binaires contenues dans un fichier de type :file:`JPEG` ou :file:" 
+"`EXE`. Soyez particulièrement attentifs à ouvrir ces fichiers binaires en " 
+"mode binaire." 
  
 #: ../Doc/tutorial/inputoutput.rst:265 
 msgid "" 
@ -358,10 +356,10 @@ msgid ""
 "-\\ :keyword:`finally` blocks::" 
 msgstr "" 
 "C'est une bonne pratique d'utiliser le mot-clé :keyword:`with` lorsque vous " 
-"traitez des fichiers.  Ceci procure l'avantage de toujours fermer " 
-"correctement le fichier, même si une exception est levée.  Utiliser :keyword:" 
-"`with` est aussi beaucoup plus court que d'utiliser l'équivalent avec des " 
-"blocs :keyword:`try`\\ -\\ :keyword:`finally` : ::" 
+"traitez des fichiers. Vous fermez ainsi toujours correctement le fichier, " 
+"même si une exception est levée. Utiliser :keyword:`with` est aussi beaucoup " 
+"plus court que d'utiliser l'équivalent avec des blocs :keyword:`try`\\ -\\ :" 
+"keyword:`finally` : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:276 
 msgid "" 
@ -373,12 +371,12 @@ msgid ""
 "implementations will do this clean-up at different times." 
 msgstr "" 
 "Si vous n'utilisez pas le mot clef :keyword:`with`, vous devez appeler ``f." 
-"close()`` pour fermer le fichier et immédiatement libérer les resources " 
-"systèmes qu'il utilise. Si vous ne fermez pas explicitement le fichier, le " 
+"close()`` pour fermer le fichier et immédiatement libérer les ressources " 
+"système qu'il utilise. Si vous ne fermez pas explicitement le fichier, le " 
 "ramasse-miette de Python finira par détruire l'objet et fermer le fichier " 
-"pour vous, mais le fichier peut rester ouvert pendant un moment.  Un autre " 
+"pour vous, mais le fichier peut rester ouvert pendant un moment. Un autre " 
 "risque est que différentes implémentations de Python risquent faire ce " 
-"nettoyage à différents moments." 
+"nettoyage à des moments différents." 
  
 #: ../Doc/tutorial/inputoutput.rst:284 
 msgid "" 
@ -386,9 +384,9 @@ msgid ""
 "calling ``f.close()``, attempts to use the file object will automatically " 
 "fail. ::" 
 msgstr "" 
-"Après la fermeture du fichier, que ce soit via une instruction :keyword:" 
+"Après la fermeture du fichier, que ce soit *via* une instruction :keyword:" 
 "`with` ou en appelant ``f.close()``, toute tentative d'utilisation de " 
-"l'objet fichier échouera systématiquement. ::" 
+"l'objet fichier échoue systématiquement. ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:298 
 msgid "Methods of File Objects" 
@ -399,8 +397,8 @@ msgid ""
 "The rest of the examples in this section will assume that a file object " 
 "called ``f`` has already been created." 
 msgstr "" 
-"Les derniers exemples de cette section supposeront qu'un objet fichier " 
-"appelé ``f`` a déjà été créé." 
+"Les derniers exemples de cette section supposent qu'un objet fichier appelé " 
+"``f`` a déjà été créé." 
  
 #: ../Doc/tutorial/inputoutput.rst:303 
 msgid "" 
@ -412,13 +410,13 @@ msgid ""
 "Otherwise, at most *size* bytes are read and returned. If the end of the " 
 "file has been reached, ``f.read()`` will return an empty string (``''``). ::" 
 msgstr "" 
-"Pour lire le contenu d'un fichier, appelez ``f.read(size)``, qui lit une " 
+"Pour lire le contenu d'un fichier, appelez ``f.read(taille)`` : elle lit une " 
 "certaine quantité de données et les donne sous la forme d'une chaîne (en " 
-"mode texte) ou dans un objet *bytes* (en mode binaire). *size* est un " 
-"argument numérique optionnel. Quand *size* est omis ou négatif, le contenu " 
+"mode texte) ou dans un objet *bytes* (en mode binaire). *taille* est un " 
+"argument numérique optionnel. Quand *taille* est omis ou négatif, le contenu " 
 "entier du fichier est lu et donné, c'est votre problème si le fichier est " 
 "deux fois plus gros que la mémoire de votre machine. Sinon, un maximum de " 
-"*size* octets sont lus et rendus. Lorsque la fin du fichier est atteinte, " 
+"*taille* octets sont lus et donnés. Lorsque la fin du fichier est atteinte, " 
 "``f.read()`` renvoie une chaîne vide (``''``). ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:317 
@ -431,36 +429,36 @@ msgid ""
 "``'\\n'``, a string containing only a single newline. ::" 
 msgstr "" 
 "``f.readline()`` lit une seule ligne du fichier ; un caractère de fin de " 
-"ligne (``\\n``) est laissé à la fin de la chaîne, et n'est omis que sur la " 
+"ligne (``\\n``) est laissé à la fin de la chaîne. Il n'est omis que sur la " 
 "dernière ligne du fichier si celui-ci ne se termine pas un caractère de fin " 
 "de ligne. Ceci permet de rendre la valeur de retour non ambigüe : si ``f." 
 "readline()`` renvoie une chaîne vide, c'est que la fin du fichier a été " 
-"atteinte, alors qu'une ligne vide est représentée par ``'\\n'``, une chaîne " 
-"de caractères ne contenant qu'une fin de ligne. ::" 
+"atteinte, alors qu'une ligne vide est représentée par ``'\\n'`` (une chaîne " 
+"de caractères ne contenant qu'une fin de ligne). ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:331 
 msgid "" 
 "For reading lines from a file, you can loop over the file object. This is " 
 "memory efficient, fast, and leads to simple code::" 
 msgstr "" 
-"Une autre approche de lecture des lignes est de faire une boucle sur l'objet " 
-"fichier. Cela est plus efficace en terme de gestion mémoire, plus rapide, et " 
-"donne un code plus simple : ::" 
+"Pour lire ligne à ligne, vous pouvez aussi boucler sur l'objet fichier. " 
+"C'est plus efficace en terme de gestion mémoire, plus rapide et donne un " 
+"code plus simple : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:340 
 msgid "" 
 "If you want to read all the lines of a file in a list you can also use " 
 "``list(f)`` or ``f.readlines()``." 
 msgstr "" 
-"Pour lire toutes les lignes d'un fichier, il est aussi possible d'utiliser " 
-"``list(f)`` ou ``f.readlines()``." 
+"Pour construire une liste avec toutes les lignes d'un fichier, il est aussi " 
+"possible d'utiliser ``list(f)`` ou ``f.readlines()``." 
  
 #: ../Doc/tutorial/inputoutput.rst:343 
 msgid "" 
 "``f.write(string)`` writes the contents of *string* to the file, returning " 
 "the number of characters written. ::" 
 msgstr "" 
-"``f.write(string)`` écrit le contenu de *string* dans le fichier, et renvoie " 
+"``f.write(chaine)`` écrit le contenu de *chaine* dans le fichier et renvoie " 
 "le nombre de caractères écrits. ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:349 
@ -468,8 +466,8 @@ msgid ""
 "Other types of objects need to be converted -- either to a string (in text " 
 "mode) or a bytes object (in binary mode) -- before writing them::" 
 msgstr "" 
-"D'autres types doivent être convertis, soit en une chaîne (en mode texte) ou " 
-"un objet *bytes* (en mode binaire), avant de les écrire : ::" 
+"Les autres types doivent être convertis, soit en une chaîne (en mode texte), " 
+"soit en objet *bytes* (en mode binaire) avant de les écrire : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:357 
 msgid "" 
@ -478,8 +476,8 @@ msgid ""
 "in binary mode and an opaque number when in text mode." 
 msgstr "" 
 "``f.tell()`` renvoie un entier indiquant la position actuelle dans le " 
-"fichier, mesurée en octets à partir du début du fichier, lorsque le fichier " 
-"est ouvert en mode binaire, ou un nombre obscure en mode texte." 
+"fichier, mesurée en octets à partir du début du fichier lorsque le fichier " 
+"est ouvert en mode binaire, ou un nombre obscur en mode texte." 
  
 #: ../Doc/tutorial/inputoutput.rst:361 
 msgid "" 
@ -491,12 +489,12 @@ msgid ""
 "*from_what* can be omitted and defaults to 0, using the beginning of the " 
 "file as the reference point. ::" 
 msgstr "" 
-"Pour modifier la position dans le fichier, utilisez ``f.seek(offset, " 
-"from_what)``. Laposition est calculée en ajoutant *offset* à un point de " 
-"référence ; ce point de référence est sélectionné par l'argument " 
-"*from_what* : 0 pour le début du fichier, 1 pour la position actuelle, et 2 " 
-"pour la fin du fichier. *from_what* peut être omis et sa valeur par défaut " 
-"est 0, utilisant le début du fichier comme point de référence : ::" 
+"Pour modifier la position dans le fichier, utilisez ``f.seek(decalage, " 
+"a_partir_de)``. La position est calculée en ajoutant *decalage* à un point " 
+"de référence ; ce point de référence est déterminé par l'argument " 
+"*a_partir_de* : 0 pour le début du fichier, 1 pour la position actuelle et 2 " 
+"pour la fin du fichier. *a_partir_de* peut être omis et sa valeur par défaut " 
+"est 0 (Python utilise le début du fichier comme point de référence) : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:380 
 msgid "" 
@ -509,9 +507,9 @@ msgstr ""
 "Sur un fichier en mode texte (ceux ouverts sans ``b`` dans le mode), seuls " 
 "les changements de position relatifs au début du fichier sont autorisés " 
 "(sauf une exception : se rendre à la fin du fichier avec ``seek(0, 2)``) et " 
-"les seuls valeurs possible pour le paramètre *offset* sont les valeurs " 
+"les seules valeurs possibles pour le paramètre *decalage* sont les valeurs " 
 "renvoyées par ``f.tell()``, ou zéro. Toute autre valeur pour le paramètre " 
-"*offset* engendrera un comportement indéfini." 
+"*decalage* produit un comportement indéfini." 
  
 #: ../Doc/tutorial/inputoutput.rst:386 
 msgid "" 
@ -526,7 +524,7 @@ msgstr ""
  
 #: ../Doc/tutorial/inputoutput.rst:394 
 msgid "Saving structured data with :mod:`json`" 
-msgstr "Sauvegarder des données structurées avec le module :mod:`json`" 
+msgstr "Sauvegarde de données structurées avec le module :mod:`json`" 
  
 #: ../Doc/tutorial/inputoutput.rst:398 
 msgid "" 
@ -538,12 +536,13 @@ msgid ""
 "serializing by hand becomes complicated." 
 msgstr "" 
 "Les chaînes de caractères peuvent facilement être écrites dans un fichier et " 
-"relues. Les nombres nécessitent un peu plus d'efforts, car la méthode :meth:" 
-"`read` ne renvoie que des chaînes, qui doivent donc être passées à une " 
+"relues. Les nombres nécessitent un peu plus d'effort, car la méthode :meth:" 
+"`read` ne renvoie que des chaînes. Elles doivent donc être passées à une " 
 "fonction comme :func:`int`, qui prend une chaîne comme ``'123'`` en entrée " 
 "et renvoie sa valeur numérique 123. Mais dès que vous voulez enregistrer des " 
 "types de données plus complexes comme des listes, des dictionnaires ou des " 
-"instances de classes, les choses se compliquent beaucoup plus." 
+"instances de classes, le traitement lecture/écriture à la main devient vite " 
+"compliqué." 
  
 #: ../Doc/tutorial/inputoutput.rst:405 
 msgid "" 
@ -558,15 +557,15 @@ msgid ""
 "file or data, or sent over a network connection to some distant machine." 
 msgstr "" 
 "Plutôt que de passer son temps à écrire et déboguer du code permettant de " 
-"sauvegarder des types de données compliquées, Python permet d'utiliser `JSON " 
+"sauvegarder des types de données compliqués, Python permet d'utiliser `JSON " 
 "(JavaScript Object Notation) <http://json.org>`_, un format répandu de " 
-"représentation et d'échange de données. Le module standard appellé :mod:" 
-"`json` peut transformer des hiérarchies de données Python en leur " 
-"représentation sous forme de chaîne de caractère. Ce processus est nommé :" 
+"représentation et d'échange de données. Le module standard appelé :mod:" 
+"`json` peut transformer des données hiérarchisées Python en une " 
+"représentation sous forme de chaîne de caractères. Ce processus est nommé :" 
 "dfn:`sérialiser`. Reconstruire les données à partir de leur représentation " 
-"sous forme de chaîne est appelé :dfn:`déserialiser`. Entre sa serialisation " 
-"et sa déserialisation, la chaîne représentant les données peuvent avoir été " 
-"stockées ou transmises à une autre machine." 
+"sous forme de chaîne est appelé :dfn:`déserialiser`. Entre sa sérialisation " 
+"et sa dé-sérialisation, la chaîne représentant les données peut avoir été " 
+"stockée ou transmise à une autre machine." 
  
 #: ../Doc/tutorial/inputoutput.rst:416 
 msgid "" 
@ -574,17 +573,17 @@ msgid ""
 "exchange. Many programmers are already familiar with it, which makes it a " 
 "good choice for interoperability." 
 msgstr "" 
-"Le format JSON se retrouve communément dans les applications modernes pour " 
-"échanger des données. Beaucoup de développeurs sont déjà familier avec le " 
-"JSON, en faisant un format de prédilection pour l'interopérabilité." 
+"Le format JSON est couramment utilisé dans les applications modernes pour " 
+"échanger des données. Beaucoup de développeurs le maîtrise, ce qui en fait " 
+"un format de prédilection pour l'interopérabilité." 
  
 #: ../Doc/tutorial/inputoutput.rst:420 
 msgid "" 
 "If you have an object ``x``, you can view its JSON string representation " 
 "with a simple line of code::" 
 msgstr "" 
-"Si vous avez un objet ``x``, vous pouvez simplement voir sa représentation " 
-"JSON ::" 
+"Si vous avez un objet ``x``, vous pouvez voir sa représentation JSON en " 
+"tapant simplement : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:427 
 msgid "" 
@ -592,10 +591,10 @@ msgid ""
 "dump`, simply serializes the object to a :term:`text file`. So if ``f`` is " 
 "a :term:`text file` object opened for writing, we can do this::" 
 msgstr "" 
-"Une variation de la fonction :func:`~json.dumps`, nommée :func:`~json.dump`, " 
+"Une variante de la fonction :func:`~json.dumps`, nommée :func:`~json.dump`, " 
 "sérialise simplement l'objet donné vers un :term:`fichier texte <text " 
 "file>`. Donc si ``f`` est un :term:`fichier texte <text file>` ouvert en " 
-"écriture, il devient possible de faire : ::" 
+"écriture, il est possible de faire : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:433 
 msgid "" 
@ -603,7 +602,7 @@ msgid ""
 "been opened for reading::" 
 msgstr "" 
 "Pour reconstruire l'objet, si ``f`` est cette fois un :term:`fichier texte` " 
-"ouverten lecture : ::" 
+"ouvert en lecture : ::" 
  
 #: ../Doc/tutorial/inputoutput.rst:438 
 msgid "" 
@ -612,8 +611,8 @@ msgid ""
 "effort. The reference for the :mod:`json` module contains an explanation of " 
 "this." 
 msgstr "" 
-"Cette méthode de serialisation peut sérialiser des listes et des " 
-"dictionnaires, mais sérialiser d'autres types de données nécessité un peu " 
+"Cette méthode de sérialisation peut sérialiser des listes et des " 
+"dictionnaires. Mais sérialiser d'autres types de données requiert un peu " 
 "plus de travail. La documentation du module :mod:`json` explique comment " 
 "faire." 
  
@ -630,9 +629,10 @@ msgid ""
 "pickle data coming from an untrusted source can execute arbitrary code, if " 
 "the data was crafted by a skilled attacker." 
 msgstr "" 
-"À l'inverse de :ref:`JSON <tut-json>`, *pickle* est un protocole permettant " 
-"la serialisation d'objets Python arbitrairement complexes. Il est donc " 
-"spécifique à Python et ne peut être utilisé pour communiquer avec d'autres " 
-"langages. Il n'est aussi pas sans failles : desérialiser des données au " 
-"format pickle provenant d'une source malveillante et particulièrement habile " 
-"pourrait mener exécuter du code arbitraire." 
+"Au contraire de :ref:`JSON <tut-json>`, *pickle* est un protocole permettant " 
+"la sérialisation d'objets Python arbitrairement complexes. Il est donc " 
+"spécifique à Python et ne peut pas être utilisé pour communiquer avec " 
+"d'autres langages. Il est aussi, par défaut, une source de vulnérabilité : " 
+"dé-sérialiser des données au format pickle provenant d'une source " 
+"malveillante et particulièrement habile peut mener à exécuter du code " 
+"arbitraire." 
--- a/tutorial/interactive.po
+++ b/tutorial/interactive.po
@ -9,7 +9,7 @@ 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: YEAR-MO-DA HO:MI+ZONE\n" 
+"PO-Revision-Date: 2018-02-15 00:59+0100\n" 
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" 
 "Language-Team: LANGUAGE <LL@li.org>\n" 
 "Language: fr\n" 
@ -38,7 +38,7 @@ msgstr ""
  
 #: ../Doc/tutorial/interactive.rst:17 
 msgid "Tab Completion and History Editing" 
-msgstr "Complément Automatique et édition de l'historique" 
+msgstr "Complément automatique et édition de l'historique" 
  
 #: ../Doc/tutorial/interactive.rst:19 
 msgid "" 
--- a/tutorial/stdlib.po
+++ b/tutorial/stdlib.po
@ -8,25 +8,25 @@ msgstr ""
 "Project-Id-Version: Python 3.6\n" 
 "Report-Msgid-Bugs-To: \n" 
 "POT-Creation-Date: 2016-10-30 10:40+0100\n" 
-"PO-Revision-Date: 2016-11-19 15:52+0100\n" 
+"PO-Revision-Date: 2018-02-15 00:59+0100\n" 
 "MIME-Version: 1.0\n" 
 "Content-Type: text/plain; charset=UTF-8\n" 
 "Content-Transfer-Encoding: 8bit\n" 
  
 #: ../Doc/tutorial/stdlib.rst:5 
 msgid "Brief Tour of the Standard Library" 
-msgstr "Survol de la Bibliothèque Standard" 
+msgstr "Survol de la bibliothèque standard" 
  
 #: ../Doc/tutorial/stdlib.rst:11 
 msgid "Operating System Interface" 
-msgstr "Interface avec le Système d'Exploitation" 
+msgstr "Interface avec le système d'exploitation" 
  
 #: ../Doc/tutorial/stdlib.rst:13 
 msgid "" 
 "The :mod:`os` module provides dozens of functions for interacting with the " 
 "operating system::" 
 msgstr "" 
-"Le modules :mod:`os` propose pléthore fonctions pour interagir avec le " 
+"Le module :mod:`os` propose des dizaines de fonctions pour interagir avec le " 
 "système d'exploitation : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:23 
@ -35,17 +35,16 @@ msgid ""
 "This will keep :func:`os.open` from shadowing the built-in :func:`open` " 
 "function which operates much differently." 
 msgstr "" 
-"Mais, encore une fois, préférez ``import os``, à ``from os import *``, sans " 
-"quoi :func:`os.open` cacherait la primitive :func:`open`, qui fonctionne " 
-"différemment." 
+"Veillez bien à utiliser ``import os`` plutôt que ``from os import *``, sinon :" 
+"func:`os.open` cache la primitive :func:`open` qui fonctionne différemment." 
  
 #: ../Doc/tutorial/stdlib.rst:29 
 msgid "" 
 "The built-in :func:`dir` and :func:`help` functions are useful as " 
 "interactive aids for working with large modules like :mod:`os`::" 
 msgstr "" 
-"Les primitives :func:`dir` et :func:`help` sont des outils utiles lorsque " 
-"vous travaillez en mode interactif avez des gros modules comme :mod:`os` ::" 
+"Les primitives :func:`dir` et :func:`help` sont des aides utiles lorsque vous " 
+"travaillez en mode interactif avez des gros modules comme :mod:`os` : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:38 
 msgid "" 
@ -57,7 +56,7 @@ msgstr ""
  
 #: ../Doc/tutorial/stdlib.rst:51 
 msgid "File Wildcards" 
-msgstr "Jokers sur les noms de Fichiers" 
+msgstr "Jokers sur les noms de fichiers" 
  
 #: ../Doc/tutorial/stdlib.rst:53 
 msgid "" 
@ -69,7 +68,7 @@ msgstr ""
  
 #: ../Doc/tutorial/stdlib.rst:64 
 msgid "Command Line Arguments" 
-msgstr "Paramètres en ligne de Commande" 
+msgstr "Paramètres passés en ligne de commande" 
  
 #: ../Doc/tutorial/stdlib.rst:66 
 msgid "" 
@ -79,10 +78,10 @@ msgid ""
 "two three`` at the command line::" 
 msgstr "" 
 "Typiquement, les outils en ligne de commande ont besoin de lire les " 
-"paramètres qui leur sont donnés. Ces paramètres sont stockés dans la " 
-"variable ``argv`` dans le module :mod:`sys` sous forme de liste. Par " 
-"exemple, l'affichage suivant vient de l'exécution de ``python demo.py one " 
-"two three`` depuis la ligne de commande : ::" 
+"paramètres qui leur sont donnés. Ces paramètres sont stockés dans la variable " 
+"``argv`` du module :mod:`sys` sous la forme d'une liste. Par exemple, " 
+"l'affichage suivant vient de l'exécution de ``python demo.py one two three`` " 
+"depuis la ligne de commande : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:75 
 msgid "" 
@ -90,10 +89,10 @@ msgid ""
 "Unix :func:`getopt` function. More powerful and flexible command line " 
 "processing is provided by the :mod:`argparse` module." 
 msgstr "" 
-"Le module :mod:`getopt` comprend *sys.argv* en utilisant les conventions " 
-"habituelles de la fonction Unix :func:`getopt`. Des outils de compréhension " 
-"des paramètres de la ligne de commande plus flexibles et avancés sont " 
-"disponibles dnas le module :mod:`argparse`." 
+"Le module :mod:`getopt` analyse *sys.argv* en utilisant les conventions " 
+"habituelles de la fonction Unix :func:`getopt`. Des outils d'analyse des " 
+"paramètres de la ligne de commande plus flexibles et avancés sont disponibles " 
+"dans le module :mod:`argparse`." 
  
 #: ../Doc/tutorial/stdlib.rst:83 
 msgid "Error Output Redirection and Program Termination" 
@ -105,7 +104,7 @@ msgid ""
 "*stderr*. The latter is useful for emitting warnings and error messages to " 
 "make them visible even when *stdout* has been redirected::" 
 msgstr "" 
-"Le module :mod:`sys` a aussi des attributs pour *stdin*, *stdout*, et " 
+"Le module :mod:`sys` a aussi des attributs pour *stdin*, *stdout* et " 
 "*stderr*. Ce dernier est utile pour émettre des messages d'avertissement ou " 
 "d'erreur qui restent visibles même si *stdout* est redirigé : ::" 
  
@ -116,7 +115,7 @@ msgstr ""
  
 #: ../Doc/tutorial/stdlib.rst:98 
 msgid "String Pattern Matching" 
-msgstr "Recherche de motifs dans les Chaînes" 
+msgstr "Recherche de motifs dans les chaînes" 
  
 #: ../Doc/tutorial/stdlib.rst:100 
 msgid "" 
@ -124,11 +123,10 @@ msgid ""
 "processing. For complex matching and manipulation, regular expressions offer " 
 "succinct, optimized solutions::" 
 msgstr "" 
-"Le module :mod:`re` fournit des outils basés sur les expressions " 
-"rationnelles permettant des opérations complexes sur les chaînes. C'est une " 
-"solution optimisée, utilisant une syntaxe consise, pour rechercher des " 
-"motifs complexes, ou effectuer des remplacements complexes dans les " 
-"chaînes : ::" 
+"Le module :mod:`re` fournit des outils basés sur les expressions rationnelles " 
+"permettant des opérations complexes sur les chaînes. C'est une solution " 
+"optimisée, utilisant une syntaxe concise, pour rechercher des motifs " 
+"complexes ou effectuer des remplacements complexes dans les chaînes : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:110 
 msgid "" 
@ -136,7 +134,7 @@ msgid ""
 "because they are easier to read and debug::" 
 msgstr "" 
 "Lorsque les opérations sont simples, il est préférable d'utiliser les " 
-"méthodes des chaînes, elles sont plus lisibles et plus facile à débugger : ::" 
+"méthodes des chaînes. Elles sont plus lisibles et plus faciles à déboguer : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:120 
 msgid "Mathematics" 
@ -147,13 +145,13 @@ msgid ""
 "The :mod:`math` module gives access to the underlying C library functions " 
 "for floating point math::" 
 msgstr "" 
-"Le module :mod:`math` expose des fonctions d'opération sur les \"float* de " 
-"la bibliothèque C ::" 
+"Le module :mod:`math` donne accès aux fonctions sur les nombres à virgule " 
+"flottante (*float* en anglais) de la bibliothèque C : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:131 
 msgid "The :mod:`random` module provides tools for making random selections::" 
 msgstr "" 
-"Le module :mod:`random` offre des outils pour faire des sélections " 
+"Le module :mod:`random` offre des outils pour faire des tirages " 
 "aléatoires : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:143 
@ -162,15 +160,15 @@ msgid ""
 "mean, median, variance, etc.) of numeric data::" 
 msgstr "" 
 "Le module :mod:`statistics` permet de calculer des valeurs statistiques " 
-"basiques (la moyenne, la médiane, la variance, ...) ::" 
+"basiques (moyenne, médiane, variance, ...) : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:155 
 msgid "" 
 "The SciPy project <https://scipy.org> has many other modules for numerical " 
 "computations." 
 msgstr "" 
-"Le projet SciPy <https://scipy.org> contient beaucoup d'autres modules " 
-"autour des calculs numériques." 
+"Le projet SciPy <https://scipy.org> contient beaucoup d'autres modules dédiés " 
+"aux calculs numériques." 
  
 #: ../Doc/tutorial/stdlib.rst:161 
 msgid "Internet Access" 
@ -182,16 +180,15 @@ msgid ""
 "internet protocols. Two of the simplest are :mod:`urllib.request` for " 
 "retrieving data from URLs and :mod:`smtplib` for sending mail::" 
 msgstr "" 
-"Il existe tout un tat de modules permettant d'accéder à internet et gérer " 
-"des protocoles utilisés sur internet. Les deux plus simples sont :mod:" 
-"`urllib.request`, qui permet de télécharger à partir d'une URL, et :mod:" 
-"`smtplib` pour envoyer des emails : ::" 
+"Il existe beaucoup de modules permettant d'accéder à internet et gérer les " 
+"protocoles réseaux. Les deux plus simples sont :mod:`urllib.request` qui " 
+"permet de récupérer des données à partir d'une URL et :mod:`smtplib` pour " 
+"envoyer des courriers électroniques : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:186 
 msgid "(Note that the second example needs a mailserver running on localhost.)" 
 msgstr "" 
-"(Notez que le deuxième exemple a besoin d'un serveur mail tournant " 
-"localement.)" 
+"Notez que le deuxième exemple a besoin d'un serveur mail tournant localement." 
  
 #: ../Doc/tutorial/stdlib.rst:192 
 msgid "Dates and Times" 
@ -205,16 +202,15 @@ msgid ""
 "for output formatting and manipulation. The module also supports objects " 
 "that are timezone aware. ::" 
 msgstr "" 
-"Le module :mod:`datetime` propose des classes pour manipuler les dates et " 
-"les temps de manière à la fois simple ou complexe. Bien que faire des " 
-"calculs de dates et de temps soit possible, la priorité de l'implémentation " 
-"est mise sur l'extraction efficace des attributs pour le formatage et la " 
-"manipulation. Le module gère aussi les objets dépendant des fuseaux " 
-"horaires : ::" 
+"Le module :mod:`datetime` propose des classes pour manipuler les dates et les " 
+"heures de manière simple ou plus complexe. Bien que faire des calculs de " 
+"dates et d'heures soit possible, la priorité de l'implémentation est mise sur " 
+"l'extraction efficace des attributs pour le formatage et la manipulation. Le " 
+"module gère aussi les objets dépendant des fuseaux horaires : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:218 
 msgid "Data Compression" 
-msgstr "Compression de donnée" 
+msgstr "Compression de données" 
  
 #: ../Doc/tutorial/stdlib.rst:220 
 msgid "" 
@ -223,12 +219,12 @@ msgid ""
 "`zipfile` and :mod:`tarfile`. ::" 
 msgstr "" 
 "Les formats d'archivage et de compression les plus communs sont directement " 
-"gérés par les modules :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :" 
-"mod:`zipfile`, et :mod:`tarfile` ::" 
+"gérés par les modules :mod:`zlib`, :mod:`gzip`, :mod:`bz2`, :mod:`lzma`, :mod:" 
+"`zipfile` et :mod:`tarfile` ::" 
  
 #: ../Doc/tutorial/stdlib.rst:240 
 msgid "Performance Measurement" 
-msgstr "Mesure des Performances" 
+msgstr "Mesure des performances" 
  
 #: ../Doc/tutorial/stdlib.rst:242 
 msgid "" 
@ -236,9 +232,9 @@ msgid ""
 "performance of different approaches to the same problem. Python provides a " 
 "measurement tool that answers those questions immediately." 
 msgstr "" 
-"Certains utilisateurs de Python développent un intérêt profond des " 
-"performances de différentes approches d'un même problème. Python propose un " 
-"outil de mesure répondant simplement à ces questions." 
+"Certains utilisateurs de Python sont très intéressés par les performances de " 
+"différentes approches d'un même problème. Python propose un outil de mesure " 
+"répondant simplement à ces questions." 
  
 #: ../Doc/tutorial/stdlib.rst:246 
 msgid "" 
@ -248,8 +244,8 @@ msgid ""
 msgstr "" 
 "Par exemple, pour échanger deux variables, il peut être tentant d'utiliser " 
 "l'empaquetage et le dépaquetage de tuples plutôt que la méthode " 
-"traditionnelle. Le module :mod:`timeit` montre simplement laquelle est la " 
-"plus efficace : ::" 
+"traditionnelle. Le module :mod:`timeit` montre rapidement le léger gain de " 
+"performance obtenu : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:256 
 msgid "" 
@ -263,7 +259,7 @@ msgstr ""
  
 #: ../Doc/tutorial/stdlib.rst:264 
 msgid "Quality Control" 
-msgstr "Contrôle Qualité" 
+msgstr "Contrôle qualité" 
  
 #: ../Doc/tutorial/stdlib.rst:266 
 msgid "" 
@ -273,7 +269,7 @@ msgid ""
 msgstr "" 
 "Une approche possible pour développer des application de très bonne qualité " 
 "est d'écrire des tests pour chaque fonction au fur et à mesure de son " 
-"développement, et d'exécuter ces tests fréquemment lors du processus de " 
+"développement, puis d'exécuter ces tests fréquemment lors du processus de " 
 "développement." 
  
 #: ../Doc/tutorial/stdlib.rst:270 
@ -285,10 +281,10 @@ msgid ""
 "example and it allows the doctest module to make sure the code remains true " 
 "to the documentation::" 
 msgstr "" 
-"Le module :mod:`doctest` permet de chercher des tests dans les chaînes de " 
-"documentation. Un tests ressemble à un simple copié-collé d'un appel et son " 
-"résultat depuis le mode interactif. Cela améliore la documentation en " 
-"fournissant des exemples tout en prouvant qu'ils sont justes : ::" 
+"Le module :mod:`doctest` cherche des tests dans les chaînes de documentation. " 
+"Un test ressemble à un simple copier-coller d'un appel et son résultat depuis " 
+"le mode interactif. Cela améliore la documentation en fournissant des " 
+"exemples tout en prouvant qu'ils sont justes : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:288 
 msgid "" 
@ -296,13 +292,13 @@ msgid ""
 "module, but it allows a more comprehensive set of tests to be maintained in " 
 "a separate file::" 
 msgstr "" 
-"Le module :mod:`unittest` est plus lourd que le module :mod:`doctest`, mais " 
-"il permet de construire un jeu de tests plus complet, maintenable, et " 
-"compréhensible dans un fichier séparé : ::" 
+"Le module :mod:`unittest` requiert plus d'efforts que le module :mod:" 
+"`doctest` mais il permet de construire un jeu de tests plus complet que l'on " 
+"fait évoluer dans un fichier séparé : ::" 
  
 #: ../Doc/tutorial/stdlib.rst:310 
 msgid "Batteries Included" 
-msgstr "Piles Fournies" 
+msgstr "Piles fournies" 
  
 #: ../Doc/tutorial/stdlib.rst:312 
 msgid "" 
@ -310,9 +306,9 @@ msgid ""
 "the sophisticated and robust capabilities of its larger packages. For " 
 "example:" 
 msgstr "" 
-"Python respecte la philosophie \"piles fournies\". C'est plus évident en " 
-"regardant les capacités sophistiquées et solides de ses plus gros paquets. " 
-"Par exemple:" 
+"Python adopte le principe des \"piles fournies\". Vous pouvez le constater au " 
+"travers des fonctionnalités évoluées et solides fournies par ses plus gros " 
+"paquets. Par exemple :" 
  
 #: ../Doc/tutorial/stdlib.rst:315 
 msgid "" 
@ -320,9 +316,9 @@ msgid ""
 "remote procedure calls into an almost trivial task. Despite the modules " 
 "names, no direct knowledge or handling of XML is needed." 
 msgstr "" 
-"Les modules :mod:`xmlrpc.client` et :mod:`xmlrpc.server` permettent " 
-"d'appeler des fonctions à distance quasiment sans effort. En dépit du nom " 
-"des modules, aucune connaissance du XML n'est nécessaire." 
+"Les modules :mod:`xmlrpc.client` et :mod:`xmlrpc.server` permettent d'appeler " 
+"des fonctions à distance quasiment sans effort. En dépit du nom des modules, " 
+"aucune connaissance du XML n'est nécessaire." 
  
 #: ../Doc/tutorial/stdlib.rst:319 
 msgid "" 
@ -334,10 +330,10 @@ msgid ""
 "protocols." 
 msgstr "" 
 "Le paquet :mod:`email` est une bibliothèque pour gérer les messages " 
-"electroniques, incluant les MIME et autre encodages basés sur la RFC 2822. " 
-"Contrairement à :mod:`smtplib` et :mod:`poplib`, qui envoient et reçoivent " 
-"des messages, le paquet email est une boite à outils pour construire, lire " 
-"des structures de messages complexes (comprenant des pièces jointes), ou " 
+"électroniques, incluant les MIME et autres encodages basés sur la RFC 2822. " 
+"Contrairement à :mod:`smtplib` et :mod:`poplib` qui envoient et reçoivent des " 
+"messages, le paquet email est une boite à outils pour construire, lire des " 
+"structures de messages complexes (comprenant des pièces jointes) ou " 
 "implémenter des encodages et protocoles." 
  
 #: ../Doc/tutorial/stdlib.rst:326 
@ -351,13 +347,14 @@ msgid ""
 "applications and other tools." 
 msgstr "" 
 "Le paquet :mod:`json` permet de lire et d'écrire du JSON, format d'encodage " 
-"de donnée répandu. Le module :mod:`csv` gère la lecture et l'écriture de " 
-"données stockés sous forme de valeurs séparés par des virgules dans des " 
-"fichiers (Coma-Separated Values), typique des base de donnée et feuiles de " 
-"calculs. Pour la lecture du XML, utilisez les paquet :mod:`xml.etree." 
-"ElementTree`, :mod:`xml.dom` et :mod:`xml.sax`. Réunis, ces modules et " 
-"paquets simplifient grandement l'échange de données entre les applications " 
-"Python et les autres outils." 
+"de données répandu. Le module :mod:`csv` gère la lecture et l'écriture de " 
+"données stockées sous forme de valeurs séparées par des virgules dans des " 
+"fichiers (*Comma-Separated Values* en anglais), format typiquement " 
+"interopérable avec les bases de données et les feuilles de calculs. Pour la " 
+"lecture du XML, utilisez les paquets :mod:`xml.etree.ElementTree`, :mod:`xml." 
+"dom` et :mod:`xml.sax`. Combinés, ces modules et paquets simplifient " 
+"grandement l'échange de données entre les applications Python et les autres " 
+"outils." 
  
 #: ../Doc/tutorial/stdlib.rst:335 
 msgid "" 
@ -366,13 +363,13 @@ msgid ""
 "slightly nonstandard SQL syntax." 
 msgstr "" 
 "Le module :mod:`sqlite3` est une abstraction de la bibliothèque SQLite, " 
-"permettant de manipuler une base de donnée persistante, accédée et manipulée " 
-"en utilisant une syntaxe  SQL quasi standard." 
+"permettant de manipuler une base de données persistante, accédée et manipulée " 
+"en utilisant une syntaxe SQL quasi standard." 
  
 #: ../Doc/tutorial/stdlib.rst:339 
 msgid "" 
 "Internationalization is supported by a number of modules including :mod:" 
 "`gettext`, :mod:`locale`, and the :mod:`codecs` package." 
 msgstr "" 
-"L'internationalisation est possible grâce à moulte paquets, comme :mod:" 
-"`gettext`, :mod:`locale`, ou :mod:`codecs`." 
+"L'internationalisation est possible grâce à de nombreux paquets tels que :mod:" 
+"`gettext`, :mod:`locale` ou :mod:`codecs`." 
--- a/tutorial/stdlib2.po
+++ b/tutorial/stdlib2.po
@ -8,30 +8,30 @@ 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-11-28 14:10+0100\n" 
+"PO-Revision-Date: 2018-02-14 12:20+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 1.8.11\n" 
+"X-Generator: Poedit 2.0.2\n" 
  
 #: ../Doc/tutorial/stdlib2.rst:5 
 msgid "Brief Tour of the Standard Library --- Part II" 
-msgstr "Survol de la Bibliothèque Standard -- Partie II" 
+msgstr "Survol de la bibliothèque standard -- Deuxième partie" 
  
 #: ../Doc/tutorial/stdlib2.rst:7 
 msgid "" 
 "This second tour covers more advanced modules that support professional " 
 "programming needs. These modules rarely occur in small scripts." 
 msgstr "" 
-"Cette seconde visite vous fera découvrir des modules d'un usage plus " 
-"professionnel. Ces modules sont rarement nécessaires dans de petits scripts." 
+"Cette deuxième partie aborde des modules plus à destination des programmeurs " 
+"professionnels. Ces modules sont rarement nécessaires dans de petits scripts." 
  
 #: ../Doc/tutorial/stdlib2.rst:14 
 msgid "Output Formatting" 
-msgstr "Formatage" 
+msgstr "Formatage de l'affichage" 
  
 #: ../Doc/tutorial/stdlib2.rst:16 
 msgid "" 
@ -39,7 +39,7 @@ msgid ""
 "abbreviated displays of large or deeply nested containers::" 
 msgstr "" 
 "Le module :mod:`reprlib` est une variante de la fonction :func:`repr`, " 
-"spécialisée dans l'affichage concis de conteneurs volumineux ou fortement " 
+"spécialisé dans l'affichage concis de conteneurs volumineux ou fortement " 
 "imbriqués : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:23 
@ -50,10 +50,10 @@ msgid ""
 "adds line breaks and indentation to more clearly reveal data structure::" 
 msgstr "" 
 "Le module :mod:`pprint` propose un contrôle plus fin de l'affichage des " 
-"objets, aussi bien primitifs que définis par l'utilisateur, et souvent " 
-"lisible part l'interpréteur. Lorsque le résultat fait plus d'une ligne, il " 
-"est séparé sur plusieurs lignes et indenté pour rendre la structure plus " 
-"visible : ::" 
+"objets, aussi bien natifs que ceux définis par l'utilisateur, de manière à " 
+"être lisible par l'interpréteur. Lorsque le résultat fait plus d'une ligne, " 
+"il est séparé sur plusieurs lignes et est indenté pour rendre la structure " 
+"plus visible : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:39 
 msgid "" 
@ -69,9 +69,10 @@ msgid ""
 "formats. The grouping attribute of locale's format function provides a " 
 "direct way of formatting numbers with group separators::" 
 msgstr "" 
-"Le module :mod:`locale` offre une base de donnée de formats de donnée " 
-"spécifique à chaque région. L'attribut ``grouping`` de la fonction de " 
-"formatage permet de formater directement des nombres avec un séparateur : ::" 
+"Le module :mod:`locale` utilise une base de données des formats spécifiques " 
+"à chaque région pour les dates, nombres, etc. L'attribut ``grouping`` de la " 
+"fonction de formatage permet de formater directement des nombres avec un " 
+"séparateur : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:72 
 msgid "Templating" 
@ -84,11 +85,11 @@ msgid ""
 "allows users to customize their applications without having to alter the " 
 "application." 
 msgstr "" 
-"Le module :mod:`string` contiens une classe fort polyvalente : :class:" 
-"`~string.Template` permettant d'écrire des gabarits (dits \"templates\") " 
-"avec une syntaxe simple, si simple qu'elle est compréhensible par des non-" 
-"développeurs. Cela permet donc à vous utilisateurs de personnaliser leur " 
-"application sans la modifier." 
+"Le module :mod:`string` contient une classe polyvalente : :class:`~string." 
+"Template`. Elle permet d'écrire des gabarits (*templates* en anglais) avec " 
+"une syntaxe simple, dans le but d'être utilisable par des non-développeurs. " 
+"Ainsi, vos utilisateurs peuvent personnaliser leur application sans la " 
+"modifier." 
  
 #: ../Doc/tutorial/stdlib2.rst:78 
 msgid "" 
@ -98,11 +99,11 @@ msgid ""
 "letters with no intervening spaces. Writing ``$$`` creates a single escaped " 
 "``$``::" 
 msgstr "" 
-"Le format est constitué de marqueurs formés d'un ``$`` suivi d'un " 
-"identifiant Python valide (caractères alphanumériques et tirets-bas). " 
-"Entourer le marqueur d'accolades permet de lui coller d'autres caractères " 
-"alphanumériques sans intercaler un espace. Écrire ``$$`` créé un simple ``" 
-"$``." 
+"Le format utilise des marqueurs formés d'un ``$`` suivi d'un identifiant " 
+"Python valide (caractères alphanumériques et tirets-bas). Entourer le " 
+"marqueur d'accolades permet de lui coller d'autres caractères " 
+"alphanumériques sans intercaler une espace. Écrire ``$$`` produit un simple " 
+"``$`` : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:88 
 msgid "" 
@ -115,9 +116,9 @@ msgstr ""
 "La méthode :meth:`~string.Template.substitute` lève une exception :exc:" 
 "`KeyError` lorsqu'un marqueur n'a pas été fourni, ni dans un dictionnaire, " 
 "ni sous forme d'un paramètre nommé. Dans certains cas, lorsque la donnée à " 
-"appliquer n'est connur que partiellement, la méthode :meth:`~string.Template." 
-"safe_substitute` est plus appropriée car elle laissera tel quel les " 
-"marqueurs manquants : ::" 
+"appliquer peut n'être fournie que partiellement par l'utilisateur, la " 
+"méthode :meth:`~string.Template.safe_substitute` est plus appropriée car " 
+"elle laisse tels quels les marqueurs manquants : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:103 
 msgid "" 
@ -128,8 +129,8 @@ msgid ""
 msgstr "" 
 "Les classes filles de ``Template`` peuvent définir leur propre délimiteur. " 
 "Typiquement, un script de renommage de photos par lots peut choisir le " 
-"symbole pourcent comme marqueur pour, par exemple, la date actuelle, le " 
-"numéro de l'image, ou son format : ::" 
+"symbole pourcent comme marqueur pour les champs tels que la date actuelle, " 
+"le numéro de l'image ou son format : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:125 
 msgid "" 
@ -137,13 +138,13 @@ msgid ""
 "details of multiple output formats. This makes it possible to substitute " 
 "custom templates for XML files, plain text reports, and HTML web reports." 
 msgstr "" 
-"Un autre usage des templates est de séparer la logique métier dub côté et " 
-"les détails spécifiques à chaque format de sortie. Il est possible de " 
-"générer de cette manière des fichiers XML, texte, HTML, ..." 
+"Une autre utilisation des gabarits consiste à séparer la logique métier des " 
+"détails spécifiques à chaque format de sortie. Il est ainsi possible de " 
+"générer des gabarits spécifiques pour les fichiers XML, texte, HTML ..." 
  
 #: ../Doc/tutorial/stdlib2.rst:133 
 msgid "Working with Binary Data Record Layouts" 
-msgstr "Travailler avec des données binaires" 
+msgstr "Traitement des données binaires" 
  
 #: ../Doc/tutorial/stdlib2.rst:135 
 msgid "" 
@ -160,7 +161,7 @@ msgstr ""
 "recourir au module :mod:`zipfile`. Les marqueurs ``\"H\"`` et ``\"I\"`` " 
 "représentent des nombres entiers non signés, stockés respectivement sur deux " 
 "et quatre octets. Le ``\"<\"`` indique qu'ils ont une taille standard et " 
-"dans le style petit-boutiste." 
+"utilisent la convention petit-boutiste : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:166 
 msgid "Multi-threading" 
@ -174,20 +175,21 @@ msgid ""
 "background. A related use case is running I/O in parallel with computations " 
 "in another thread." 
 msgstr "" 
-"Des tâches indépendantes peuvent être exécutées simultanément (on parle de " 
-"concourance), en utilisant des fils d'exécution. Les fils d'exécution " 
-"peuvent améliorer la réactivité d'une application qui accepterait " 
-"d'interagir avec l'utilisateur pendant que d'autres traitements sont " 
-"exécutés en arrière plan. Un autre usage typique est de séparer sur deux " 
-"fils d'exécution distincts les I/O (entrées / sorties) et le calcul." 
+"Des tâches indépendantes peuvent être exécutées de manière non séquentielle " 
+"en utilisant des fils d'exécution (*threading* en anglais). Les fils " 
+"d'exécution peuvent être utilisés pour améliorer la réactivité d'une " 
+"application qui interagit avec l'utilisateur pendant que d'autres " 
+"traitements sont exécutés en arrière-plan. Une autre utilisation typique est " 
+"de séparer sur deux fils d'exécution distincts les entrées / sorties et le " 
+"calcul." 
  
 #: ../Doc/tutorial/stdlib2.rst:173 
 msgid "" 
 "The following code shows how the high level :mod:`threading` module can run " 
 "tasks in background while the main program continues to run::" 
 msgstr "" 
-"Le code suivant donne un exemple d'usage du module :mod:`threading` " 
-"exécutant des tâches en arrière plan pendant que le programme principal " 
+"Le code suivant donne un exemple d'utilisation du module :mod:`threading` " 
+"exécutant des tâches en arrière-plan pendant que le programme principal " 
 "continue de s'exécuter : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:197 
@ -197,11 +199,12 @@ msgid ""
 "module provides a number of synchronization primitives including locks, " 
 "events, condition variables, and semaphores." 
 msgstr "" 
-"Le challenge principal des applications multi tâches est la coordination " 
-"entre les fils d'exécution qui partagent des données ou des ressources. Pour " 
-"ce faire, le module ``threading`` expose quelques outils dédiés à la " 
-"synchronisation comme les verrous (locks), événement (events), variables " 
-"conditionnelles (condition variables), et les sémaphores." 
+"Le principal défi des applications avec plusieurs fils d'exécution consiste " 
+"à coordonner ces fils qui partagent des données ou des ressources. Pour ce " 
+"faire, le module ``threading`` expose quelques outils dédiés à la " 
+"synchronisation comme les verrous (*locks* en anglais), les événements " 
+"(*events* en anglais), les variables conditionnelles (*condition variables* " 
+"en anglais) et les sémaphores (*semaphore* en anglais)." 
  
 #: ../Doc/tutorial/stdlib2.rst:202 
 msgid "" 
@ -213,14 +216,14 @@ msgid ""
 "thread communication and coordination are easier to design, more readable, " 
 "and more reliable." 
 msgstr "" 
-"Bien que ces outils soient puissants, des erreurs de conceptions peuvent " 
-"engendrer des problèmes difficiles à reproduire. Donc, l'approche favorite " 
-"pour coordonner des tâches est de restreindre l'accès d'une ressource à un " 
-"seul fil d'exécution, et d'utiliser le module :mod:`queue` pour alimenter ce " 
-"fil d'exécution de requêtes venant d'autres fils d'exécution. Les " 
-"applications utilisant des :class:`~queue.Queue` pour leurs communication et " 
-"coordination entre fils d'exécution sont plus simples à concevoir, plus " 
-"lisible, et plus fiables." 
+"Bien que ces outils soient puissants, de petites erreurs de conception " 
+"peuvent engendrer des problèmes difficiles à reproduire. Donc, l'approche " 
+"classique pour coordonner des tâches est de restreindre l'accès d'une " 
+"ressource à un seul fil d'exécution et d'utiliser le module :mod:`queue` " 
+"pour alimenter ce fil d'exécution en requêtes venant d'autres fils " 
+"d'exécution. Les applications utilisant des :class:`~queue.Queue` pour leurs " 
+"communication et coordination entre fils d'exécution sont plus simples à " 
+"concevoir, plus lisibles et plus fiables." 
  
 #: ../Doc/tutorial/stdlib2.rst:213 
 msgid "Logging" 
@ -234,11 +237,11 @@ msgid ""
 msgstr "" 
 "Le module :mod:`logging` est un système de journalisation complet. Dans son " 
 "utilisation la plus élémentaire, les messages sont simplement envoyés dans " 
-"un fichier ou sur ``sys.stderr`` ::" 
+"un fichier ou sur ``sys.stderr`` : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:225 
 msgid "This produces the following output:" 
-msgstr "Produisant l'affichage suivant :" 
+msgstr "Cela produit l'affichage suivant :" 
  
 #: ../Doc/tutorial/stdlib2.rst:233 
 msgid "" 
@ -250,11 +253,11 @@ msgid ""
 "`~logging.ERROR`, and :const:`~logging.CRITICAL`." 
 msgstr "" 
 "Par défaut, les messages d'information et de débogage sont ignorés, les " 
-"autres écrites sur la sortie standard. Il est aussi possible d'envoyer les " 
-"messages par email, datagrammes, sur des sockets, ou postés sur un serveur " 
-"HTTP. Les nouveaux filtres permettent d'utiliser des sorties différentes en " 
+"autres sont envoyés vers la sortie standard. Il est aussi possible d'envoyer " 
+"les messages par courriel, datagrammes, sur des sockets ou vers un serveur " 
+"HTTP. Des nouveaux filtres permettent d'utiliser des sorties différentes en " 
 "fonction de la priorité du message : :const:`~logging.DEBUG`, :const:" 
-"`~logging.INFO`, :const:`~logging.WARNING`, :const:`~logging.ERROR`, et :" 
+"`~logging.INFO`, :const:`~logging.WARNING`, :const:`~logging.ERROR` et :" 
 "const:`~logging.CRITICAL`." 
  
 #: ../Doc/tutorial/stdlib2.rst:240 
@ -263,8 +266,9 @@ msgid ""
 "from a user editable configuration file for customized logging without " 
 "altering the application." 
 msgstr "" 
-"depuis un fichier de configuration, permettant de personnaliser le log sans " 
-"modifier l'application." 
+"La configuration de la journalisation peut être effectuée directement dans " 
+"le code Python ou peut être chargée depuis un fichier de configuration, " 
+"permettant de personnaliser la journalisation sans modifier l'application." 
  
 #: ../Doc/tutorial/stdlib2.rst:248 
 msgid "Weak References" 
@ -276,10 +280,10 @@ msgid ""
 "and :term:`garbage collection` to eliminate cycles). The memory is freed " 
 "shortly after the last reference to it has been eliminated." 
 msgstr "" 
-"Python gère lui même la mémoire (par comptage de référence pour la majorité " 
-"des objets, et en utilisant un :term:`ramasse-miettes`\\s (garbage " 
-"collector) pour éliminer les cycles). La mémoire est libérée rapidement " 
-"lorsque sa dernière référence est perdue." 
+"Python gère lui-même la mémoire (par comptage des références pour la plupart " 
+"des objets et en utilisant un :term:`ramasse-miettes` (*garbage collector* " 
+"en anglais) pour éliminer les cycles). La mémoire est libérée rapidement " 
+"lorsque sa dernière référence est supprimée." 
  
 #: ../Doc/tutorial/stdlib2.rst:254 
 msgid "" 
@ -292,19 +296,19 @@ msgid ""
 "weakref objects. Typical applications include caching objects that are " 
 "expensive to create::" 
 msgstr "" 
-"Cette approche fonctionne bien pour la majorité des applications, mais, " 
+"Cette approche fonctionne bien pour la majorité des applications mais, " 
 "parfois, il est nécessaire de surveiller un objet seulement durant son " 
 "utilisation par quelque chose d'autre. Malheureusement, le simple fait de le " 
-"suivre crée une référence, qui rend l'objet permanent. Le module :mod:" 
+"suivre crée une référence qui rend l'objet permanent. Le module :mod:" 
 "`weakref` expose des outils pour suivre les objets sans pour autant créer " 
 "une référence. Lorsqu'un objet n'est pas utilisé, il est automatiquement " 
-"supprimé du tableau des références faibles, et une fonction de rappel " 
-"(callback) est appelée. Un exemple typique est le cache d'objets coûteux à " 
-"créer : ::" 
+"supprimé du tableau des références faibles et une fonction de rappel " 
+"(*callback* en anglais) est appelée. Un exemple typique est le cache " 
+"d'objets coûteux à créer : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:289 
 msgid "Tools for Working with Lists" 
-msgstr "Outils pour travailler avec des listes" 
+msgstr "Outils pour les listes" 
  
 #: ../Doc/tutorial/stdlib2.rst:291 
 msgid "" 
@ -312,9 +316,9 @@ msgid ""
 "sometimes there is a need for alternative implementations with different " 
 "performance trade-offs." 
 msgstr "" 
-"Beaucoup de structures de données peuvent être représentés avec des listes " 
-"natives. Cependant, parfois, d'autres besoins émergent, pour des structures " 
-"ayant des caractéristiques différentes, typiquement en terme de performance." 
+"Beaucoup de structures de données peuvent être représentées avec les listes " 
+"natives. Cependant, d'autres besoins peuvent émerger pour des structures " 
+"ayant des caractéristiques différentes, typiquement en termes de performance." 
  
 #: ../Doc/tutorial/stdlib2.rst:295 
 msgid "" 
@ -324,11 +328,11 @@ msgid ""
 "binary numbers (typecode ``\"H\"``) rather than the usual 16 bytes per entry " 
 "for regular lists of Python int objects::" 
 msgstr "" 
-"Le module :mod:`array` fournit un objet :class:`~array.array()`, ne " 
-"permettant de stocker que des listes homogènes, mais d'une manière plus " 
-"compacte. L'exemple suivant montre une liste de nombres, stockés chacun sur " 
+"Le module :mod:`array` fournit un objet :class:`~array.array()` ne " 
+"permettant de stocker que des listes homogènes mais d'une manière plus " 
+"compacte. L'exemple suivant montre une liste de nombres stockés chacun sur " 
 "deux octets non signés (marqueur ``\"H\"``) plutôt que d'utiliser 16 octets " 
-"comme l'aurais fait une liste classique : ::" 
+"comme l'aurait fait une liste classique : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:308 
 msgid "" 
@ -338,10 +342,11 @@ msgid ""
 "implementing queues and breadth first tree searches::" 
 msgstr "" 
 "Le module :mod:`collections` fournit la classe :class:`~collections." 
-"deque()`, qui ressemble à une liste, mais plus rapide à insérer ou sortir " 
-"des éléments par la gauche, et plus lente pour accéder aux éléments du " 
-"milieu. C'est objets sont particulièrement adaptés pour construire des " 
-"queues ou des algorithme de parcours d'arbre en largeur : ::" 
+"deque()`. Elle ressemble à une liste mais est plus rapide pour l'insertion " 
+"ou l'extraction des éléments par la gauche et plus lente pour accéder aux " 
+"éléments du milieu. Ces objets sont particulièrement adaptés pour construire " 
+"des queues ou des algorithmes de parcours d'arbres en largeur (ou BFS, pour " 
+"*Breadth First Search* en anglais) : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:329 
 msgid "" 
@ -349,7 +354,7 @@ msgid ""
 "other tools such as the :mod:`bisect` module with functions for manipulating " 
 "sorted lists::" 
 msgstr "" 
-"Au delà de fournir des implémentations de listes alternatives, la " 
+"En plus de fournir des implémentations de listes alternatives, la " 
 "bibliothèque fournit des outils tels que :mod:`bisect`, un module contenant " 
 "des fonctions de manipulation de listes triées : ::" 
  
@ -360,14 +365,15 @@ msgid ""
 "This is useful for applications which repeatedly access the smallest element " 
 "but do not want to run a full list sort::" 
 msgstr "" 
-"Le module :mod:`heapq`, permettant d'implémenter des tas (heaps) à partir de " 
-"simple listes. La valeur la plus faible est toujours à la première position " 
-"(indice 0). C'est utile dans les cas où l'application souvent besoin de " 
-"trouver l'élément le plus petit sans trier entièrement la liste : ::" 
+"Le module :mod:`heapq` permet d'implémenter des tas (*heap* en anglais) à " 
+"partir de simples listes. La valeur la plus faible est toujours à la " 
+"première position (indice 0). C'est utile dans les cas où l'application " 
+"accède souvent à l'élément le plus petit mais sans vouloir classer " 
+"entièrement la liste : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:355 
 msgid "Decimal Floating Point Arithmetic" 
-msgstr "Arithmétique décimale à Virgule Flottante" 
+msgstr "Arithmétique décimale à virgule flottante" 
  
 #: ../Doc/tutorial/stdlib2.rst:357 
 msgid "" 
@ -375,28 +381,28 @@ msgid ""
 "decimal floating point arithmetic. Compared to the built-in :class:`float` " 
 "implementation of binary floating point, the class is especially helpful for" 
 msgstr "" 
-"Le module :mod:`decimal` expose la classe :class:`~decimal.Decimal`, " 
-"spécialisée dans le calcul de nombres décimaux représentés en virgule " 
+"Le module :mod:`decimal` expose la classe :class:`~decimal.Decimal` : elle " 
+"est spécialisée dans le calcul de nombres décimaux représentés en virgule " 
 "flottante. Par rapport à la classe native :class:`float`, elle est " 
-"particulièrement utile pour" 
+"particulièrement utile pour :" 
  
 #: ../Doc/tutorial/stdlib2.rst:361 
 msgid "" 
 "financial applications and other uses which require exact decimal " 
 "representation," 
 msgstr "" 
-"les application traitant de finance est autres usages nécessitant une " 
+"les applications traitant de finance et autres utilisations nécessitant une " 
 "représentation décimale exacte," 
  
 #: ../Doc/tutorial/stdlib2.rst:363 
 msgid "control over precision," 
-msgstr "contrôle sur la précision, " 
+msgstr "le contrôle de la précision," 
  
 #: ../Doc/tutorial/stdlib2.rst:364 
 msgid "control over rounding to meet legal or regulatory requirements," 
 msgstr "" 
-"contrôle sur les arrondis pour correspondre aux obligations légales ou du " 
-"régulateur," 
+"le contrôle sur les arrondis pour répondre à des obligations légales ou " 
+"réglementaires," 
  
 #: ../Doc/tutorial/stdlib2.rst:365 
 msgid "tracking of significant decimal places, or" 
@ -407,7 +413,7 @@ msgid ""
 "applications where the user expects the results to match calculations done " 
 "by hand." 
 msgstr "" 
-"les applications avec lesquelles l'utilisateur attend des résultats " 
+"les applications pour lesquelles l'utilisateur attend des résultats " 
 "identiques aux calculs faits à la main." 
  
 #: ../Doc/tutorial/stdlib2.rst:369 
@ -416,8 +422,8 @@ msgid ""
 "results in decimal floating point and binary floating point. The difference " 
 "becomes significant if the results are rounded to the nearest cent::" 
 msgstr "" 
-"Par exemple, calculer 5% de taxe sur une facture de 70 centimes donne un " 
-"résultat différent en nombre a virgule flottantes binaires et décimales. La " 
+"Par exemple, calculer 5 % de taxe sur une facture de 70 centimes donne un " 
+"résultat différent en nombre à virgule flottante binaire et décimale. La " 
 "différence devient significative lorsqu'on arrondit le résultat au centime " 
 "près : ::" 
  
@ -430,12 +436,12 @@ msgid ""
 "decimal quantities." 
 msgstr "" 
 "Le résultat d'un calcul donné par :class:`~decimal.Decimal` conserve les " 
-"zéro non-significatifs. La classe conserve automatiquement quatre décimales " 
+"zéros non-significatifs. La classe conserve automatiquement quatre décimales " 
 "significatives pour des opérandes à deux décimales significatives. La classe " 
-"``Decimal`` imite les mathématiques tels qu'elles pourraient être effectuées " 
-"à la main, évitant les problèmes typique de l'arithmétique binaire à virgule " 
-"flottante qui n'est pas capable de représenter exactement certaines " 
-"quantités décimales." 
+"``Decimal`` imite les mathématiques telles qu'elles pourraient être " 
+"effectuées à la main, évitant les problèmes typiques de l'arithmétique " 
+"binaire à virgule flottante qui n'est pas capable de représenter exactement " 
+"certaines quantités décimales." 
  
 #: ../Doc/tutorial/stdlib2.rst:385 
 msgid "" 
@ -444,8 +450,8 @@ msgid ""
 "floating point::" 
 msgstr "" 
 "La représentation exacte de la classe :class:`~decimal.Decimal` lui permet " 
-"de faire des calculs du modulo ou des tests d'égalité qui ne seraient pas " 
-"possibles avec des virgules flottantes binaires : ::" 
+"de faire des calculs de modulo ou des tests d'égalité qui ne seraient pas " 
+"possibles avec une représentation à virgule flottante binaire : ::" 
  
 #: ../Doc/tutorial/stdlib2.rst:399 
 msgid "" 
--- a/tutorial/venv.po
+++ b/tutorial/venv.po
@ -8,14 +8,14 @@ msgstr ""
 "Project-Id-Version: Python 3.6\n" 
 "Report-Msgid-Bugs-To: \n" 
 "POT-Creation-Date: 2016-10-30 10:40+0100\n" 
-"PO-Revision-Date: 2016-11-19 15:52+0100\n" 
+"PO-Revision-Date: 2018-02-15 00:59+0100\n" 
 "MIME-Version: 1.0\n" 
 "Content-Type: text/plain; charset=UTF-8\n" 
 "Content-Transfer-Encoding: 8bit\n" 
  
 #: ../Doc/tutorial/venv.rst:6 
 msgid "Virtual Environments and Packages" 
-msgstr "Environnements virtuels et Paquets" 
+msgstr "Environnements virtuels et paquets" 
  
 #: ../Doc/tutorial/venv.rst:9 
 msgid "Introduction" 
@ -78,7 +78,7 @@ msgstr ""
  
 #: ../Doc/tutorial/venv.rst:36 
 msgid "Creating Virtual Environments" 
-msgstr "Création d'Environnements Virtuels" 
+msgstr "Création d'environnements virtuels" 
  
 #: ../Doc/tutorial/venv.rst:38 
 msgid "" 
@ -151,7 +151,7 @@ msgstr ""
  
 #: ../Doc/tutorial/venv.rst:87 
 msgid "Managing Packages with pip" 
-msgstr "Gérer les Paquets avec pip" 
+msgstr "Gérer les paquets avec pip" 
  
 #: ../Doc/tutorial/venv.rst:89 
 msgid "" 
--- a/tutorial/whatnow.po
+++ b/tutorial/whatnow.po
@ -9,7 +9,7 @@ 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: 2017-09-22 10:55+0200\n" 
+"PO-Revision-Date: 2018-02-15 01:00+0100\n" 
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" 
 "Language-Team: LANGUAGE <LL@li.org>\n" 
 "Language: fr\n"